F#子类和记忆化

在F#中，可以定义一个基类和派生类来实现继承性。然而，当使用记忆化来保存计算结果时，派生类的实例可能无法正确地处理缓存的值，因此需要一种更加通用的方法来解决这个问题。

一种简单的解决方法是使用一个不同的类型来表示缓存的数据，并在基类和所有派生类中使用相同的类型。这样，任何派生类都可以处理任何缓存值。

下面是一个示例，演示如何使用记忆化和子类来计算Fibonacci序列：

type MemoCache<'T> =
    private memo : Dictionary<int, 'T>
    new () = { memo = Dictionary() }
    member this.Lookup n = 
        match this.memo.TryGetValue n with
        | true, v -> Some v
        | false, _ -> None
    member this.Add n v = this.memo.[n] <- v

type FibBase() =
    let memo = MemoCache<int>()

    abstract member Fib : int -> int

    default this.Fib n = 
        match memo.Lookup n with
        | Some v -> v
        | None -> 
            let v = 
                match n with
                | 0 -> 0
                | 1 -> 1
                | _ -> this.Fib (n-1) + this.Fib (n-2)
            memo.Add n v
            v

type FibRec() =
    inherit FibBase()
    override this.Fib n =
        match n with
        | 0 -> 0
        | 1 -> 1
        | _ -> this.Fib (n-1) + this.Fib (n-2)

type FibIter() =
    inherit FibBase()
    override this.Fib n =
        let mutable p = 0
        let mutable c = 1
        for i in 1..n do
            let t = c
            c <- p + c
            p <- t
        p

MemoCache类定义了一个私有