使用fold *在Haskell中增加列表

Question

I'm trying to solve the following problem in Haskell: given an integer return the list of its digits. The constraint is I have to only use one of the fold* functions (* = {r,l,1,l1}).

Without such constraint, the code is simple:

list_digits :: Int -> [Int]
list_digits 0 = []
list_digits n = list_digits r ++ [n-10*r] 
                where
                     r = div n 10

But how do I use fold* to, essentially grow a list of digits from an empty list?

Thanks in advance.

Answer 1

Is this a homework assignment? It's pretty strange for the assignment to require you to use foldr , because this is a natural use for unfoldr , not foldr . unfoldr :: (b -> Maybe (a, b)) -> b -> [a] builds a list, whereas foldr :: (a -> b -> b) -> b -> [a] -> b consumes a list. An implementation of this function using foldr would be horribly contorted.

listDigits :: Int -> [Int]
listDigits = unfoldr digRem
    where digRem x
              | x <= 0 = Nothing
              | otherwise = Just (x `mod` 10, x `div` 10)

In the language of imperative programming, this is basically a while loop. Each iteration of the loop appends x `mod` 10 to the output list and passes x `div` 10 to the next iteration. In, say, Python, this'd be written as

def list_digits(x):
    output = []
    while x > 0:
        output.append(x % 10)
        x = x // 10
    return output

But unfoldr allows us to express the loop at a much higher level. unfoldr captures the pattern of "building a list one item at a time" and makes it explicit. You don't have to think through the sequential behaviour of the loop and realise that the list is being built one element at a time, as you do with the Python code; you just have to know what unfoldr does. Granted, programming with folds and unfolds takes a little getting used to, but it's worth it for the greater expressiveness.

If your assignment is marked by machine and it really does require you to type the word foldr into your program text, (you should ask your teacher why they did that and) you can play a sneaky trick with the following " id [] -as- foldr " function:

obfuscatedId = foldr (:) []
listDigits = obfuscatedId . unfoldr digRem

Answer 2

Though unfoldr is probably what the assignment meant, you can write this using foldr if you use foldr as a hylomorphism , that is, building up one list while it tears another down.

digits :: Int -> [Int]
digits n = snd $ foldr go (n, []) places where
  places = replicate num_digits ()
  num_digits | n > 0     = 1 + floor (logBase 10 $ fromIntegral n)
             | otherwise = 0
  go () (n, ds) = let (q,r) = n `quotRem` 10 in (q, r : ds)

Effectively, what we're doing here is using foldr as "map-with-state". We know ahead of time how many digits we need to output (using log10) just not what those digits are, so we use unit ( () ) values as stand-ins for those digits.

If your teacher's a stickler for just having a foldr at the top-level, you can get away with making go partial:

digits' :: Int -> [Int]
digits' n = foldr go [n] places where
  places = replicate num_digits ()
  num_digits | n > 0     = floor (logBase 10 $ fromIntegral n)
             | otherwise = 0
  go () (n:ds) = let (q,r) = n `quotRem` 10 in (q:r:ds)

This has slightly different behaviour on non-positive numbers:

>>> digits 1234567890
[1,2,3,4,5,6,7,8,9,0]
>>> digits' 1234567890
[1,2,3,4,5,6,7,8,9,0]
>>> digits 0
[]
>>> digits' 0
[0]
>>> digits (negate 1234567890)
[]
>>> digits' (negate 1234567890)
[-1234567890]