3 ms·

> -> instead of comma? Because a comma would be a very unusual notation to separate the parameter and return value of a function. For example a function with

> -> instead of comma? Because a comma would be a very unusual notation to separate the parameter and return value of a function. For example a function with type "a -> b -> c" is not a function taking three parameters, it's a function taking something of type a returning another function of type (b -> c). Writing that as "a, b, c" would be an extremely weird way to write that.

rurban 10y ago
Yes, I was wrong. I should have said () vs ->. You would write your "a -> b -> c" as (a) -> b (b) -> c and then combined: ((a) -> b) -> c. A function taking a function. But Haskell just flattens nested these lists. E.g. take this: inc :: Num a => a -> a is normally written as func inc (Num a) -> Num; A function taking a Num and returning a Num. The a is normally written as T, a generic type variable, thus forbidding type-promotions from e.g. overflowing Integer to Num. This inc will wrap around. This is normally written without dependent types as generic for all subtypes. func inc (Num a) -> Num; func inc (Integer a) -> Integer; Now Haskell calls that "pattern matching", but of course it is not pattern matching, it is polymorphism, static dispatch based on signatures. Pattern matching has a well-established meaning already, if strings or structural matching. Dispatch does much more than just matching. A match only finds exact candidates, dispatch also finds the closest candidate, which doesn't need to match.
- Ericson2314 10y ago
  Sorry you got the paren association wrong. It's right associative: curried function returns a function.
- irishsultan 10y ago
  Haskell doesn't call that pattern matching, or at least I've never heard that usage. What Haskell calls pattern matching is if you have a single type (e.g. Maybe a) with two different constructors (in this case Just and Nothing) where "Just something" will match with a value constructed with that first constructor and Nothing with the second constructor. Note that his isn't the only thing you have wrong, there are no values of type Num, because Num is not a type. In the expression "inc :: Num a => a -> a" the only type is a, which has a restriction namely that the type has to implement the Num typeclass. The parameters don't have a name in the type signature.

rurban 10y ago

Yes, I was wrong. I should have said () vs ->. You would write your "a -> b -> c" as (a) -> b (b) -> c and then combined: ((a) -> b) -> c. A function taking a function. But Haskell just flattens nested these lists. E.g. take this: inc :: Num a => a -> a is normally written as func inc (Num a) -> Num; A function taking a Num and returning a Num. The a is normally written as T, a generic type variable, thus forbidding type-promotions from e.g. overflowing Integer to Num. This inc will wrap around. This is normally written without dependent types as generic for all subtypes. func inc (Num a) -> Num; func inc (Integer a) -> Integer; Now Haskell calls that "pattern matching", but of course it is not pattern matching, it is polymorphism, static dispatch based on signatures. Pattern matching has a well-established meaning already, if strings or structural matching. Dispatch does much more than just matching. A match only finds exact candidates, dispatch also finds the closest candidate, which doesn't need to match.

Ericson2314 10y ago
Sorry you got the paren association wrong. It's right associative: curried function returns a function.
irishsultan 10y ago
Haskell doesn't call that pattern matching, or at least I've never heard that usage. What Haskell calls pattern matching is if you have a single type (e.g. Maybe a) with two different constructors (in this case Just and Nothing) where "Just something" will match with a value constructed with that first constructor and Nothing with the second constructor. Note that his isn't the only thing you have wrong, there are no values of type Num, because Num is not a type. In the expression "inc :: Num a => a -> a" the only type is a, which has a restriction namely that the type has to implement the Num typeclass. The parameters don't have a name in the type signature.