Làm cách nào để chuyển đổi hoàn toàn thành các loại siêu phổ biến trong các kết hợp mẫu F #?

Question

Tóm tắt Sự cố

Tại thời điểm này khi sử dụng f # Tôi phải ép buộc một cách rõ ràng giá trị cho các loại mẹ của loại của nó để có được mô hình phù hợp với biểu thức để gõ kiểm tra một cách chính xác. Tôi sẽ lý tưởng như một cách thức làm việc.

Ví dụ

Giả sử tôi có một số lớp hệ thống cấp bậc:

type Foo() = 
    abstract member Value : unit -> string 

type A (i:int) = 
    inherit Foo() 
     override this.Value() = i.ToString() 

type B (s:string) = 
    inherit Foo() 
     override this.Value() = s 

Lý tưởng nhất, và trong một số ngôn ngữ lập trình trong bình thường, tôi sẽ viết tương đương với các nội dung sau:

let bar (i:int) : Foo = 
    match i with 
     | 1 -> B "one" 
     | _ -> A i 

Tuy nhiên điều này không đánh máy kiểm tra chính xác, cho tôi lỗi, "Biểu hiện này được dự kiến ​​sẽ có loại Foo nhưng cô ấy e có loại B ". Tôi không hiểu tại sao trình biên dịch không có đủ thông tin để suy ra một loại siêu phổ biến cho biểu thức khớp và sau đó kiểm tra xem loại siêu phổ biến là 'Foo' hay không.

Hiện nay tôi buộc phải cung cấp một sự ép buộc rõ ràng cho mọi trường hợp trong mô hình phù hợp:

let bar2 (i:int) : Foo = 
    match i with 
     | 1 -> (B "one") :> Foo 
     | _ -> (A i) :> Foo 

Tôi muốn tránh điều này.

Ghi chú Hơn nữa

• Trực giác cho thấy rằng đây là một kết quả của một vấn đề tổng quát hơn. Tôi đã có thể nghĩ rằng mặc dù một cái gì đó phổ biến như phù hợp với mô hình, hoặc nếu báo cáo mà cũng thể hiện cùng một tài sản, sẽ có một loại kiểm tra quy tắc để giải thích cho các loại siêu phổ biến.
• Trước khi bất cứ ai gợi ý - Tôi đánh giá cao nếu A hoặc B là Biểu thức đối tượng thì điều này sẽ hiệu quả, nhưng ví dụ thực sự của tôi là tạo các thể hiện của các lớp C# nơi chúng là các lớp bình thường.
• Có cách nào để tôi khai báo hàm để chuyển đổi các loại ngầm định, ví dụ như scala có, vì vậy tôi có thể áp dụng chuyển đổi tự động cho mô-đun mà tôi đang tạo thế hệ này không?

Cảm ơn bạn đã giúp đỡ về vấn đề này.

Answer 1

Tôi sẽ sử dụng upcast, a la

[<AbstractClass>] 
type Foo() = 
    abstract member Value : unit -> string 

type A (i:int) = 
    inherit Foo() 
    override this.Value() = i.ToString() 

type B (s) = 
    inherit Foo() 
    override this.Value() = s 

let bar2 i : Foo = 
    match i with 
    | 1 -> upcast B "one" 
    | _ -> upcast A i 

Bạn vẫn phải thêm nó vào mỗi chi nhánh, nhưng điều này thường thích hợp hơn để đúc các loại, vì thường là typename là như dài 20 hoặc 30 ký tự (MyNamespace.ThisThingy), trong khi upcast chỉ là 6 ký tự.

Nhưng, một thời gian ngắn, các quy tắc ngôn ngữ không cho phép bất kỳ điều gì khác, các loại của tất cả các nhánh phải bằng nhau.

Answer 2

Tôi đã nhìn thấy câu hỏi này một vài lần trước đây, nhưng tôi mới nhận ra rằng có một cách khá thú vị để giải quyết vấn đề (không có bất kỳ tác động tiêu cực đáng kể nào như phí thời gian chạy lớn).

Bạn có thể sử dụng biểu thức tính toán rất đơn giản chỉ có Return thành viên. Trình tạo sẽ có thông số loại và Return sẽ mong đợi các giá trị thuộc loại này. Bí quyết là, rằng F # thực hiện chèn tự động phát khi gọi thành viên. Đây là tuyên bố:

type ExprBuilder<'T>() = 
    member x.Return(v:'T) = v 

let expr<'T> = ExprBuilder<'T>() 

Để viết một mô hình kết hợp đơn giản mà trả về bất cứ điều gì như obj, bây giờ bạn có thể viết:

let foo a = expr<obj> { 
    match a with 
    | 0 -> return System.Random() 
    | _ -> return "Hello" } 

Bạn vẫn phải được rõ ràng về các kiểu trả về (khi tạo biểu thức tính toán), nhưng tôi thấy cú pháp khá gọn gàng (nhưng nó chắc chắn là một cách sử dụng khéo léo có thể gây nhầm lẫn cho những người sẽ thấy nó lần đầu tiên).