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.
