Question

I have a discriminated union, such as

type Dish = 
| Eggs
| Spam of Dish

This is basically a linked list, without any content, e.g. Spam(Spam(Spam(Eggs))). I want to strictly perform a computation on this structure, such as counting the length, and memorize the result. In a normal type, I’d use class-local let bindings, but those aren’t available in discriminated unions.

One way to do this would be,

type Count = int
type Dish = 
| Eggs
| Spam of Dish * Count

But this is really messy, when the data I need is easily computable, but I still hope there is a better way (without using external mutable constructs).

Answer 1

After reviewing the answers, I’ve decided to go with a model that seems the least obtrusive to me. I’ve used a modified object to demonstrate how it would work in a slightly more complex scenario.

type StackDef<'a>(v : 'a, s : Stack<'a>) = 
    member val Length = s.Length + 1
    member val Inner = v, s 
and Stack<'a> = 
    | Empty
    | Stack of StackDef<'a>
    member this.Length = 
        match this with
        | Empty -> 0
        | Stack(def) -> def.Length

let Stack (v, s) = Stack(StackDef(v, s)) 
let (|Stack|Empty|) = function | Empty -> Empty | Stack(sd) -> Stack(sd.Inner)
//...
let example = Stack(1, Stack(2, Stack(3, Empty))).Length

1. It doesn’t contain any external mutable state.
2. The discriminated union Dish (or in the example, Stack) continues to exist.
3. The field length doesn’t appear in the union definition at all, nor is it provided by any constructor, just as it should be.
4. The memoized data is associated with the instance, as it should be.

However, having thought about it, by using a static weaver such as Afterthought it might be possible to replace any method such as:

Stack<'a> = 
    | Empty
    | Stack of 'a * Stack<'a>

    [<Lazy>] //custom attribute that would work with a static weaver
    member this.Length = 
        match this with
        | Empty -> 0
        | Stack(_, s) -> s.Length + 1

With a private readonly Lazy<int> __length initialized in the constructor with a delegate that executes the above code, and change the actual content of the method to simply invoking __length.Value.
While F# doesn’t allow union types to contain fields, possibly for very valid reasons, I highly doubt the IL would have such restrictions.
In fact, it would be possible to do a lot of things using some IL manipulation. Maybe it’s something to think about.