[Haskell-beginners] map type explanation

[Lawrence Bottorff]

Why is it not just

a -> b -> [a] -> [b]

again, why the parentheses?

On Fri, Dec 18, 2020 at 4:10 PM Ut Primum <utprimum at gmail.com> wrote:

> Hi,
>
> a -> b  is the type of a function taking arguments of a generic type (we
> call it a) and returning results of another type, that we call b.
>
> So
> (a -> b ) -> [a] -> [b]
> Means that you have a first argument that is a function (a-> b),  a second
> argument that is a list of elements of the same type of the function input,
> and that the returned element is a list of things of the type of the output
> of the function.
>
> Cheers,
> Ut
>
> Il ven 18 dic 2020, 23:02 Lawrence Bottorff <borgauf at gmail.com> ha
> scritto:
>
>> Thank you, but why in
>>
>> map :: (a -> b) -> [a] -> [b]
>>
>> are there parentheses around a -> b ? In general, what is the currying
>> aspect of this?
>>
>>
>> On Fri, Dec 18, 2020 at 12:43 PM David McBride <toad3k at gmail.com> wrote:
>>
>>> They are not parameters, they are the types of the parameters.
>>>
>>> In this case a can really be anything, Int, Char, whatever, so long as
>>> the function takes a single argument of that type and the list that is
>>> given has elements of that same type.
>>> It is the same for b, it doesn't matter what b ends up being, so long as
>>> when you call that function the function's return value is compatible with
>>> the element type of the list that you intended to return from the entire
>>> statement.
>>>
>>> You can mess with it yourself in ghci to see how type inference works.
>>>
>>> >:t show
>>> :show :: Show a => a -> String
>>> >:t map show
>>> map show :: Show a => [a] -> [String]
>>> > :t flip map [1::Int]
>>> > flip map [1::Int] :: (Int -> b) -> [b]
>>>
>>>
>>> On Fri, Dec 18, 2020 at 1:31 PM Lawrence Bottorff <borgauf at gmail.com>
>>> wrote:
>>>
>>>> I'm looking at this
>>>>
>>>> ghci> :type map
>>>> map :: (a -> b) -> [a] -> [b]
>>>>
>>>> and wondering what the (a -> b) part is about. map takes a function
>>>> and applies it to an incoming list. Good. Understood. I'm guessing that the
>>>> whole Haskell type declaration idea is based on currying, and I do
>>>> understand how the (a -> b) part "takes" an incoming list, [a] and
>>>> produces the [b] output. Also, I don't understand a and b very well
>>>> either. Typically, a is just a generic variable, then b is another
>>>> generic variable not necessarily the same as a. But how are they being
>>>> used in this type declaration?
>>>>
>>>> LB
>>>> _______________________________________________
>>>> Beginners mailing list
>>>> Beginners at haskell.org
>>>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>>>
>>> _______________________________________________
>>> Beginners mailing list
>>> Beginners at haskell.org
>>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>>
>> _______________________________________________
>> Beginners mailing list
>> Beginners at haskell.org
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/beginners/attachments/20201218/323026a9/attachment.html>