for v in V: d[v] = infinity; parent[v] = none
d[s] = 0
repeat |V|-1 times:
    changed = false
    for each edge (u,v) of weight w:
        if d[u] != infinity and d[u] + w < d[v]:
            d[v] = d[u] + w
            parent[v] = u
            changed = true
    if not changed: break
for each edge (u,v) of weight w:
    if d[u] != infinity and d[u] + w < d[v]:
        report a reachable negative-weight cycle

filter p = unfold null head next . seek
  where
    seek = dropWhile (not . p)
    next = seek . tail

fibs :: [Integer]
fibs = unfold (const False) fst step (0,1)
  where
    step (a,b) = (b,a+b)

map f     = unfold null (f . head) tail
iterate f = unfold (const False) id f

unfold p f g = map f . takeWhile (not . p) . iterate g

iterate :: (a -> a) -> a -> [a]
iterate f x = x : iterate f (f x)

unfold :: (s -> Bool) -> (s -> a) -> (s -> s) -> s -> [a]