hello,
I am just moving to ATS2 now and I find very hard to read errors of
constraints because the compiler does not say which line it refers to.
Is there a trick to locate these kind of errors ?
implement main0(argc, argv) = let
val e = event_of_list $list_vt{int} (1,2,3,4,5)
val (e’, last_e) = event_vt_last e
val l = list_of_event e’
val () = ( case+ last_e of
| ~Some_vt (x) => println! ("last event is ", x)
| ~None_vt () => () ): void
in
list_vt_free l
end
This is an error from the ATS compiler. Could you post your code somewhere
so that I can take a look?
It seems that a generated constraint cannot be handled by the
constraint-solver.
Though I am still not clear about how events are going to be used, I feel
that a list-based implementation is naive.
Nonetheless, it is a good start.
Here is a rule of thumb for programming in ATS (and in many other languages
as well).
When you use list to implement event, you in general do not write code
manipulating lists directly. Instead,
you try to use existing list-funtions to do what you need. Only if what you
need cannot be implemented (efficiently)
based on existing functions, you try to implement it on your own. For
instance, I just added list_vt_unextend for
your need of list_get_last. If you implement list-functions on your own,
you want to do it in a way so that the code
may be moved into the list-library.
By now an event of type T is just a collection of values of type T (mainly
because event query can be sampled at fixed rate and more than one value
can occur between event queries)
I just use list now because it is the easiest way to implement it.
I just work on concepts first, I want to make sure I can make real usage of
it before working more on implementation.
my code ported to ats2 is now here :
My next step is trying to use this paradigm for a simple opengl
visualization with Glfw
// get last event
implement{a} event_vt_last(e) = @(e’, x) where {
fun last {n:nat} (e: list_vt(a, n)): [b: bool] option_vt(a, b)
= case+ e of
| ~list_vt_cons (x, ~list_vt_nil()) => Some_vt{a} x
| ~list_vt_cons (x, y) => last y
| ~list_vt_nil () => None_vt{a} ()
val l = list_of_event{a} e
val l’ = list_vt_copy l
val e’ = event_of_list{a} l
val x = last l’
}
I changed the constraint solve a bit to report this issue in a more
meaningful way.
I see some serious problems with the following style of implementation.
I would like to get you on the right track of using ATS to implement events.
What is really an event? If you treat ‘event’ as a class, what kind of
methods
do you want to support?
