Next-Generation Macros for Scala

SF Scala: Eugene Burmako, Concrete Next Steps for Scala Macros

Recording: SF Scala: Eugene Burmako, Concrete Next Steps for Scala Macros

all right thanks a lot for the introduction thank you very much for coming again and let's get to the talk is the talks title has been refined over the couple weeks and now I think the time has come to finish experiments with Scala macros it's been a while and what I just joined the PFL in 2011 almost six years ago we started doing crazy stuff so more crazy stuff more crazy stuff and somehow it gets used by people a lot of people that was a quite an amazing story very very enjoyable but actually the reality is that now macros are used in production in many companies and they power I don't know a software that costs millions of dollars and this is probably high time to just stop the experiments stabilize and provide some assurances to our users so here I am with you know trying to say that sky is not falling everything's going to be all right and let's follow the talk to see what's going on first of all yeah Vlad said that everyone knows me that just in case you don't know me I am a former PhD student of Marcin Adair scheme the lab where Scala guys invented recently I defended my PhD dissertation and moved here to San Francisco to work at Twitter and here I'm leading the semantic tool in effort using something called Scala meta we're building useful tools for Scala a lot of this effort is open source probably heard of Kalamata and now to something completely unrelated I'm also the author and maintainer of the current Scala macro system and that's what this talk is going to be about well let's get acquainted a bit more so well what are you looking for so just some hypotheses on my side well first of all maybe you watched one of the margins keynotes or Adrienne's Kino adrian is the lead of the Scala compiler team at live band and you heard that macros are going away so you're using macros and you're actually freaking out what's going on so if you're in that category you'll get your answers today secondly maybe you know you already heard about new style macros which we introduced that Scala days New York and Berlin last year so they work in IntelliJ that's amazing and maybe you would like to know what will happen to them you will get your answers to so I see you know happy nods in the audience I'm probably doing the good job also well maybe you already used these cool macro notations and you would like cool best macros sure this talk is for you more nuts or amazing I'm really on fire so anyway finally if you like Scala you would like to learn more about this language or your APL geek you also have fun all right goals of this talk well first of all I would like to explain the rationale between some of the decisions of the Scala language committee behind macros for instance why are macros going away if they're doing so well if everyone's using them secondly this will be a minor part of the talk unlike some of my previous talks I will present our latest developments and well on a couple of examples I see how to write macros in yet another new style macro system and finally what I think is the main goal here is to show that we know what we are doing we actually have settled on the concrete course to productize macros also non goals this is always a hard one but our time is limited well first of all I will not be introducing macros or explaining what they're good for because there have been a bunch of talks a lot of talks like dozens of them and I've just speak one of them it's my talk from 2014 but well it's still relevant also Scala meta so some of you who watched the evolution of Scala macros they know that it's been linked to this project cost kilometer which aims to provide next generation metaprogramming API for Scala so I'm not going to talk about this as well just take a look at our website it provides more information finally over the last year the last two years I've been presenting a lot about Scala meta itself the part that is not related to macros there have been some super exciting developments in that regard for instance the semantic DB thing that I would come up with here at Twitter and also work jointly with the open source community including Scala Center but again our time is limited so please check out our latest talk with my colleagues - hood from Twitter we've just arrived from Copenhagen Scala days where we presented this thing so hopefully the video will be up soon and for now there's a link to the slides I'll post this slide deck afterwards so you will be able to click the stuff and finally daddy is a big new thing so just recently in Copenhagen last week they had the first preview release that's actually a huge deal because that is going to become Scala 3 that's official and well everyone's curious what's in there unfortunately the stock is also not about this and well here are the two links of the presentations by the members of the data team I'm no longer at EPFL I'm not in the data team so well don't quote me on that just learn from the source ok let's begin with our journey first of all all style macros by saying no style I mean the macro system that's currently in production it's been an experimental language Fisher if I had two hands available I would say quote unquote on the experimental word because even though you have to import Scala dot language that experimental macros well no one really cares everyone's using this feature so the fact that it is a standard for compile time meta programming and it's been available for five years since Scala 210 which was released in the beginning of 2012 and it's become about almost a mandatory feature that well virtually the entire scala community depends on starting from such libraries of scala test specs shapeless and so on and so forth and the basic idea behind macros even though I promised not to introduce them still I need to say something as you write functions against something that we call a reflection API which is exposed in this calorie flag jar part of the standard distribution of the language and then the compiler executes this functions at compile time so basically in these functions you get some ast s abstract syntax trees that represent your code and then you can generate more code you can analyze the Dacey's lots of exciting stuff well that's pretty cool but why do we need this not many languages have macros well we don't count C macros because that's that's not that C Macker they basically do textual substitution as opposed to you know much more principled a sea-based meta programming that we do so not not a lot of languages well template Haskell maybe comes to mind but it's not a common feature why have it in Scala well when I just joined the PFL I wanted to have fun but obviously that's not a good reason what was what was something that impressed Marcin on their ski the creator of the language is that macros they provide more power in a principled way so it is possible to do things like cogeneration more advanced age aesthetic checks so Scala step system is already advanced but macros really push the envelope and the finally we can do better gear cells so all that is covered in the talk that I was referring to before watermark is good for but for knowledge stuff of that so just the summary people have found this technology useful and what's the problem with mic receive they're so great why do we need to do something else well first of all here's the bad news something that I've been conveniently omitting in the beginning of the talk actually current macros they require you to know about compiler internals this is bad actually because when I just joined EPFL I spent several weeks or several months actually just you know together with people who invented the compiler who wrote it just onboarding well that's hard and essentially we impose this tax on a lot of compiler writers also while compiler api's they're optimized towards compiler writers you know the full-fledged work full of compilation and you don't necessarily need all this power to program what macros as they are right now in Scala and as a result the API is huge and you basically have to learn it and finally our to support is lagging behind so still five years after the introduction of macros some of them they cannot expand in IntelliJ this is pretty crazy if you think about it so you write a library it uses cool features of the language you keep the really you know push the boundaries of expressiveness only to have your users well basically get red squigglies in IntelliJ this is bad and deliberate Moore and IntelliJ so what that's obviously a huge problem these macros they require compiler internals and as a result IntelliJ is a completely implementation of the scholars type checker so it's not compatible with Scala C compiler internals as simple as that so that's up that's too bad and also one corollary I mentioned re Scala 3.0 this new hot thing it's also a reemployment ation of Scala type checker so basically doesn't support current macros at all so well two main reasons first of all the API is too hard and secondly edges doesn't scale to the future so what do we do about that oh yeah that's uh something that they already mentioned briefly so we are gonna continue supporting Scala macros until the last release of Scala to X and that's going to be Scala 215 it's actually the future is really close if you think about it so currently we're on 212 and you know just a couple of years and bye-bye scroll to X and due to the reasons mentioned the Buffs color three-point X is not going to support macros so we need the solution and we need it fast so that's that's why the stabilization effort so that we end up with something usable way before that is here so you guys have time to migrate okay what did we do to make the situation better of course we recognize that a couple years ago when that I just started and we had some ideas well first of all me and Dennis Chabal in my former colleague at EPFL here's to a PhD student and I've already graduated we started a project called Scala Mehta just like Scala reflect was and is currently powering old-style macros we wanted Scala matter to be a better metaprogramming API for new markers and as early as in 2015 202 and a half years ago actually by now in San Francisco and in Amsterdam at Scala days we show the prototype of new macros that were bad better than the old ones and that were cross-platform that is potentially supported in Scala see IntelliJ and in dot e in in those times that it was a closed source development that was done internally at the web unfortunately this first attempt it didn't go well so this happens in research sometimes it just fails so nothing has come out of this attempt really then a year afterwards we had something better so we've already thought some of our IP Island in New York and in Berlin we presented new style macro notation so that's the cool thing that worked with IntelliJ and later on when Daddy became public we actually added support for diary finally we delivered on our promise for a macro system that works in all platforms sauce called compiler platforms and that was pretty awesome surprisingly well even though that was a technical preview people have started using it because IntelliJ support so I should have you know foreseen that but really it ended up been a cure feature so actually macro notations that work in IntelliJ that you can expand well how cool is this that definitely was fun material for demos and it was very practical so you can to learn more you can go to this website on both repoed github and start using this technology right now it's a well even though it's a technology preview people are using it in production so there's something good about it another attempt it started with the independent research at EPFL so right at the time when I departed from was one to work here in San Francisco Twitter we started a semester project with another PhD student in the marketing lab his name was Pingo and he did another attempt at a macro system it was inspired by Scala meta but it ended up being something quite different and as a result según he did an amazing job so he did some breakthrough research and showed us how to implement def macros based on Scala meta so those of you who follow this more or less closely you know that we've been having trouble with that and thanks to Fagin we now know the way and the new prototype is based exactly on this so this really cool research is available also on github it only supports daddy and it's not supposed you know to scale further just because it was an experiment a successful one but still an experiment so you could take a look afterwards at what the cool stuff that something has come up with and finally what we're going to do with all this research what are the next steps well just the last month before the Scala days conference we figured out that well we need the to summarize everything and move on and there's a result based on the Scala met API as it is right now I've created the prototype that supports both macro annotations and def macros so in the current prototype we have a compiler plugin that for Scala 211 actually can expand with new style macros and we're also partnering with people from epfl Scala Center and the also jetbrains to deliver support for other platforms so that's that's something that they created a whole new repo for this Scala macro slash Scala macros currently it's empty was just a couple issues and the big pull request which can contains this prototype that I was mentioning Oh before I bore you completely let me just show some code because that's definitely the most exciting part those of you who have been following our developments you probably won't find anything super surprising well after all our goal is not to provide something completely groundbreaking but rather to ensure a smooth migration path though definitely if you're relying on compiler internals and your microbes just you know Caston the symbol table or global maybe saying see those internal that something well it's not going to scale because that's compiler internals alright so what we'll be looking at is the macro notation and an inclusive materializer so first the macro notation thing here we have a macro that can be applied to objects and then this it's like you know the apt rate at the moment and then we take apart the contents of the objects namely we extract the statements and afterwards we generate a main method using this notation called quasi quotes and we put the contents of the object into the main method so basically unfortunately I'm pretty limited with the microphones or have to select text but maybe you know I can look up something for you just to show an example of the macro oh yeah very good name and then test and that will come handy a little bit later so here this is something that would have worked if not the limitation of Scala test but anyway you put this annotation main on an object and then you can run this main method as seen here so as I promised just a replacement for the app trade which is by the way going away in dari so speaking of dotty there's it's significantly different from Scala see from Scala to X and recently thanks to the a release that happened last week the data team they actually published some documentation about the features that are changed for instance type inference and implicit serrations and so forth and the newly added feature so for instance I don't know whether you know but in that is actually added in amps as a native language feature that sounds really exciting so please check out the docs so anyway moving on from macro notations which again as I promised don't have anything groundbreaking you just match code using quasi codes and then you meet more code let's do implicit materialized errs so materialized errs they support the type class pattern that in Scala is provided by implicit parameters so in this example we have a trade serialize which will call a type class and then we have some instances of this type class you know def int here so let me scroll up def in here and there string here which truly civilize these guys to Jason and the cute thing about macros is that they allow you to generate type class instances on the fly so we can write a macro and this is tentatively the syntax that we'll be using to define macros and you style macros and we say that it's an implicit method which means that it will be called every time when there isn't a look up for an implicit instance and then at compile time it will generate instances for every type that is called with for instance if you want to serialize some domain object that you're using in your application you'll be able to do that so for every possible case class it will be possible to generate some code and let's see how this happens so basically for every T that you pass into the macro here we go through all the vowels and then we filter those walls which are case meaning that there they are in the first parameter list of a case so probably if you've written records before then you know how hard it is actually to write an equivalent of this code in the current micro system so you'd have to do member a member lookup and then you have to filter you know case X exercise I want even explain what it is because well compiler internals and now as you can see it's really a really neat and very concise and afterwards for every field that we obtain this way we actually create a piece of code that you know serializes this field so in particular we serialize the name into JSON and afterwards we recursively generate a serializer for the type of the field so basically when we say pre dev dot implicitly serialize of F dot info we do another implicit lookup for the type plus instance for the type of the field and finally we emit some padding so well it doesn't matter much as a result after we create the fuel generation logic we are now ready to synthesize the type class instance for this particular type so as you can see it's a bit verbose but this is how it's encode DEP classes in Scala we create an implicit object and then we implement the interface it's expected with afterwards we just instantiate the string builder well this code is horribly mutable but hey that's just a prototype macro and afterwards after emitting opening and closing braces we splice our serialization code with this dot dot dollar notation so basically even if you are not familiar with macros you can probably more or less understand what this code does so it's like string interpolation and a lot of languages say bash or whatever else are in Scala so basically here we assemble code snippets Scala code snippets inserting things that we generate dynamically and so well now this is it something of some parts of the demonstration that are worth being mentioned is that there's an there's a way to inspect types that are passed into macros with you know our latest developments it is also possible to just you know enumerate members of those types and finally it's still ok to use quasi codes so the best parts of the existing macro system namely quasi codes and you know the but which functionality to talk to the compiler they still remain and what we dreamed is you know exotic use cases that require access to compiler internals and finally just to let's take a look at what's enabled by them by this implicit serialization macro so we have this method called serialize which requires that it takes an input of a type that's serializable and it just you know obtains the serialize ER from the method itself and applies it to the input it's basically super straightforward that's because with the type class pattern well all the logic is actually in that class instances not with this particular methods and finally we call this method serialize on some domain object which which is defined on line 14 basically some random case class which has an infield in a string field and we ensure that the result is actually what you expect also this does work and that even though it looks simple that was a big progress for us because this macro system can scale to scholars scholar to scholar 3 and IntelliJ so we're working on other implementations of 2 to make this a reality to make something that you can play with ok back to slides we visiting the live demo that was promised on this slide and let's have a quick Q&A because probably some of you have questions and I try to anticipate them well what happens to this prototype to the spool request well together with the folks from live band the EPFL on the Scala Center we review it we agree that that's what we want and then we productize it by the end of this year we plan to have more or less stable which is a better quality stuff you can use to migrate your macros and in the meanwhile you can also contact us that will be a link afterwards in order to be super early adopters the team that's currently working on this effort it's myself I'm doing the Scala C compiler plugin probably this thing is going to be distributed there's a compiler plugin at least for 212 and 213 there's Mikhail from JetBrains who's working with us on the IntelliJ team and all of from the Scala Center he's agreed to do a Dahlia implementation so what we're pretty well staffed and we hope to deliver some concrete results quite soon and also with you know we are currently discussion in discussions with compiler maintainer x' this called 2x team and the Scala 3.0 team about long term maintenance so macros are supposed to become a stable feature of the language so we need you know long term all owner of this feature and well world we're going to figure this out speaking of platforms which were going to support I mentioned before that my compiler plugin is supporting 211 but it's actually quite unlikely that 211 will be in the final release lululemon support if we take into account you know the whole zoo of Scala version so currently people are using two to ten to eleven to twelve with the current release and 213 is upcoming and then to fourteen so that's that's a lot of stuff so we just like like to start with scale to twelve which has been around for a year already almost a year and then move on from there also IntelliJ just as you've seen on the previous slide and Scala 3.0 aka Dali so as I mentioned before we would really appreciate your involvement with the Scala 211 implementation it shouldn't be so different from skulls as well just because compiler internals in 211 and 212 in those areas that - macros they were more or less unchanged but again well maintaining this thing is quite hard so we would really appreciate your migration strategy that something if you have macros in production you're probably interested in that well we're going to support at least we want to provide a clear migration path for all style macros that don't use compiler internals which means that no cast to global or symbol table and no usage of api's which are marked as internal also we want to support those macros the school new macro notations that will introduced a year ago from Scala meta paradise and how we're going to do that whether they're going to be you know maybe cross-compilation shims that you can enable in your projects and cross compile or maybe there will be a scholastics base the rewriting strategy so Scala 6 is a code your automated code you're writing tool is developed it's call center well we don't know yet but we will definitely provide an answer in the coming weeks so please follow our issue tracker also speaking of discussion so definitely we're looking for feedback because this macro system is intended to be used it's not something you know in itself and as a result if you if you have a lot of macros or if you have complicated macros then it says the right time to contact us so I created the Keter Channel please drop by and I'll try to answer everyone's questions and there'll be V place to chat about the new style macro system also Scala madam something the Scala method actually started several years ago almost four years ago as they replay well as the foundation for better macro system but over years we figured that there's a whole new niche for Scala meta which is basically dev tools and since then such tools of Scala from T and scholastics were created to make use of unique functionality that we provide in Scala meta that's not available in the current compiler and as a result recently well in May we decided to separate these two projects so Scala meta is going to have an API that two authors will be using and Scala macro signal leaves the this part that used to be in Scala meta it now lives in the skull of micros organization so as you've seen the link here it says Scala macro slash Scala macros so that's I think God is going to be good for both projects because it provides clear focus so just so that you guys have been more clear understanding Scala meta henceforth it's for dev tools and Scala macros well naturally it's about macros the api's that they're going to be using they will be the same but we need to separate them now we've come to the conclusion of the talk so I hope that have not tired you with the details I try to be as concrete as possible without you know being you know happy about new experiments and now I would see how what we heard today well first of all credits this project is a joint well as a result of a lot of efforts so as we see in this credits section in the project treat me well a lot of contributors they made Scala macros possible and it's really hard to even list those people because it's really more than 50 people who somehow contributed with code with ideas with bug fixes it's amazing the scale of the project and in my dissertation I did my best to summarize and categorize contributions from the community so please check out the dissertation for you know completely sick people and finally this concrete project these macros that I've been presenting today they've been made possible by efforts from penguin someone whom I've mentioned it Martin's PhD student who developed a prototype with groundbreaking contributions and also together with Allah from the Scala Center we've been working on the previous version of Scala meta paradise and thanks to all of we've exposed and will describe the shortcomings of the previous approach all right let's sit about the credits let's get back to the slides finally just to summarize what we've heard today first of all I'm really glad to announce that research in Scala mattress is basically over we will productize what we currently have because macros they're really useful as they're right now and we're very interested in providing a stable foundation for micro users finally you can take a look at our current progress at Scala macros fresco macros that's an open circuit hub project and please submit your feedback and maybe if you'd like to get involved come and chat with us on Twitter and finally something that this message that I would like to get across is that Scala Met and Scala macros they're not two different projects so even though the user virtually the same API the the world target audiences they are different so you use column at if you want to write dev tools and you scale macros basically if you want to write Mack Road finally just before I finish the talk that's the mandatory were hiring announcement so speaking of Scala meta this is something that we're doing here at Twitter so we've used kalamatas the foundation for better tooling for Scala Scala matter is 100% open source so thanks you know the generous arrangement that we have with Twitter we can have all the functionality available for everyone and it's not just you know empty words we're actually working with people from the community including the Scala Center for instance and ensuring they can build tools on top of that and previously I mentioned my talk together was to food my colleague from Twitter he's over there by the way you can stalk him of the attack and if you check out the slides and the video is coming up soon you'll be able to learn more about the agenda and finally just being me contact me if you'd like to join us we have you know a lot of exciting developments ahead of us and well we are really going to make skull tooling better okay thank you very much thank you very much and I'm going to take questions now [Applause] all right so first of all thanks for the kind words that's exactly the response that I wanted to get so we're on the right track and on to about the milestones questions so what kind of milestones we have please check out the issue tracker so at the moment it's like you know super early days of you know publicity for this project and less than a week ago I push this to github so we'll be providing updates in the coming days and yeah that's that's the best reference point if you have you know any technical questions you know minor ones I feel free to contact either me directly or Peter thank you okay any other questions guys okay that's a good question so basically at the moment as I mentioned the prototype is for Scala - 11 the prototype compiler plugin but were actually planning to provide long-term support only for 212 and onwards well yeah that's that's a bit of confusion my fault actually be - Evan think is a prototype and the implementations that worship who they will start with 2:12 we needed to have something going and my default version at the moment before Scala version on my laptop is called 211 so they said well let's do it for Skulltula okay Jakob please the question of distribution and packaging so currently we have this column at a paradise plugin and we have this column a Crow's plugin are they different yes they're different and well they're going to be incompatible because the API is for instance up let me show the source code so here we see that we import scholar that macros that underscore some package that we haven't seen before and Scala meta paradise it uses Scala metadata underscore so you will not be able to use this macros you know will be two plugins together probably but as I said we plan to provide a migration path from muscala meta paradise macros to be new new markets alright any other questions please [Music] right so this is the question about this Kalamata project the dev tools part and the the question is so our current semantic - an effort at Twitter it's let me just - of the slides [Music] we give this light green I guess silently okay this one yep okay so our current strategy for semantic dueling here at Twitter is that were based on two technologies firstly Symantec DB we should grown from Scala meta it indexes the scholar programs and remember semantic information about them and then we feed this info into something called kite kite is an open source project developed at Google and it powers their semantic student effort kite is a polygraph schema for semantic information plus a company in tools that deal with the schema and the peculiar fact about cases is that indeed it supports several languages including you know Python go C++ Java you know the big languages at Google and were also adding support for Scala so how it was related to Scala macros you would ask well completely no relation and this these questions is exactly why I decided to split Scala Matins callimachus into two parts so against Callanetics for dev tools and Scala macros is for writing macros and Cal macros it only supports Scala because well this color name we skull apart in the name but I would be glad means to actually would be glad to answer your questions if you have more questions about guys or you know the entire infrastructure let's mention in the slides ok anything else guys right please yeah by the way look over there was no big motto but happy yes they're both sides both just by waiting - all right so the question was about deaf macros so as I mentioned the in one of the slides before it took us quite a while to figure out something that works with deaf macros so first in 2015 we started trying we failed 2016 only supported macro annotations and finally now in 2017 thanks to England's work were on the right track when you can start migrating your macros well as I mentioned before at the moment the project is empty so let me just show the github page so here we go just one file amazing huh but also it's not a complete fraud relax guys we have this pull request which says mr. macro API is in a prototype implementation yes yes that's correct yeah so actually what we want to do now is to discuss this with people from epfl on light band and once we agreed it on the high level this is what we want we will merge it and then we will publish in all the instructions how to get started so please stay tuned probably join our guitar channel and as new releases will get pushed as something playable gets published we will definitely notify you guys thanks for the interest yeah go ahead please it's a restart today given that is not quite there yet and like especially if one came to us members would be your advice that would be to start with my paradise and my way all right so the question is if someone were to start were to write their first macro today what to use that's a tough one because yeah as you've seen there were a lot of experiments I would actually either use scale reflect something that is there at the moment if this is something fairly small if you anticipate this is going to be a huge macro than probably just wait why well as I mentioned before we have concrete milestones so by the end of this year we'll have something that you'll be able to use in production actually it's not be the final release but it should be solid so the weight is not that big and if you need to do something right now skál reflect is pretty ok actually so people have been using it to achieve their goals it's well definitely very rough around the edges because you need to know compiler internals and stuff but you can actually use it to get your job done so if it's something urgent and small feel free to use call reflect otherwise just don't bother until well several months at least alright another question please you mentioned that yeah the previous approach which was the pre conversion and the degrees and mapping factors were between themselves crease with the guy I'm not yet sure about the actual sort of new courthouse he could has wicked awesome expected astoundingly long to know what to be doing sort of a very big overview of sort of the core model difference that is here okay that's a great question very technical something that honestly I've been afraid to bring up because I'll probably just several people in the audience know what's what this is going to be about but anyway yeah of course I'll repeat the question right now so what's the difference between the between Scala meta based macros which are based on so-called converters and the new approach that was implemented at EPFL called Gestalt okay I'll try to be a real quick anyway so when we just started with Scala meta as I mentioned before it was a reaction to complexity of compiler internals that are used in the current macros and well what we did we basically designed our own data structures and just to simplify stuff because we compiler it's a it's a grab bag of functionality so in some of my earlier talks well I'll just no show the slides some of the earlier talks I mentioned that there's several dozen data structures that are used in the current scarf like API and we said well what the hell we're going to unify them and we're only going to use just one data structure please that was an awesome thing it was a pipe dream a little bit that we must have delivered on that and the key thing if you're introducing your own data structures is that you need to convert between compiler things and our own things we try to implement this actually three times I have a god I cannot believe that I try to do the same thing three times and fail three times single but yeah every new attempt it looked really good and we had the right people but ultimately what we learned is that compiler data structures they're just too complex to have bi-directional mappings so for instance the Scala compiler it does a lot of the sugaring which is that it Maps advanced language features like for loops I don't know context bonds into low-level features that you can then translate to the JVM bytecode and this kind of transformations they're really hard to undo and well we tried we failed so I wouldn't recommend this to a friend and so that was it for converter based macros this is the Scala meta based approach come at a paradise in particular what some goon did he independently reinvented Scala reflect so that was pretty amazing scholar reflect is the old macros and old macros they basically expose compiler internals there's actually a really neat trick now I won't go into the horrible anyway so that's a really cool trick when we use the cake pattern and abstract types and extractors so quite cool if you're interested take a look at the pull request to submit it then you're able to provide the thin layer of section over compiler internals and this is it since there are compiler objects underneath you don't have to write any converters and you ship the macro system immediately how cool is this and so the key inside the string being provided is that even though this approach failed in Scala effect we can actually make it better using insights collected in Scala meta so thanks to Scala matter we have reliable quasi codes without any compiler hacks and thanks to Scala meta we understood that we need a better semantic API and we need to expose you know less surface of the API so that Kalamata show that it's possible and now we know armed by experience both from sky reflectance Kalamata as shown in Gestalt we believe that we are on the right track so hopefully this is not too much of a convoluted explanation all right and it smells guys all right no other questions thanks a lot thank you [Applause] [Music]