[Haskell-beginners] Haskell type definitions

[Patrick Mylund Nielsen]

Yes, it is a type signature. It's "function name :: optional type
constraints => function of type a -> function of type b -> type c"

take' :: Num i => i -> [a] -> [a]     = take' is a function whose first
argument is of type i, where the i type must be an instance of the Num
typeclass. The function also takes a list of values of type a (any specific
type), and returns a list of values of the same type.

take' :: (Num i, Ord i) => i -> [a] -> [a]     = take' is a function whose
first argument is of type i, where the i type must be an instance of both
the Num and Ord typeclasses. The function also takes a list of values of
type a (any one type), and returns a list of values of the same type.

So the tuple behind the => doesn't mean that one of the arguments is a
tuple, or that the constraints apply to the arguments positionally, but
rather that the specified type, e.g. i, must satisfy some constraints--in
this case implement Ord and Eq so that you can check if it's below 0 (Ord)
and use it as a number (Num.) take' :: i -> [a] -> [a] would have been
valid too, but you wouldn't know if you can compare against i, or use it as
a number.

If you wanted to sort the [a], then indeed, you would need to make it take'
:: (Num i, Ord i, Ord a), since sort from Data.List has a type signature of
sort :: Ord a => [a] -> [a]


On Wed, Apr 10, 2013 at 11:32 AM, Angus Comber <anguscomber at gmail.com>wrote:

> I am learning Haskell using Learn You a Haskell.  On page 54 is an
> implementation of take like so:
>
>     take' :: (Num i, Ord i) => i -> [a] -> [a]
>     take' n _
>         | n <= 0 = []
>     take' _ []   = []
>     take' n (x:xs) = x : take' (n-1) xs
>
> I understand all the code apart from the first line.
>
> The :: part I understand as meaning this is a type definition?
>
> (Num i, Ord i) is a tuple.  The first element of the tuple has to be
> numeric, fair enough.  the second param has to be able to be ordered.
> The parameter is the same - both are i.  This means that the types
> have to be the same?
>
> Why is it not (Num i, Ord j)?  Isn't the 2nd tuple element
> referring to the list?  Which could be of any type?
>
> What does => signify?
>
> i -> [a] -> [a] means first parameter is numeric?  2nd param is any
> type list, 3rd param is any type list.  So this is saying first param
> numeric, 2nd param a list of any type and it returns a list of any
> type.  Well that is understandable I suppose.
>
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://www.haskell.org/mailman/listinfo/beginners
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/beginners/attachments/20130410/f803b2d6/attachment.htm>