The New Haskell Homepage(new-www.haskell.org)

    data BTree a = Node a (BTree a) (BTree a)

    fold :: (a -> x -> x -> x) -> BTree a -> x
    fold f (Node a l r) = f a (fold f l) (fold f r)

    unfold :: (x -> (a, x, x)) -> x -> BTree a
    unfold f x = let (a, l, r) = f x in Node a (unfold f l) (unfold f r)

    breadthFirst :: BTree a -> [a]
    breadthFirst = concat . fold glue where
      glue a ls rs = [a] : zipWith (++) ls rs

    allRationals :: Fractional a => [a]
    allRationals = breadthFirst (unfold step (1, 1)) where
      step (m, n) = ( m/n, (m, m+n)
                         , (n+m, n) )

    data BTree a = Node a (BTree a) (BTree a)

    breadthFirst :: BTree a -> [a]
    breadthFirst = concat . glue where
      glue (Node a ls rs) = [a] : zipWith (++) (glue ls) (glue rs)

    rats :: Fractional a => [a]
    rats = breadthFirst (generate (1, 1)) where
      generate (m, n) = Node (m/n) (generate (m, m+n)) (generate (n+m, n))

    import Data.Tree

    allRationals :: Fractional a => [a]
    allRationals = flatten (unfoldTree step (1, 1)) where
      step (m, n) = ( m/n, [ (m, m+n), (n+m, n) ] )

    data Trip a x = Trip a x x deriving Functor

    hylo :: Functor f => (f b -> b) -> (a -> f a) -> a -> b
    hylo phi psi = phi . fmap (hylo phi psi) . psi

    allRationals :: Fractional a => [a]
    allRationals = concat (hylo glue step (1, 1)) where
      glue (Trip a ls rs) = [a] : zipWith (++) ls rs
      step (m, n) = Trip (m/n) (m, m+n) (n+m, n)

    allRationals :: Fractional a => [a]
    allRationals = concat (go (1, 1)) where
      go               = glue . next . step
      next (a, b, c)   = (a, f b, f c)
      glue (a, ls, rs) = [a] : zipWith (++) ls rs
      step (m, n)      = ( m/n, (m, m+n), (n+m, n) )

    allRationals :: Fractional a => [a]
    allRationals = concat (go 1 1) where go m n = [m/n] : zipWith (++) (go m (m+n)) (go (n+m) n)

    allRationals :: Fractional a => [a]
    allRationals = go 1 1 where go m n = (m/n) : interleave (go m (m+n)) (go (n+m) n)

    interleave :: [a] -> [a] -> [a]
    interleave []     ys     = ys
    interleave xs     []     = xs
    interleave (x:xs) (y:ys) = x : y : interleave xs ys

    from fractions import Fraction
    from itertools import islice

    def interleave(x, y):
      while True:
        yield x.next()
        yield y.next()

    def all_rationals():
      def go(m, n):
        yield (m/n)
        for v in interleave(go(m, m+n), go(m+n, n)):
          yield v
      return go(Fraction(1,1), Fraction(1,1))

    def rationals(n):
      return list(islice(all_rationals(), n))

  fibonacci :: Integer -> Integer
  fibonacci 0 = 0
  fibonacci 1 = 1
  fibonacci n = fibonacci (n - 1) + fibonacci (n - 2)

    def tuple_decomp( (a,b) ):
        return a+b

    factorial 0 = 1
    factorial n = n * factorial (n-1)

    factorial n = if n == 0 
                    then 1
                    else n * factorial (n-1)

    multiply 0 _ = 0
    multiply _ 0 = 0
    multiply n m = n * m

    multiply (f (g (h 999))) 0

    multiply( f(g(h(999))), 0);

    data Pet = 
        Cat {
            color :: String,
            breed :: String,
            annoying :: Bool
        } |
        Dog {
            breed :: String,
            trained :: Bool
        }

    likePet (Cat "Yellow" _ _) = True
    likePet (Cat _ _ False) = True
    likePet (Cat _ _ _) = False
    likePet (Dog _ True) = True
    likePet (Dog _ _) = False

    def sieve(xs): p = next(xs); yield p; yield from sieve(x for x in xs if x % p != 0)
    primes = sieve(itertools.count(2))