WillNess

fmap :: (a->b) -> foo a -> foo b             (a->b) -> (p->a) -> (p->b)
fmap :: (c->d) -> bar c -> bar d             (c->d) -> (q->c) -> (q->d)
(.)  :: (t->u) -> (s->t) -> (s->u)

(.) fmap :: -- t ~ (a->b)  ;  u ~ (foo a->foo b)
            (s->a->b) -> (s->foo a->foo b)             (s->a->b) -> (s->(p->a)->(p->b))

(.) fmap fmap :: s ~ (c->d)  ;  a ~ (bar c)  b ~ (bar d)
             ( (c->d) -> foo(bar c) -> foo(bar d) ) 

WillNess

g x y = (return . (+x)) =<< y
 = (=<<) (return . (+x)) y
 = ((=<<) . (return .)) ((+) x) y
 = (=<<) . (return .) . (+) $ x y

h mx my = mx >>= (\x ->
          my >>= (\y ->
          return (x+y) ))

h mx my = do x <- mx

WillNess

zero s z = z
succ n s z = s (n s z)
one s z = s z
two s z = s (s z)

false x y = y = zero x y 
true  x y = x = const x y

const x y = x

WillNess

-- http://stackoverflow.com/questions/10368835/partitioning-a-list-in-racket

foldr (\x r-> case r of [] -> [[x]]; ((a:_):_) | x+1 /= a -> [x]:r; (b:c) -> ((x:b):c)) []

-- or, MUCH preferred, TRMC:
foldr (\x r-> let (b:c)=case r of {[] -> [[]]; ((a:_):_) | x+1 /= a -> []:r; _ -> r} in ((x:b):c)) []

--  [1,2,3,5,6,8,9]  ==>  [[1,2,3],[5,6],[8,9]]

WillNess

{- Author:     Jeff Newbern
   Maintainer: Jeff Newbern <jnewbern@nomaware.com>
   Time-stamp: <Mon Nov 10 11:59:14 2003>
   License:    GPL
-}

{- DESCRIPTION

Example 1 - Our first monad

WillNess

    hamm = 1:foldl (\s n->let r = merge s (n:map (n*) r) in r)  [] [5,3,2]

      r0 = []
      r1 = merge r0 (5: map (5*) r1) = [5^i | i<-[1..]]
      r2 = merge r1 (3: map (3*) r2) = r1 + map(3*)(1:r1) + map(9*)(1:r1) + ...
                                          + map( 3^n *)(1:r1) + ...
      r3 = merge r2 (2: map (2*) r3) = r2 + map(2*)(1:r2) + map(4*)(1:r2) + ...
                                          + map( 2^n *)(1:r2) + ...

    so, given a factorization [(p_i,k_i)], the number's divisors are:

WillNess

http://stackoverflow.com/questions/15730385/scheme-pairs-output/15731206#15731206

    ipairs (x:xs) (y:ys) = (x,y) : g xs ys [map ((,) x) ys] where
      g (x:xs) (y:ys) ac = (x,y) : map head ac ++ g xs ys (map ((,) x) ys : map tail ac)

    ipairs1 (x:xs) (y:ys) = (x,y) : g xs ys [map ((,) x) ys] where
      g (x:xs) (y:ys) ac = map head (reverse ac) ++ (x,y) : g xs ys (map ((,) x) ys : map tail ac)

In Scheme,

WillNess

{-# LANGUAGE PatternGuards #-}

-- triangular enumeration by upward diagonals
triags :: [[a] -> [a]
triags s = g s []
  where
    g [] [] = []
    g s a = let (h,t) = splitAt 1 s 
                acc = filter (not.null) $ h ++ a 
            in map head acc ++ g t (map tail acc) 

WillNess

"A cheeky person can thus express any infinitary recursion as a non-recursive foldr 
on an infinite list. E.g.,

foldr (\_ fibs -> 1 : 1 : zipWith (+) fibs (tail fibs)) undefined [1..]

(Edit: or, for that matter

foldr (\_ fib a b -> a : fib b (a + b)) undefined [1..] 1 1

which is closer to the definition in the question.)"

WillNess

a note on dave4420's comment: 

    sequence [a,b] 
     = a >>= (\x -> b >>= (\y -> return [x,y])) 
     = a >>= (\x -> sequence [b] >>= (\xs -> return x:xs))

For `Monad ((->) r)`,  `(f >>= k) r = k (f r) r = (k.f) r r = join (k.f) r` 
(makes sense, because in general, `f>>=k = join (fmap k f)`. 

so, `sequence [a,b] r = (a >>= k1) r = k1 (a r) r`.