Tổng hợp danh sách các mức lồng nhau tùy ý trong F #

Tôi đang cố gắng tạo một hàm F # sẽ trả về tổng của một danh sách intcác hàm lồng nhau tùy ý. I E. nó sẽ làm việc cho a list<int>, a list<list<int>>và a list<list<list<list<list<list<int>>>>>>.

Trong Haskell tôi sẽ viết một cái gì đó như:

class HasSum a where
    getSum :: a -> Integer

instance HasSum Integer where
    getSum = id

instance HasSum a => HasSum [a] where
    getSum = sum . map getSum

Điều đó sẽ cho tôi làm:

list :: a -> [a]
list = replicate 6

nestedList :: [[[[[[[[[[Integer]]]]]]]]]]
nestedList =
    list $ list $ list $ list $ list $
    list $ list $ list $ list $ list (1 :: Integer)

sumNestedList :: Integer
sumNestedList = getSum nestedList

Làm thế nào tôi có thể đạt được điều này trong F #?

CẬP NHẬT

Tôi tìm thấy một phiên bản đơn giản hơn bằng cách sử dụng một toán tử ($)thay vì một thành viên. Lấy cảm hứng từ https://stackoverflow.com/a/7224269/4550898 :

type SumOperations = SumOperations 

let inline getSum b = SumOperations $ b // <-- puting this here avoids defaulting to int

type SumOperations with
    static member inline ($) (SumOperations, x  : int     ) = x 
    static member inline ($) (SumOperations, xl : _   list) = xl |> List.sumBy getSum

Phần còn lại của lời giải thích vẫn được áp dụng và nó rất hữu ích ...

Tôi tìm thấy một cách để làm cho nó có thể:

let inline getSum0< ^t, ^a when (^t or ^a) : (static member Sum : ^a -> int)> a : int = 
    ((^t or ^a) : (static member Sum : ^a -> int) a)

type SumOperations =
    static member inline Sum( x : float   ) = int x
    static member inline Sum( x : int     ) =  x 
    static member inline Sum(lx : _   list) = lx |> List.sumBy getSum0<SumOperations, _>

let inline getSum x = getSum0<SumOperations, _> x

2                  |> getSum |> printfn "%d" // = 2
[ 2 ; 1 ]          |> getSum |> printfn "%d" // = 3
[[2; 3] ; [4; 5] ] |> getSum |> printfn "%d" // = 14

Chạy ví dụ của bạn:

let list v = List.replicate 6 v

1
|> list |> list |> list |> list |> list
|> list |> list |> list |> list |> list
|> getSum |> printfn "%d" // = 60466176

Điều này dựa trên việc sử dụng SRTP với các ràng buộc thành viên : static member Sum, ràng buộc này yêu cầu loại phải có một thành viên được gọi Sum trả về một int. Khi sử dụng các chức năng chung SRTP cần phải có inline.

Đó không phải là phần khó khăn. Phần khó là "thêm" Sumthành viên vào loại hiện có intvà Listkhông được phép. Nhưng, chúng ta có thể thêm nó vào một loại mới SumOperationsvà đưa vào chế (^t or ^a) nơi ^tsẽ luôn luôn được SumOperations.

• getSum0tuyên bố các Sumràng buộc thành viên và gọi nó.
• getSum chuyển SumOperationslàm tham số loại đầu tiên chogetSum0

Dòng static member inline Sum(x : float ) = int xđược thêm vào để thuyết phục trình biên dịch sử dụng lệnh gọi hàm động chung và không chỉ mặc định static member inline Sum(x : int )khi gọiList.sumBy

Như bạn có thể thấy là một chút phức tạp, cú pháp rất phức tạp và cần phải làm việc xung quanh một số quirks trên trình biên dịch nhưng cuối cùng thì điều đó là có thể.

Phương pháp này có thể được mở rộng để làm việc với Mảng, bộ dữ liệu, tùy chọn, v.v. hoặc bất kỳ sự kết hợp nào của chúng bằng cách thêm nhiều định nghĩa vào SumOperations:

type SumOperations with
    static member inline ($) (SumOperations, lx : _   []  ) = lx |> Array.sumBy getSum
    static member inline ($) (SumOperations, a  : ^a * ^b ) = match a with a, b -> getSum a + getSum b 
    static member inline ($) (SumOperations, ox : _ option) = ox |> Option.map getSum |> Option.defaultValue 0

(Some 3, [| 2 ; 1 |]) |> getSum |> printfn "%d" // = 6

https://dotnetfiddle.net/03rVWT

Đây là phiên bản thời gian chạy, sẽ hoạt động với tất cả các bộ sưu tập .net. Tuy nhiên, trao đổi lỗi trình biên dịch trong câu trả lời của AMieres cho ngoại lệ thời gian chạy và AMieres 'cũng nhanh hơn 36 lần.

let list v = List.replicate 6 v

let rec getSum (input:IEnumerable) =
    match input with
    | :? IEnumerable<int> as l -> l |> Seq.sum
    | e -> 
        e 
        |> Seq.cast<IEnumerable> // will runtime exception if not nested IEnumerable Types
        |> Seq.sumBy getSum


1 |> list |> list |> list |> list |> list
|> list |> list |> list |> list |> list |> getSum // = 60466176

Điểm chuẩn

|    Method |        Mean |     Error |    StdDev |
|---------- |------------:|----------:|----------:|
| WeirdSumC |    76.09 ms |  0.398 ms |  0.373 ms |
| WeirdSumR | 2,779.98 ms | 22.849 ms | 21.373 ms |

// * Legends *
  Mean   : Arithmetic mean of all measurements
  Error  : Half of 99.9% confidence interval
  StdDev : Standard deviation of all measurements
  1 ms   : 1 Millisecond (0.001 sec)