Phiên bản F # của kết hợp mẫu haskell

Question

Làm cách nào để làm điều này haskell trong F # sạch?

add 1 2 x = 3 + x 
add 1 x y = 1 + x + y 
add z x y = z + x + y 

Answer 1

Bạn không thể quá tải chức năng riêng của mình, nhưng bạn có thể sử dụng mô hình kết hợp trực tiếp:

let add z x y =    // curried multiple parameters 
    match z, x, y with  // convert to three-tuple to match on 
    | 1, 2, x -> 3 + x 
    | 1, x, y -> 1 + x + y 
    | z, x, y -> z + x + y 

Việc sử dụng như mong đợi: add 1 2 3

Nếu bạn sẵn sàng để sử dụng tuples là đối số (ví dụ: forgo currying và partial application), bạn thậm chí có thể viết nó nhanh hơn:

let add =      // expect three-tuple as first (and only) parameter 
    function     // use that one value directly to match on 
    | 1, 2, x -> 3 + x 
    | 1, x, y -> 1 + x + y 
    | z, x, y -> z + x + y 

Cách sử dụng bây giờ là: add (1, 2, 3)

Answer 2

Nhớ lại trong Haskell rằng general form of functions như một danh sách các tờ khai với các mẫu:

f pat1 ... = e1 
f pat2 ... = e2 
f pat3 ... = e3 

chỉ đường cho việc phân tích case:

f x1 .. xn = case (x1, .. xn) of 
       (pat1, ..., patn) -> e1 
       (pat2, ..., patn) -> e2 
       (pat3, ..., patn) -> e3 

nên bản dịch tương tự có thể được thực hiện với các ngôn ngữ khác có khớp mẫu nhưng không có mẫu cấp khai báo.

Answer 3

Đây hoàn toàn là cú pháp. Ngôn ngữ như Haskell, Standard ML và Mathematica cho phép bạn viết ra trường hợp kết hợp khác nhau như thể chúng là các chức năng khác nhau:

factorial 0 = 1 
factorial 1 = 1 
factorial n = n * factorial(n-1) 

trong khi các ngôn ngữ như OCaml và F # yêu cầu bạn phải có một định nghĩa hàm đơn và sử dụng match hoặc tương đương trong cơ thể của nó:

let factorial = function 
    | 0 -> 1 
    | 1 -> 1 
    | n -> n * factorial(n-1) 

Lưu ý rằng bạn không cần phải sao chép các tên hàm hơn và hơn nữa sử dụng cú pháp này và bạn có thể yếu tố trường hợp trận đấu dễ dàng hơn:

let factorial = function 
    | 0 | 1 -> 1 
    | n -> n * factorial(n-1) 

Như yamen đã viết, làm currying với let f a b = match a, b with ... trong F #.

Trong việc thực hiện cây đỏ-đen cổ điển, tôi tìm ra sự trùng lặp của tên hàm và hai bên cánh tay phải trong Standard ML và Haskell khá xấu xí:

balance :: RB a -> a -> RB a -> RB a 
balance (T R a x b) y (T R c z d) = T R (T B a x b) y (T B c z d) 
balance (T R (T R a x b) y c) z d = T R (T B a x b) y (T B c z d) 
balance (T R a x (T R b y c)) z d = T R (T B a x b) y (T B c z d) 
balance a x (T R b y (T R c z d)) = T R (T B a x b) y (T B c z d) 
balance a x (T R (T R b y c) z d) = T R (T B a x b) y (T B c z d) 
balance a x b = T B a x b 

so với tương đương OCaml hoặc F #:

let balance = function 
    | B, z, (T(R, y, T(R, x, a, b), c) | T(R, x, a, T(R, y, b, c))), d 
    | B, x, a, (T(R, z, T(R, y, b, c), d) | T(R, y, b, T(R, z, c, d))) -> 
     T(R, y, T(B, x, a, b), T(B, z, c, d)) 
    | a, b, c, d -> T(a, b, c, d)