Send Beginners mailing list submissions to
beginners@haskell.org
To subscribe or unsubscribe via the World Wide Web, visit
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
beginners-requ...@haskell.org
You can reach the person managing the list at
beginners-ow...@haskell.org
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. map type explanation (Lawrence Bottorff)
2. Re: map type explanation (David McBride)
3. Re: map type explanation (Lawrence Bottorff)
4. Re: map type explanation (Ut Primum)
----------------------------------------------------------------------
Message: 1
Date: Fri, 18 Dec 2020 12:30:54 -0600
From: Lawrence Bottorff <borg...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: [Haskell-beginners] map type explanation
Message-ID:
<CAFAhFSUdySU7=ojAZpobahY=cevd2tg8p9swtndlc0inf8y...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
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
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20201218/4f066558/attachment-0001.html>
------------------------------
Message: 2
Date: Fri, 18 Dec 2020 13:42:22 -0500
From: David McBride <toa...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] map type explanation
Message-ID:
<can+tr439ke3+nlx0qcjvrwyjbb79mryn0htcn51tjyhqygb...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
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 <borg...@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@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/2919abd3/attachment-0001.html>
------------------------------
Message: 3
Date: Fri, 18 Dec 2020 16:01:01 -0600
From: Lawrence Bottorff <borg...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] map type explanation
Message-ID:
<CAFAhFSUH5tX_0hbCJzDqBL_73bO6qSrei5NtNZFO=xumrlg...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
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 <toa...@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 <borg...@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@haskell.org
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>
> _______________________________________________
> Beginners mailing list
> Beginners@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/e0298567/attachment-0001.html>
------------------------------
Message: 4
Date: Fri, 18 Dec 2020 23:08:56 +0100
From: Ut Primum <utpri...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] map type explanation
Message-ID:
<canjdmk+hx6mgd46+4v1rsradh_d8evfzuzvupuwkpvltga0...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
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 <borg...@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 <toa...@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 <borg...@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@haskell.org
>>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>>
>> _______________________________________________
>> Beginners mailing list
>> Beginners@haskell.org
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>
> _______________________________________________
> Beginners mailing list
> Beginners@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/9fdb3c1a/attachment.html>
------------------------------
Subject: Digest Footer
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
End of Beginners Digest, Vol 149, Issue 11
******************************************
