Been playing and, well... it's amazing stuff. Here are the problems
I've run into:

* as constructor declarations,
nil:List X    and (----------! are inequivalent, strangely (?)
                  !nil:List X)

* in

     (   X : *    !                            ( xs : List X ;  x : X !
data !------------!  where (--------------! ;  !----------------------!
     ! List X : * )        ! nil : List X )    !  cons x xs : List X  )

The order of x and xs above the line is significant. As it stands, it
won't elaborate. Replace the top line with x:X ; xs:List X and it
will. I have seen other similar problems requiring me to reorder
things to get it to elaborate.

* If you define a function type without dummy arguments (i.e. plus: Nat
 -> Nat -> Nat instead of plus x y : Nat) then I can't work out how to
 write the program interactively. I tried "lam x <= case x" but that
 didn't work... (shoudl there be a new 'abstr' strategy for defining
 by lambda abstraction?)

That's the obvious things. I also can't get a non-trivial instance of
the 'oh So true' trick to work, but that might be operator error, or
it might just been you haven't written enough of the proof search code
yet.

Jules




Reply via email to