Hi Don,

Thanks for your reply. My post seems to have been somewhat mangled; the '<' and '>' enclosing the type all vanished! (I will use an alternate syntax) It was meant to read as:

1
2
3
4
5
6
7
8
9
10

type 'a Seqrepr = 
    | Seqrepr of 'a
    | Named of string*'a
    | Plus of ('a Seqrepr)*('a Seqrepr)
    | Minus of ('a Seqrepr)*('a Seqrepr)
    | Mult of ('a Seqrepr)*('a Seqrepr)
    | Divide of ('a Seqrepr)*('a Seqrepr)
    | Max of ('a Seqrepr)*('a Seqrepr)
    | Min of ('a Seqrepr)*('a Seqrepr)
    | Conditional of ('a Seqrepr)*('a Seqrepr)*(bool Seqrepr)

As you have suggested, it would certainly be an option to define a range of types for each underlying type (i.e. float,int,datetime..). The problem with this approach is that I wish to use AST's of Seqexpr<'a> within another type; so, for instance:

1
2
3
4
5
6

type Inst = 
    | Zero    
    | One
    | And of Inst*Inst
    | When  of Inst*(bool Seqexpr)
    | Scale of Inst*(float Seqrepr)

Using this type, I wish to construct generic representations to represent certain actions on the undelying Seqrepr, e.g

1
2

let example (s1: 'a Seqexpr) s2 = 
       When (Scale One s1) (GreaterThan s1 s2)

This would not require the caller provide an argument for the (bool Seqexpr) resulting from the 'GreaterThan s1 s2'. If I were to define different types (e.g. Floatrepr, Datetimerepr,..) and then have a Boolrepr as:

1
2
3
4

type Boolrepr = 
    | FloatGreaterThan of (float Seqrepr)*(float Seqrepr)
    | DateGreaterThan of (DateTime Seqrepr)*(DatTime Seqrepr)
    | etc..

I could no longer allow the arguments of my example function to be generic.

It is also an aim my make the DSL familiar to a user; my fear is it would become rather cumbersome with a proliferation of types.

Any thoughts or suggestions would be most welcome.

Best regards,

Michael