I\'ve been doing some OCaml programming lately to learn the language and to get more acquainted with functional programming. Recently, I\'ve started to think that I\'d like
An interesting solution is to use polymorphic variant:
type bexp =
[ `And of bexp * bexp
| `Or of bexp * bexp
| `Xor of bexp * bexp
| `Not of bexp ];;
type nbexp = [ bexp | `Nop of nbexp ];;
Note that polymorphic variants are trickier than normal ones, but allow extension of type.
An interesting example of expression evaluation, with extension, using polymorphic variant can be found in a test directories of the ocaml source, see the svn
Update: Ocaml now has extensible types. http://caml.inria.fr/pub/docs/manual-ocaml/extn.html#sec246
Here you would do
type bexpr += Nop of bexpr
Hey, these are supposed to be Algebraic data types, right?
Right. And algebraic data types are constructed by tagged (aka discriminated) unions and products. What you want is just a (non-tagged) union, which is not an algebraic data type and isn't supported by Haskell. OCaml has polymorphic variants (see other answers).
Typed Scheme does support non-tagged unions, so you may want to check it out.
As you yourself correctly surmise, this is not possible in algebraic types. I agree with Apocalisp's suggestion that you may simply wrap the "inherited" part of nbexp
in a constructor of its own.
I would add that the lack of inheritance of algebraic types is part of their wonderfulness. This means that an expression such as And(foo, bar)
is umambiguously typed, and that casting (either up or down) has no role to play in the type system. This yields both greater safety and greater clarity. It does of course require of the programmer that s/he explicitly handle the cases where s/he wants to interact with the bexp
parts of nbexp
, but if you think about it, that's how the increased safety and clarity is realised in practice.