# note to self: löb and möb

Working through the detail of Löb and möb: strange loops in Haskell and the related discussion on reddit.com/r/haskell, in particular psygnisfive’s comment. There’s nothing much original in this post, I’m just working through the details.

The LHS source for this post is here: https://github.com/carlohamalainen/playground/tree/master/haskell/loeb_and_moeb

> module Loeb where


In a spreadsheet one has a set of cells, and each cell can be defined in terms of values in the other cells. For example, let’s use four cells x0, x1, x2, and x3 with the following definition:

> f1 :: [Int]
> f1 = let xs0 = 1
>          xs1 = succ xs0
>          xs2 = succ xs1
>          xs3 = succ xs2
>          xs  = [xs0, xs1, xs2, xs3]
>          in xs


The variable xs0 appears in a few places but it can be factored out. Remove xs0 = 1 and substitute the value 1 in the definition for xs. Also, xs0 is the first element of the xs list, so refer to it using xs !! 0:

> f2 :: [Int]
> f2 = let xs1 = succ (xs !! 0)
>          xs2 = succ xs1
>          xs3 = succ xs2
>          xs = [1, xs1, xs2, xs3]
>          in xs


Now do the same for xs1:

> f3 :: [Int]
> f3 = let xs2 = succ (xs !! 1)
>          xs3 = succ xs2
>          xs = [1, succ (xs !! 0), xs2, xs3]
>          in xs


The pattern should be clear, so now factor out xs2 and xs3:

> f4 :: [Int]
> f4 = let xs = [ 1
>               , succ (xs !! 0)
>               , succ (xs !! 1)
>               , succ (xs !! 2)
>               ]
>          in xs


The common feature of the last three lines is that they are a function of xs. The first line is the constant 1, and we can make this a function of xs with something like

> _ -> 1


but the standard prelude provides const 1 for just this purpose. So now we have:

> f4_1 :: [Int]
> f4_1 = let xs = [ const 1 $xs > , succ (xs !! 0) > , succ (xs !! 1) > , succ (xs !! 2) > ] > in xs  So each line is a function of xs. Can we factor it out, in a sense, so each line looks more like the first? Yes: > f4_2 :: [Int] > f4_2 = let xs = [ const 1$ xs
>                 , succ . (h -> h !! 0) $xs > , succ . (h -> h !! 1)$ xs
>                 , succ . (h -> h !! 2) $xs > ] > in xs  The lambda expressions are a bit cumbersome. What we are doing is the succ function after selecting a certain element of a list. Haskell supports currying, and when one curries an operator, the left vs right arguments are respected: *Main> :t (!!) (!!) :: [a] -> Int -> a *Main> :t (!! 3) (!! 3) :: [a] -> a  So succ (xs !! 0) can be rewritten as succ . (!! 0)$ xs. Here is the next version:

> f5 :: [Int]
> f5 = let xs = [ const 1       $xs > , succ . (!! 0)$ xs
>               , succ . (!! 1) $xs > , succ . (!! 2)$ xs
>               ]
>         in xs


We can still ask if there is a way to generalise the definition of f5. Each line is of the form function $xs so we could define a list of functions > fs = [ const 1 > , succ . (!! 0) > , succ . (!! 1) > , succ . (!! 2) > ]  and then xs = map (-> f xs) fs. In full: > f6_1 :: [Int] > f6_1 = let fs = [ const 1 > , succ . (!! 0) > , succ . (!! 1) > , succ . (!! 2) > ] > xs = map (f -> f xs) fs > in xs  Finally, the lambda expression is a bit clunky and Haskell provides the dollar-sign operator for function application (which is all the lambda expression is actually doing). With currying we get an appropriate type: *Main> :t ($)
($) :: (a -> b) -> a -> b *Main> :t ($ [1, 2, 3])
($[1, 2, 3]) :: Num t => ([t] -> b) -> b  so ($ xs) will be a function that takes a function that operates on a list and returns something (as long as xs is a list). This is just what we need:

> f6_2 :: [Int]
> f6_2 = let fs = [ const 1
>                 , succ . (!! 0)
>                 , succ . (!! 1)
>                 , succ . (!! 2)
>                 ]
>            xs = map ($xs) fs > in xs  and this is the final form in psygnisfive’s comment. (Embarrassingly for myself, I had assumed that the type of (!! xs) would be the result of currying on its left-hand parameter, not the right, which made the map ($ xs) fs form incomprehensible.)

To finish things off, we’d like to write a function that computes the result f6_2 given the list fs. Here’s a first attempt:

> loeb1 fs = let xs = map ($xs) fs in xs  An alternative to using a let definition is to use a where (this brings us closer to the form given by quchen): > loeb2 fs = go where go = map ($ go) fs


Looking at the type of loeb2,

> loeb2 :: [[b] -> b] -> [b]


shows the fact that we used a list as the starting point for the derivation. The first parameter is a list of functions that take a list and produce a value (of the same type), and the result is list. The final remark in psygnisfive’s comment is “rinse and repeat for your favourite functor.” What this refers to is the fact that map is specialised for lists. Functors generalise the idea of being able to “map over” something, and fmap generalises map:

*Main> :t map
map :: (a -> b) -> [a] -> [b]

*Main> :t fmap
fmap :: Functor f => (a -> b) -> f a -> f b

*Main> map (+2) [1, 2, 3]
[3,4,5]

*Main> fmap (+2) [1, 2, 3]
[3,4,5]

*Main> :m Data.Maybe

Prelude Data.Maybe> fmap (+1) (Just 3)
Just 4

Prelude Data.Maybe> fmap (+1) Nothing
Nothing


Changing map to fmap in the definition of loeb2 gets us the actual definition of loeb:

> loeb :: Functor f => f (f b -> b) -> f b
> loeb fs = go where go = fmap ($go) fs  For what it’s worth, putting f = [] specialises to the type signature of the earlier loeb2: > loeb :: [] ([] b -> b) -> [] b  which can be rewritten in the usual form > loeb :: [[b] -> b] -> [b]  It doesn’t end! You can then abstract out the fmap by making it a parameter, which gives the moeb function: > moeb :: t -> (((a -> b) -> b) -> t -> a) -> a > moeb fs x = go where go = x ($ go) fs


See the discussion on reddit for motivation and possible uses of moeb.