anchor.diff:      |> Seq.map (fun (xs, ys) ->
          Observable.zipWith (+) xs ys)
   
  -  let ints () = Observable.generate 0 (fun _ -> true) ((+) 1) id
  +  let ints n = Observable.generate 0 (fun x -> x <= n) ((+) 1) id
   
     module Pyramid =
  -    let rec pyramid n =
  -      if n <= 0
  -      then ints ()
  -      else let xs = pyramid (n-1)
  -           let ys = pyramid (n-1)
  +    let rec pyramid m n =
  +      if m <= 0
  +      then ints (n+1)
  +      else let xs = pyramid (m-1) n
  +           let ys = pyramid (m-1) n
              Observable.zipWith (+) xs ys
   
       let run m n =
         let timer = Stopwatch.StartNew ()
         let result = ref -1
  -      (pyramid m
  +      (pyramid m n
          |> Observable.skip n).SubscribeOn(System.Reactive.Concurrency.ThreadPoolScheduler.Instance)
         |> Observable.subscribe (fun x ->
            lock result <| fun () ->
  
positive.code: 
    module Diamond =
      let rec repeat n f xs = if n = 0 then xs else repeat (n-1) f (f xs)
      let diamond n =
        Seq.singleton (ints ())
        |> repeat n split
        |> repeat n join
        |> Seq.head
  
      let run m n =
        let timer = Stopwatch.StartNew ()
        let result =
          diamond m
          |> Stream.skip (int64 n)
          |> Stream.get
          |> run
  
negative.code:       printfn "fib %d = %s, took %A" n (result.ToString ()) stop
  
    module Pyramid =
      let rec pyramid m n =
        if m <= 0
        then ints (n+1)
        else let xs = pyramid (m-1) n
             let ys = pyramid (m-1) n
             Stream.zipWithFun (+) xs ys
  
      let run m n =
        let timer = Stopwatch.StartNew ()
        let result =
          pyramid m n
          |> Stream.skip (int64 n)
          |> Stream.get
          |> run
  