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. Re: map type explanation (c...@coot.me)
----------------------------------------------------------------------
Message: 1
Date: Sun, 20 Dec 2020 19:43:24 +0000
From: c...@coot.me
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:
<cXaXkpbIu_NtavVZrdIduhjTnoacQADcpQ42mJLHswOtVTaqUDcA6CYG0uVI1Uyx4DKukobwQCTar9MjHGLVvAMCCMTeIH711JKEzAvW6YQ=@coot.me>
Content-Type: text/plain; charset="utf-8"
Hi,
The `(a -> b)` in `map :: (a -> b) -> [a] -> [b]` is a type of function from a
type `a` to a type `b`. Haskell, by default, is using implicit
quantification, however using `ScopedTypeVariables` extension you could write
`map :: forall a b. (a -> b) -> [a] -> [b]` to make it explicit. This way you
see that both `a` and `b` are introduced by `forall`. In particular, you can
substitute any types, e.g. if you substitute `a` with `Char` and `b` with
`Int`, you'll get `map :: (Char -> Int) -> [Char] -> [Int]`. If you enable
`TypeApplication` extension you can do that in `ghci`: `:t map @Char @Int`
You can read the type of `map` as follows: given a function `f` from type `a`
to some type `b`, `map f :: [a] -> [b]`, i.e. `map f` is a function from list
of `a` to list of `b`'s.
Being able to write functions like `map`, is called parametric polymorphism.
Using such polymorphism you guarantee that the implentation of `map` cannot do
any thing with `a`'s and `b`'s, as there's no knowledge about what they are,
beside the recepe how to transform `a`'s into `b` given by `f`. This limits
what `map f` can do to a list of `a`'s.
Best regards,
Marcin Szamotulski
‐‐‐‐‐‐‐ Original Message ‐‐‐‐‐‐‐
On Friday, December 18th, 2020 at 19:30, 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
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20201220/887c6b4a/attachment-0001.html>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 509 bytes
Desc: OpenPGP digital signature
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20201220/887c6b4a/attachment-0001.sig>
------------------------------
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 15
******************************************
