Refactoring Haskell lambda functions

Question

I have a lambda function ((:) . ((:) x)) that I am passing to foldr like so: foldr ((:) . ((:) x)) [] xs where xs is a 2d list. I would like to refactor to make it clearer (so I can better understand it). I imagine it would be done like so:

foldr (\ element acc -> (element:acc) . (x:acc)) [] xs

But this gives me the error:

ex.hs:20:84: error:
    • Couldn't match expected type ‘a0 -> b0’ with actual type ‘[[a]]’
    • Possible cause: ‘(:)’ is applied to too many arguments
      In the second argument of ‘(.)’, namely ‘(x : acc)’
      In the expression: (element : acc) . (x : acc)
      In the first argument of ‘foldr’, namely
        ‘(\ element acc -> (element : acc) . (x : acc))’
    • Relevant bindings include
        acc :: [[a]] (bound at ex.hs:20:60)
        element :: [a] (bound at ex.hs:20:52)
        xs :: [[a]] (bound at ex.hs:20:30)
        x :: [a] (bound at ex.hs:20:28)
        prefixes :: [a] -> [[a]] (bound at ex.hs:20:1)
   |
20 | prefixes = foldr (\x xs -> [x] : (foldr (\ element acc -> (element:acc) . (x:acc)) [] xs)) []
   |

Edit: My all relevant code surrounding this snippet is

prefixes :: Num a => [a] -> [[a]]
prefixes = foldr (\x acc -> [x] : (foldr ((:) . ((:) x)) [] acc)) []

and its invocation is:

prefixes [1, 2, 3]

How can I refactor the lambda ((:) . ((:) x)) to include both its arguments?

For what it's worth, that's a function expression but it's not a lambda. Lambdas are a very specific construct - they provide syntax for creating anonymous functions with named arguments. But Haskell treats functions as regular values, providing ways to pass them around and modify them without ever using a lambda construct. That's what the code in your initial example does. — Carl
– Carl, Commented Mar 17, 2022 at 19:09

Micha Wiedenmann · Accepted Answer · 2022-03-18 08:05:38Z

8

You can step-by-step convert it to a lambda.

(:) . ((:) x)
\y -> ((:) . (((:) x)) y  -- conversion to lambda
\y -> (:) (((:) x) y)     -- definition of (.)
\y -> (:) (x : y)         -- rewrite second (:) using infix notation
\y z -> (:) (x : y) z     -- add another parameter
\y z -> (x : y) : z       -- rewrite first (:) using infix notation

edited Mar 18, 2022 at 8:05

Micha Wiedenmann

21.1k22 gold badges96 silver badges142 bronze badges

answered Mar 17, 2022 at 17:37

castletheperson

33.6k11 gold badges74 silver badges111 bronze badges

Sign up to request clarification or add additional context in comments.

Collectives™ on Stack Overflow

Refactoring Haskell lambda functions

1 Answer 1

Comments

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Related