Generics 如何获得具有可变参数数的整数元组的乘积？

我没有料到

size\u to\u total\u size

中的

x

参数需要TotalSize成员。这感觉像是一个编译器错误

---

我不知道如何让它工作。有什么想法吗？

您缺少另一种“帽子”类型：

type TotalSizeToken = TotalSizeToken with
    static member TotalSize(_: TotalSizeToken, (a,b,c,d,e)): int = a*b*c*d*e
    static member TotalSize(_: TotalSizeToken, (a,b,c,d)): int = a*b*c*d
    static member TotalSize(_: TotalSizeToken, (a,b,c)): int = a*b*c
    static member TotalSize(_: TotalSizeToken, (a,b)): int = a*b
    static member TotalSize(_: TotalSizeToken, x: int): int = x

let inline size_to_total_size x = 
    ((^s) : (static member TotalSize: TotalSizeToken * ^s -> int) TotalSizeToken, x)

let t = size_to_total_size (1,5) // Error: Expecting a type supporting the operator TotalSize, but given a tuple type.

其中必须有两个，一个是传递的参数，另一个是表示包含重载的类的参数

否则，它将永远不会查看类，只查看元组，而元组类型中没有此类方法。

type TotalSizeToken a*b*c*d*e
let inline size_to_total_size x = 
    let call (t:^T) = ((^s or ^T) : (static member TotalSize: TotalSizeToken * ^s -> int) t, x)
    call TotalSizeToken

静态成员TotalSize（x:TotalSizeToken）：int=
将x与TotalSizeToken（a、b、c、d）->a*b*c*d匹配
静态成员TotalSize（x:TotalSizeToken）：int=
将x与TotalSizeToken（a、b、c）->a*b*c匹配
静态成员TotalSize（x:TotalSizeToken）：int=
将x与TotalSizeToken（a，b）->a*b匹配
静态成员TotalSize（x:TotalSizeToken）：int=
将x与TotalSizeToken x->x匹配
让内联大小\u到\u总大小\u x=
（^s）：（静态成员总大小：^s->int）x）
设t=尺寸到总尺寸（TotalSizeToken（1,5））

这种替代形式有效。还有一些额外的拳击项目，但从好的方面来说，我不需要在任何地方都传递lambdas。奇怪的是，如果将

size\u to_total\u size

写成

let inline size\u to_total\u size x=（^s）：（静态成员TotalSize:TotalSizeToken<^s>->int）x）而不是
，它就不起作用了

type TotalSizeToken<'u> = TotalSizeToken of 'u with
    static member TotalSize(x: TotalSizeToken<int*int*int*int*int>): int = 
        match x with TotalSizeToken (a,b,c,d,e) -> a*b*c*d*e
    static member TotalSize(x: TotalSizeToken<int*int*int*int>): int = 
        match x with TotalSizeToken (a,b,c,d) -> a*b*c*d
    static member TotalSize(x: TotalSizeToken<int*int*int>): int = 
        match x with TotalSizeToken (a,b,c) -> a*b*c
    static member TotalSize(x: TotalSizeToken<int*int>): int = 
        match x with TotalSizeToken (a,b) -> a*b
    static member TotalSize(x: TotalSizeToken<int>): int = 
        match x with TotalSizeToken x -> x

let inline size_to_total_size x = 
    ((^s) : (static member TotalSize: ^s -> int) x)

let t = size_to_total_size (TotalSizeToken(1,5))