Lambdas and Folds (Left and Right) - haskell

Question

I really don't understand code
myReverse'' :: [a] -> [a]
myReverse'' xs = foldr (\x fId empty -> fId (x : empty)) id xs []
In case:
empty mapping to [] <---- accumulator
id mapping to fID (func id)
x is first element of xs (list)
Can i sort/change the postion of agruments "id xs []" ?
myReverse'' xs = foldr (\x fId empty -> fId (x : empty)) xs id []
I have read a book yesterday http://learnyouahaskell.com/higher-order-functions#lambdas
elem' :: (Eq a) => a -> [a] -> Bool
elem' y ys = foldl (\acc x -> if x == y then True else acc) False ys
The explanation is understandable to me.
the left fold's binary function has the accumulator as the first parameter and the current value as the second one (so \acc x -> ...)
or I can write as
elem' :: (Eq a) => a -> [a] -> Bool
elem' y ys = foldr (\x acc -> if x == y then True else acc) False ys
Anyone, can help/guide/explain me ?
Many thanks!

Answer 1

The way I like to understand these "reverse list with foldr" problems is to split it into pieces, and apply the lesson of "Foldr is made of monoids". Don't worry, this isn't as scary as it sounds.
First, let's note that reverse can be implemented this way:
my_reverse xs = foldl (flip (:)) xs []
This is the first simplification to our problem: if we can figure out how to write foldl in terms of foldr, then we can plug that solution into my_reverse to and be done with it.
Now, the standard type signature for foldr is this:
foldr :: (a -> r -> r) -> r -> [a] -> r
But the order of the arguments doesn't really matter, so let's rearrange things this way (throwing in a few implicit parentheses as well), and we'll compare it with map:
my_foldr :: (a -> (r -> r)) -> [a] -> (r -> r)
map :: (a -> b ) -> [a] -> [b]
Once you see this correspondence, it's not hard to see that we can write my_foldr this way:
my_foldr :: (a -> (r -> r)) -> [a] -> (r -> r)
my_foldr f as = compose (map f as)
where compose :: [r -> r] -> (r -> r)
compose = foldr (.) id
Think of this in the following way:
The map operation is converting each element of the list into a "step" of the transformation that we apply to the r values.
The compose function takes the resulting list of "steps" and wires them all together, using the . operator.
And now the trick is that we can write a foldl counterpart with a small change:
my_foldl :: (a -> (r -> r)) -> [a] -> (r -> r)
my_foldl f as = compose (map f as)
where compose :: [r -> r] -> (r -> r)
compose = foldr (flip (.)) id
{- Example:
>>> my_foldl (:) [1..3] []
[3,2,1]
-}
All I did was change (.) to flip (.)! And note that my_foldl is written in terms of map and foldr... but map can be rewritten in terms of foldr as well:
my_map :: (a -> b) -> [a] -> [b]
my_map f = foldr (\a bs -> f a : bs) []
So we've ended up with a solution that's different and longer than the one you're trying to understand, but hopefully it's illuminating.

Answer 2

The crucial thing is how this work with difference lists. Let's write out some explicit conversions:
type DList a = [a]->[a]
emptyDList :: Dlist a
emptyDList = id
fromDList :: DList a -> [a]
fromDList f = f []
myReverse'' :: ∀ a . [a] -> [a]
myReverse'' xs = fromDList $ foldr revCons emptyDList xs
where revCons :: a -> DList a -> DList a
revCons x fId empty = fId $ x : empty
Note that revCons has three arguments, though its signature actually suggests only two: difference lists are really a function type, but you can think of these functions as an abstract optimised representation for concrete lists.

Answer 3

If you do:
Prelude :t \x fId empty -> fId (x : empty)
You will get:
\x fId empty -> fId (x : empty) :: a -> ([a] -> t) -> [a] -> t
This function type here is equivalent to:
a -> ([a] -> t) -> ([a] -> t)
which means a function (binary function) that takes two arguments (the second argument is a function i.e. [a] -> t) and returns a function (i.e. [a] -> t).
This binary function matches the first argument that foldr takes (i.e. a -> b -> b).
In other words, foldr (\x fId empty -> fId (x : empty)) takes two arguments: a function and a list and returns a function.
Prelude> :t foldr (\x fId empty -> fId (x : empty))
foldr (\x fId empty -> fId (x : empty))
:: ([a] -> t) -> [a] -> [a] -> t
Take this example: foldr (\x fId empty -> fId (x : empty)) id [1, 2, 3].
Step 1: 3 and id are passed to the anonymous binary function as arguments. A function like \empty -> id (3 : empty) is returned as the new accumulator value.
Step 2: 2 and \empty -> id (3 : empty) are passed to the anonymous binary function. And \empty -> id (3 : (2 : empty)) is returned.
Step 3: 1 and \empty -> id (3 : (2 : empty)) are passed to the anonymous binary function. And \empty -> id (3 : (2 : (1 : empty))) is returned.
So foldr (\x fId empty -> fId (x : empty)) id [1, 2, 3] produces a function like \empty -> id (3 : (2 : (1 : empty))).
If you apply \empty -> id (3 : (2 : (1 : empty))) to [], then it will give you [3, 2, 1].
This means foldr (\x fId empty -> fId (x : empty)) id [1, 2, 3] [] produces [3, 2, 1].