Điều gì có thể so sánh trung bình trong Elm?

Question

Tôi đang gặp khó khăn khi hiểu chính xác một số comparable là gì trong Elm. Elm có vẻ bối rối như tôi.

Trên REPL:

> f1 = (<) 
<function> : comparable -> comparable -> Bool 

Vì vậy f1 chấp nhận so sánh.

> "a" 
"a" : String 
> f1 "a" "b" 
True : Bool 

Vì vậy, có vẻ như String là có thể so sánh.

> f2 = (<) 1 
<function> : comparable -> Bool 

Vì vậy, f2 chấp nhận so sánh.

> f2 "a" 
As I infer the type of values flowing through your program, I see a conflict 
between these two types: 

    comparable 

    String 

Vì vậy Stringlà và không thể so sánh?
Tại sao loại f2 không phải là number -> Bool? Những gì có thể so sánh khác có thể f2 chấp nhận?

Answer 1

Thông thường khi bạn thấy biến kiểu trong một loại trong Elm, biến này không bị giới hạn. Khi bạn cung cấp một loại cụ thể, biến được thay thế bằng loại cụ thể đó:

-- says you have a function: 
foo : a -> a -> a -> Int 
-- then once you give an value with an actual type to foo, all occurences of `a` are replaced by that type: 
value : Float 
foo value : Float -> Float -> Int 

comparable là biến kiểu có ý nghĩa đặc biệt. Nghĩa là nó sẽ chỉ khớp với các loại "có thể so sánh", như Int, String và một vài loại khác. Nhưng nếu không nó sẽ hành xử giống nhau.Vì vậy, tôi nghĩ rằng đó là một chút lỗi trong hệ thống kiểu, cho rằng bạn nhận được:

> f2 "a" 
As I infer the type of values flowing through your program, I see a conflict 
between these two types: 

    comparable 

    String 

Nếu lỗi là không có, bạn sẽ nhận được:

> f2 "a" 
As I infer the type of values flowing through your program, I see a conflict 
between these two types: 

    Int 

    String 

EDIT: Tôi mở một issue cho lỗi này

Answer 2

Tôi nghĩ câu hỏi này có thể liên quan đến this one. Int và String đều là comparable theo nghĩa là chuỗi có thể được so sánh với chuỗi và int có thể được so sánh với int. Một hàm có thể lấy bất kỳ hai phép so sánh nào sẽ có một chữ ký comparable -> comparable -> ... nhưng trong bất kỳ một đánh giá nào của hàm cả hai phép so sánh phải có cùng loại.

Tôi tin rằng lý do f2 là khó hiểu trên là 1 là một number thay vì một loại bê tông (mà dường như để ngăn chặn sự biên dịch từ nhận thức rằng có thể so sánh phải có một loại nhất định, có lẽ nên được cố định). Nếu bạn đã làm:

i = 4 // 2 
f1 = (<) i -- type Int -> Bool 
f2 = (<) "a" -- type String -> Bool 

bạn sẽ thấy nó thực sự không sụp đổ comparable để đúng loại khi nó có thể.

Answer 3

lấy từ các tài liệu elm: - here

loại tương đương bao gồm numbers, characters, strings, lists of comparable things và tuples of comparable things. Lưu ý rằng bộ dữ liệu có 7 hoặc nhiều phần tử không thể so sánh được; tại sao tuples của bạn là quá lớn?

Điều này có nghĩa rằng:

[(1,"string"), (2, "another string")]: List (Int, String) - có thể so sánh

Nhưng có

(1, "string", True): (Int, String, Bool) hoặc

[(1,True), (2, False)]: List (Int, Bool) - là không thể so sánh được.

Vấn đề này sẽ được thảo luận here

Lưu ý: Thông thường người gặp vấn đề với các loại comparable khi họ cố gắng sử dụng một loại đoàn như một chính trong một Dict.

Thẻ và Công cụ xây dựng kiểu công đoàn không thể so sánh được. Vì vậy, những điều sau đây thậm chí không biên dịch.

type SomeUnion = One | Two | Three 
Dict.fromList [ (One, "one related"), (Two, "two related") ] : Dict SomeUnion String 

Thông thường khi bạn cố gắng để làm điều này, có một cách tiếp cận tốt hơn với cấu trúc dữ liệu của bạn. Nhưng cho đến khi điều này được quyết định - một AllDict có thể được sử dụng.