anchor.diff:  open System.Threading
   open Hopac
   open Hopac.Infixes
  +
  +[<AutoOpen>]
  +module Util =
  +  let inline (^) x = x
   
   module Stream =
     open Stream
  
positive.code:       let timer = Stopwatch.StartNew ()
        let result =
          pyramid m n
          |> Stream.skip (int64 n)
          |> Stream.get
          |> run
        let stop = timer.Elapsed
  
negative.code:         .Where(fun i -> (i &&& 8) = 0)
          .Subscribe() |> ignore
  
       bench "chooseFun" 1000000 ^ fun n ->
         Stream.ints n
         |> Stream.chooseFun ^ fun i -> if (i &&& 1) = 0 then Some (i+1) else None
         |> Stream.chooseFun ^ fun i -> if (i &&& 2) = 0 then Some (i+2) else None
         |> Stream.chooseFun ^ fun i -> if (i &&& 4) = 0 then Some (i+4) else None
         |> Stream.iter |> run
  
       bench "merge" 1000000 ^ fun n ->
         Stream.merge
          <| Stream.ints n
          <| Stream.ints n
         |> Stream.iter |> run
  
       bench "mapFun" 1000000 ^ fun n ->
         Stream.ints n
         |> Stream.mapFun ^ fun n -> n + 1
         |> Stream.mapFun ^ fun n -> n - 1
         |> Stream.iter |> run
       bench "Observable.Select" 1000000 ^ fun n ->
         Obs.ints(n)
          .Select(fun n -> n + 1)
          .Select(fun n -> n - 1)
          .Subscribe() |> ignore
  
       bench "generateFun" 10000000 ^ fun n ->
         Stream.ints n |> Stream.iter |> run
       bench "Observable.Generate" 10000000 ^ fun n ->
         Obs.ints(n).Subscribe() |> ignore
  
  module Streams =
    let split xss =
      xss
      |> Seq.collect ^ fun xs ->
           [Stream.mapFun (fun x ->  x      / 2) xs
            Stream.mapFun (fun x -> (x + 1) / 2) xs]
    let join xss =
      xss
      |> Seq.pairwise
      |> Seq.map ^ fun (xs, ys) ->
           Stream.zipWithFun (+) xs ys
  
    let ints _ = Stream.iterateFun (fun x -> x+1) 0
  
    module Fib =
      let fibs () = Stream.fix ^ fun fibs ->
        Stream.cons 0I (Stream.cons 1I (Stream.zipWithFun (+) fibs (Stream.tail fibs)))
  
      let run n =
  