如何编写F#不可变栈类型的接口？现有实现遇类型转换问题

你的核心问题在于原接口的push方法返回的是通用接口类型stack<'a>，而非调用该方法的具体实现类型。编译器无法保证返回的接口实例就是你传入的那个具体类型，因此直接强制转换会触发类型检查错误。

方案一：递归泛型接口（推荐） #

通过递归泛型约束，让接口明确绑定自身的实现类型，确保push返回的是当前实例的类型：

[<Interface>]
type IStack<'a, 'Self when 'Self :> IStack<'a, 'Self>> =
    abstract member Push : 'a -> 'Self
    abstract member Peek : unit -> 'a option
    abstract member Pop : unit -> 'a option * 'Self

接下来实现一个具体的链表栈：

type ListStack<'a>(elements: 'a list) =
    interface IStack<'a, ListStack<'a>> with
        member this.Push x = ListStack(x :: elements)
        member this.Peek() = elements |> List.tryHead
        member this.Pop() =
            match elements with
            | [] -> None, ListStack([])
            | head :: tail -> Some head, ListStack(tail)
    // 空栈构造函数
    new() = ListStack([])

现在修改push_to_stack函数，利用泛型约束直接获取正确的返回类型：

let push_to_stack (x : 'a) (t : 'Self) : 'Self when 'Self :> IStack<'a, 'Self> =
    t.Push x

调用示例：

let emptyStack = ListStack<int>()
let stackWithFive = push_to_stack 5 emptyStack
// stackWithFive的类型是ListStack<int>，完全符合预期

方案二：抽象类替代接口 #

如果不需要严格的接口抽象，也可以用抽象类来处理，虽然返回的是抽象类类型，但避免了接口的类型不确定性：

[<AbstractClass>]
type Stack<'a>() =
    abstract member Push : 'a -> Stack<'a>
    abstract member Peek : unit -> 'a option
    abstract member Pop : unit -> 'a option * Stack<'a>

type ListStack<'a>(elements: 'a list) =
    inherit Stack<'a>()
    override this.Push x = ListStack(x :: elements) :> Stack<'a>
    override this.Peek() = elements |> List.tryHead
    override this.Pop() =
        match elements with
        | [] -> None, ListStack([]) :> Stack<'a>
        | head :: tail -> Some head, ListStack(tail) :> Stack<'a>
    new() = ListStack([])

为什么原代码会报错？ #

原代码里的强制转换(t.push x :> 't)无法通过编译，是因为编译器无法证明push返回的stack<'a>实例恰好就是't类型——任何实现stack<'a>的类型都可以在push里返回其他实现，这种不确定性导致静态强制转换不被允许。递归泛型接口通过约束'Self必须是当前实现类型，从根源上消除了这种不确定性。

内容的提问来源于stack exchange，提问作者Patrick Nicodemus