Re: [Haskell-beginners] cleanest way to unwrap a list?

13 Aug 2012

      Equally,

    let map' = map . map
    map' (+1) . map (++[3]) $ [[1,2],[3,4]]
    -- [[2,3,4],[4,5,4]]

And you can really keep stacking those up. I think this approach will be cleaner in the long run.

For instance, let's start naming our parts.

   let list = [[1,2],[3,4]]
   let map' = map . map
   let addOne = map' (+1)
   let appendThree = map (++[3])
   let reverseInner = map reverse

So, from here we can do the following:

   list
   -- [[1,2],[3,4]]

   -- the first example
   addOne list
   -- [[2,3],[4,5]]

   -- now the second example
   addOne . appendThree $ list
   -- [[2,3,4],[4,5,4]]

   -- now add one to all members of the list, append three to the list, reverse the inner lists,
   -- then add one to all members of the new list

   addOne . reverseInner . appendThree . addOne $ list
   -- [[4,4,3],[4,6,5]]

Now how would you construct that as a list comprehension? With the method I've proposed, you need
only use map to operate on the nested lists themselves and map' to operate on the elements of those
lists.

====
Jack Henahan
jhenahan@uvm.edu

On Aug 13, 2012, at 6:41 PM, Christopher Howard  wrote:
...
On 08/12/2012 09:37 PM, Shakthi Kannan wrote:
...
Hi,
--- On Mon, Aug 13, 2012 at 10:51 AM, Christopher Howard
 wrote:
| Say, for example, I have the list
| [[1,2],[3,4]] and want to add 1 to each inner element, resulting in
| [[2,3],[4,5]].
\--
Like this?
ghci> let xxs = [[1,2], [3,4]]
ghci> [ [ x+1 | x <- xs] | xs <- xxs ]
[[2,3],[4,5]]
SK
Thanks everyone for the responses. I found the list comprehension
approach satisfactory, as it allows me to cleanly modify each layer of
the nested array as I unwrap it:
code:
--------
b = [[ x+1
   | x <- xs ++ [3] ]
   | xs <- [[1,2],[3,4]] ]
*Main> b
[[2,3,4],[4,5,4]]
--------
The only downside is that I have to write the layers out in reverse of
the way I would normally think of them, but that isn't too big of a
challenge.
I'm not sure how that would be done with map in a way that would be neat
and readable and wouldn't require declaring extra identifiers. I can't
give a fair evaluation of the Lens approach because I don't understand
enough of the theory yet.
-- 
frigidcode.com
indicium.us
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://www.haskell.org/mailman/listinfo/beginners