An example of a function of (a -> a -> a) would be (+), which works if your values are numbers (which mirrors your Python-like pseudocode).

On Friday, June 19, 2015, Matt Williams <matt.williams45.mw@gmail.com> wrote:

Dear All,

Thanks for your help with this.

I have got the simple version working but now need to use Map.fromListWith, and am having syntax problems.

I found a related question on Stack overflow (here: http://stackoverflow.com/questions/15514486/haskell-converting-a-list-of-a-b-key-value-pairs-with-possibly-repeated-key ).

However, I'm having problems understanding the additional function. The signature should be :
(a -> a -> a) -> [(k, a)] -> Map

And so I assume I need to supply a function whose signature is:

(a -> a -> a)

Is that correct?

Thanks,
Matt


On Fri, 19 Jun 2015 09:04 Vlatko Basic <vlatko.basic@gmail.com> wrote:
To learn, I'd suggest you implement it first with the recursion (a tip: use a "loop" function in where clause), and than with fold. Those are important features to understand in Haskell. Try to use the "higher-level" functions as little as possible until you grasp the basics (like fold syntax).

If you just need any solution, fromListWith is fine.

br,
vlatko



-------- Original Message --------
Subject: Re: [Haskell-beginners] Adapting code from an imperative loop
From: Matt Williams <matt.williams45.mw@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily beginner-level topics related to Haskell <beginners@haskell.org>
Date: 19/06/15 09:05

I tried doing it as a fold (the pattern of accumulating a value, where the accumulated value was the resulting Map), but couldn't manage the syntax.

Have now got it partially working with fromListWith.

Thanks a lot,
Matt


On Fri, 19 Jun 2015 07:18 Bob Ippolito <bob@redivi.com> wrote:
On Friday, June 19, 2015, Matt Williams <matt.williams45.mw@gmail.com> wrote:

Dear All,

I have been wrestling with this for a while now.

I have a list of data items, and want to be able to access them, in a Hash Map, via a short summary of their characteristics.

In an imperative language this might look like:

myMap = new map()
for elem in myElems:
    key = makeKey(elem)
    myMap[key] = myMap[key] + elem

I have been trying to do this in Haskell, but am stuck on how to hand the Map back to itself each time.

I have a function :: elem -> [p,q] to make the key, but the Map.insert function has the following signature:

insert :: (Hashable k, Ord k) => k -> a -> HashMap k a -> HashMap k a

My thought was that I needed to go through the list of the elems, and at each point add them to the Hash Map, handing the updated Map onto the next step - but this is what I cannot write.


This is typically done with fromListWith or a combination of foldl' and insertWith or alter.

-bob
_______________________________________________
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