Use higher-order functions instead of explicit recursion

Question

I want to write a function f that converts a binary list to an integer, like:

f :: [Integer] -> Integer
f [] = 0
f list = (last list) * 2^(length list -1) + f (init list)

For example, in f [1,1,1,1,0,0,1,0] = 79, the first list element represents 2^0 and the last list element represents 2^7.

Can I write this function with higher-order functions instead of with explicit recursion?

Answer 1

It appears the order of your list is unfortunate for foldl, but you can pass the exponent along like so:

intvalueOfList = fst . foldl f (0,1) 
   where f (acc,exp) e = (acc+e*exp, exp*2)

Answer 2

You can make use of foldr :: Foldable f => (a -> b -> b) -> b -> f a -> b which uses a "folding" function that takes an element and the accumulator. The accumulator conceptually runs right-to-left over the list. You can thus each time souble the accumulator and then add the value of the element:

f :: (Foldable f, Num a) => f a -> a
f = foldr g 0
    where g x acc = …

where you still need to fill in g.