Just some miscellaneous thoughts and questions. - Here's a paper ("Beyond Type Classes") that I found interesting. It's a generalization of Haskell's type class system that does type-directed overloading via user-defined Constraint Handling Rules (CHRs). It fits nicely with the logic metaprogramming idea, and it seems like something that would complement embeddable templates really nicely. Not sure about the type inference story.
https://pdfs.semanticscholar.org/ba5c/7c7c719f5e6980b18147d19b5c31113fbb80.pdf - Getting the compiler to understand the idea of flat storage underneath a data(view)type would be really, really helpful. For example, I would like versions of constructors to be generated that take a pointer to datatype-specific flat storage, so you don't have to use malloc to construct something. Here's a quick and dirty example of what I'd like to see the compiler do. datavtype foo = | Bar of (int,int) | Baz of (string, double) // compiler would automatically generate an abstract type foo_ (foo flat) // which represents a union of Bar_pstruct(int,int) and Baz_pstruct(string,double). // the compiler would also generate symintr Bar Baz fn Bar_default(int, int):<> foo fn Baz_default(string, double):<> foo fn Bar_flat{l:addr}(!foo_?@l | ptr(l), int, int):<> foo fn Baz_flat{l:addr}(!foo_?@l | ptr(l), string, double):<> foo overload Baz Baz_default overload Baz Baz_flat overload Bar Bar_default overload Baz Bar_flat - Something like $d2ctype that gives the type of an arbitrary expression would be nice, as would a $tyrep that gave you a sort-level type description for use in templates. - Support for heterogeneous metaprogramming - sometimes it would be convenient to generate things in another language, or more generally, give existing code new meaning. This is probably the slickest thing I've used for doing that, but I don't think it would work as well in an impure language like ATS. http://conal.net/papers/compiling-to-categories/compiling-to-categories.pdf A goal would be reinterpreting subprograms to work on vectors ("SPMD on SIMD") - Edward Kmett talked about this a while ago, and he's about to start implementing it in a new functional language he'll be working on full-time. See also the Intel SPMD Program Compiler. https://www.youtube.com/watch?v=KzqNQMpRbac https://ispc.github.io/ - Here's a few things I think are good test cases for evaluating metaprogramming capabilities. How do you see ATS3 solving the following problems, if at all? * automatically deriving (de)serialization for records and datatypes * generating parsers or API bindings from an XML description (sadly, XML is how many such things are provided) * given a skeleton of an algorithm for, say, matrix multiplication (parameterized by things like loop tiling depth, unrolling amount, etc.), generate a bunch of instantiations with different parameter choices, run and benchmark them, and use/save the best one -- You received this message because you are subscribed to the Google Groups "ats-lang-users" group. To unsubscribe from this group and stop receiving emails from it, send an email to ats-lang-users+unsubscr...@googlegroups.com. To post to this group, send email to ats-lang-users@googlegroups.com. Visit this group at https://groups.google.com/group/ats-lang-users. To view this discussion on the web visit https://groups.google.com/d/msgid/ats-lang-users/c137a67c-3a81-4b3b-a34d-d579b32bd665%40googlegroups.com.