3 ms·

Weak typing and implicit coercion are not the same thing. They're not even close to the same thing. Haskell does (things equivalent to) implicit coercion when i

• rawatson 15y ago
  Haskell uses type inference, but that's not the same as implicit coercion, which Haskell explicitly avoids. That is: if you type 4 + 4.2 Then the compiler will infer that you mean (4::Fractional a=>a) + (4.2::Fractional a => a) However, you cannot add an integer and a float: (4::Int) + (4.2::Float) Couldn't match expected type `Int' with actual type `Float' In the second argument of `(+)', namely `(4.2 :: Float)' In the expression: (4 :: Int) + (4.2 :: Float) In an equation for `it': it = (4 :: Int) + (4.2 :: Float) This follows from the type of (+) :: Num a => a -> a -> a
  • derleth 15y ago
    I guess I still don't get how there could be a difference between Float and Fractional, then.
    • rawatson 15y ago
      Haskell uses type classes to support ad hoc polymorphism, or overloading. Consider the statement: (4.2::Fractional a=> a) + (4::Float) Float is an instance of the type class Fractional. That is: methods which are defined for all fractional types must be defined for floats. The compiler infers that (4.2::Fractional a=>a) must have type float, as it is being added to a float. This is compatible with the original type of the expression, as Float is an instance of fractional, so it is valid to read 4.2 as a Float. This diagram might help: http://www.haskell.org/onlinereport/basic.html#sect6.3 http://www.haskell.org/onlinereport/basic.html#sect6.3