On Tue, 22 May 2001, Miles Egan wrote:
> Which fails to compile, for obvious reasons.  Is the solution to refactor the
> code into a nonrecursive form? 

In Caml you declare mutually recursive functions and types with a
"rec" and an "and" 

let rec apply_op op = ...
and achieve goal ops = ...

You can also use the same syntax to emulate "where" clauses of Haskell and
other FPLs. 

> Second, the PAIP code makes fairly heavy use of Lisp's symbolic features and
> uses symbols as a kind of type tag but also as printable strings.  I've been
> using variants, both traditional and polymorphic, as a substitute, but they're
> not really quite equivalent.  For example, one of the first programs is a
> simple implementation of the old GPS (general problem solver), which
> manipulates sets of states.  Lisp provides set operations on lists and allows
> printing of symbols, which makes it possible to both manipulate "state" lists
> and print them with very little code.  I can't use variants with the same
> flexibility because I have to provide an explicit ordering if I want to use
> them as set members and I can't print them because there doesn't seem to be a
> way to print something like:

One thing you can do is write polymorphic versions of the OCaml library
set functor, which you'll need anyways as soon as you want to have a type 
recursive with a functor instantiation. Insert long whining and sobbing
here about how this is a pain :-).

For this problem though, it seems that you just want nullary constructors
of a sum type to behave as integers, as in C or Ada. Easy enough with a 
bit of boilerplate code. 

> type t = ONE | TWO | THREE
> 
> as "ONE", "TWO", "THREE".

let pos = function ONE -> 1 | TWO -> 2 | THREE -> 3
let image = function ONE -> "uno" | TWO -> "dos" | THREE -> "tres"

> I'm using strings in the meantime but this isn't very satisfying.

Indeed.

-- Brian


-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr