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 ******************************************