Làm cách nào để sử dụng toán tử chuyển đổi rõ ràng quá tải?

Question

Tôi có một kiểu định nghĩa trong C# như thế này:

struct F { 
    public static explicit operator F(long value) {} 
    public static explicit operator long(F value) {} 
    public static explicit operator F(double value) {} 
    public static explicit operator double(F value) {} 
    // more conversion operators 
} 

Trong F # nếu tôi muốn tạo ra nó từ lâu, cách duy nhất tôi tìm thấy là:

let l = F.op_Explicit 3L 

Tôi đã cố gắng tạo ra một inline để làm cho điều này đẹp hơn:

let inline f a = F.op_Explicit a 

Nhưng điều này không biên dịch. Tôi cũng đã thử với một ràng buộc thành viên:

let inline f (x:^a) = (F: (static member op_Explicit : ^a -> F) x) 

Và điều đó cũng không biên dịch.

Có thể xác định hàm hoặc toán tử để chọn tình trạng quá tải phải không?

Trên một mặt lưu ý, nó không làm việc độc đáo theo hướng ngược lại:

let f = someF |> int64 // calls the right conversion operator 

Answer 1

Nó không hợp lệ để có một hạn chế thành viên trên một loại bê tông duy nhất; Tuy nhiên, điều này có thể làm việc cho bạn:

let inline f (x:^a) : F = 
    let inline g x = ((^b or ^c):(static member op_Explicit : ^b -> ^c) x) 
    g x 

này có kiểu tổng quát hơn f : ^a -> F when (^a or F) : (static member op_Explicit : ^a -> F), mà là một loại đó là không thể tự chú thích bất kỳ giá trị với!