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

[Jack Henahan]

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 at uvm.edu
      

On Aug 13, 2012, at 6:41 PM, Christopher Howard <christopher.howard at frigidcode.com> wrote:

> On 08/12/2012 09:37 PM, Shakthi Kannan wrote:
>> Hi,
>> 
>> --- On Mon, Aug 13, 2012 at 10:51 AM, Christopher Howard
>> <christopher.howard at frigidcode.com> 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 at haskell.org
> http://www.haskell.org/mailman/listinfo/beginners