F #: làm thế nào để lựa chọn thanh lịch và nhóm các công đoàn phân biệt đối xử?

Question

Nói rằng tôi có một danh sách các hình dạng:

type shape = 
| Circle of float 
| Rectangle of float * float 

let a = [ Circle 5.0; Rectangle (4.0, 6.0)] 

Làm thế nào tôi có thể sau đó kiểm tra ví dụ một vòng tròn tồn tại trong một? Tôi có thể tạo chức năng cho mỗi hình dạng

let isCircle s = 
    match s with 
    | Circle -> true 
    | _ -> false 
List.exists isCircle a 

nhưng tôi cảm thấy phải có cách thanh lịch hơn trong F #, ngoài việc phải xác định chức năng như vậy cho từng loại hình dạng. Lanhung?

câu hỏi liên quan là làm thế nào để nhóm một danh sách các hình dạng, dựa trên các loại hình dạng:

a |> seq.groupBy(<shapetype? >) 

Answer 1

bạn có thể kết hợp F # phản ánh với trích dẫn để có được giải pháp chung

type Shape = 
    | Circle of float 
    | Rectangle of float * float 

let isUnionCase (c : Expr<_ -> 'T>) = 
    match c with 
    | Lambdas (_, NewUnionCase(uci, _)) -> 
     let tagReader = Microsoft.FSharp.Reflection.FSharpValue.PreComputeUnionTagReader(uci.DeclaringType) 
     fun (v : 'T) -> (tagReader v) = uci.Tag 
    | _ -> failwith "Invalid expression" 

let a = 
    [ Circle 5.0; Rectangle (4.0, 6.0)] 
     |> List.filter (isUnionCase <@ Rectangle @>) 
printf "%A" a 

Answer 2

Một giải pháp thanh lịch hơn có thể là như sau:

let shapeExistsInList shapeType list = 
    List.exists (fun e -> e.GetType() = shapeType) list 

let circleExists = shapeExistsInList ((Circle 2.0).GetType()) a 

Tuy nhiên, tôi không phải là rất hài lòng với điều này bản thân mình kể từ khi bạn phải tạo ra một thể hiện của các công đoàn phân biệt đối xử cho nó để làm việc.

Nhóm theo loại hình có thể hoạt động theo cách tương tự.

Answer 3

Nếu bạn quan tâm trong các danh mục khác nhau về hình dạng, sau đó nó làm cho tinh thần để xác định một loại mà chính xác bắt họ:

type shapeCategory = Circular | Rectangular 

let categorize = function 
    | Circle _ -> Circular 
    | Rectangle _ -> Rectangular 

List.exists ((=) Circular) (List.map categorize a) 

a |> Seq.groupBy(categorize) 

Edit - theo đề nghị của Brian, bạn có thể lựa chọn sử dụng các mẫu tích cực thay vì của một loại mới. Nó hoạt động khá giống với các ví dụ của bạn, nhưng sẽ mở rộng tốt hơn cho các mẫu phức tạp hơn, trong khi cách tiếp cận ở trên có thể tốt hơn nếu mã của bạn thường hoạt động với các danh mục và bạn muốn có loại liên kết tốt cho chúng thay vì loại Lựa chọn .

let (|Circular|Rectangular|) = function 
    | Circle _ -> Circular 
    | Rectangle _ -> Rectangular 

List.exists (function Circular -> true | _ -> false) a 

let categorize : shape -> Choice<unit, unit> = (|Circular|Rectangular|) 
a |> Seq.groupBy(categorize) 

Answer 4

Bạn có thể sử dụng F thư viện # phản ánh để có được thẻ của một giá trị:

let getTag (a:'a) = 
    let (uc,_) = Microsoft.FSharp.Reflection.FSharpValue.GetUnionFields(a, typeof<'a>) 
    uc.Name 

a |> Seq.groupBy getTag 

Answer 5

Tôi muốn thêm một giải pháp làm việc với các trích dẫn cho mọi trường hợp công đoàn, dựa trên một giải pháp được cung cấp. Ở đây nó đi:

open Microsoft.FSharp.Quotations.Patterns 
open Microsoft.FSharp.Reflection 

let rec isUnionCase = function 
| Lambda (_, expr) | Let (_, _, expr) -> isUnionCase expr 
| NewTuple exprs -> 
    let iucs = List.map isUnionCase exprs 
    fun value -> List.exists ((|>) value) iucs 
| NewUnionCase (uci, _) -> 
    let utr = FSharpValue.PreComputeUnionTagReader uci.DeclaringType 
    box >> utr >> (=) uci.Tag 
| _ -> failwith "Expression is no union case." 

Được xác định theo cách này, isUnionCase hoạt động như desco đã hiển thị, nhưng ngay cả trên trường hợp công đoàn trống hoặc có nhiều giá trị. Bạn cũng có thể nhập một tuple các trường hợp nghiệp đoàn được phân cách bằng dấu phẩy. Hãy xem xét điều này:

type SomeType = 
| SomeCase1 
| SomeCase2 of int 
| SomeCase3 of int * int 
| SomeCase4 of int * int * int 
| SomeCase5 of int * int * int * int 

let list = 
    [ 
     SomeCase1 
     SomeCase2 1 
     SomeCase3 (2, 3) 
     SomeCase4 (4, 5, 6) 
     SomeCase5 (7, 8, 9, 10) 
    ] 

list 
|> List.filter (isUnionCase <@ SomeCase4 @>) 
|> printfn "Matching SomeCase4: %A" 

list 
|> List.filter (isUnionCase <@ SomeCase3, SomeCase4 @>) 
|> printfn "Matching SomeCase3 & SomeCase4: %A" 

Đầu tiên làUnionCase tôi chỉ cung cấp để kiểm tra trường hợp đơn. Sau đó tôi đã thêm kiểm tra biểu thức cho NewTuple và nghĩ rằng bạn có thể thích nó. Chỉ cần chắc chắn rằng nếu bạn thay đổi mã các precomputations vẫn hoạt động, đây là lý do tại sao iucs được định nghĩa bên ngoài hàm trả về vô danh.