anchor.diff:    /// A basic use for a stream source would be to produce a stream in response
     /// to events from a GUI.  For example, given a GUI button, one could write
     ///
  -  ///> let buttonClickSrc = Stream.Src.create ()
  -  ///> button.Click.Add (ignore >> Stream.Src.value buttonClickSrc >> start)
  -  ///
  -  /// to produce a stream of button clicks.  The `Stream.Src.tap` function
  -  /// returns the generated stream, which can then be manipulated using stream
  -  /// combinators.
  -  ///
  -  /// Here is a silly example.  We could write a stream combinator that counts
  -  /// the number of events within a given timeout period:
  -  ///
  -  ///> let eventsWithin timeout xs =
  -  ///>   let inc = xs |> Stream.mapFun (fun _ -> +1)
  -  ///>   let dec = xs |> Stream.mapFun (fun _ -> -1) |> Stream.shift timeout
  -  ///>   Stream.merge inc dec
  -  ///>   |> Stream.scanFromFun 0 (+)
  -  ///
  -  /// Given two stream sources for buttons, the following program would then
  -  /// print "That was fast!" whenever both buttons are clicked within 500ms.
  -  ///
  -  ///> let t500ms = timeOutMillis 500
  -  ///> let n1s = Stream.Src.tap button1ClickSrc |> eventsWithin t500ms
  -  ///> let n2s = Stream.Src.tap button2ClickSrc |> eventsWithin t500ms
  -  ///> Stream.combineLatest n1s n2s
  -  ///> |> Stream.chooseFun (fun (n1, n2) ->
  -  ///>    if n1 > 0 && n2 > 0 then Some () else None)
  -  ///> |> Stream.iterFun (fun () -> printfn "That was fast!")
  -  ///> |> queue
  -  ///
  -  /// Note that there are no special hidden mechanisms involved in the
  -  /// implementation of stream sources.  You can easily implement similar
  -  /// imperative mechanisms outside of the stream library.
  +  ///> let buttonClickSrc = Stream.Src.create ()
  +  ///> button.Click.Add (ignore >> Stream.Src.value buttonClickSrc >> start)
  +  ///
  +  /// to produce a stream of button clicks.  The `Stream.Src.tap` function
  +  /// returns the generated stream, which can then be manipulated using stream
  +  /// combinators.
  +  ///
  +  /// Here is a silly example.  We could write a stream combinator that counts
  +  /// the number of events within a given timeout period:
  +  ///
  +  ///> let eventsWithin timeout xs =
  +  ///>   let inc = xs |> Stream.mapFun (fun _ -> +1)
  +  ///>   let dec = xs |> Stream.mapFun (fun _ -> -1) |> Stream.shift timeout
  +  ///>   Stream.merge inc dec
  +  ///>   |> Stream.scanFromFun 0 (+)
  +  ///
  +  /// Given two stream sources for buttons, the following program would then
  +  /// print "That was fast!" whenever both buttons are clicked within 500ms.
  +  ///
  +  ///> let t500ms = timeOutMillis 500
  +  ///> let n1s = Stream.Src.tap button1ClickSrc |> eventsWithin t500ms
  +  ///> let n2s = Stream.Src.tap button2ClickSrc |> eventsWithin t500ms
  +  ///> Stream.combineLatest n1s n2s
  +  ///> |> Stream.chooseFun (fun (n1, n2) ->
  +  ///>    if n1 > 0 && n2 > 0 then Some () else None)
  +  ///> |> Stream.iterFun (fun () -> printfn "That was fast!")
  +  ///> |> queue
  +  ///
  +  /// Note that there are no special hidden mechanisms involved in the
  +  /// implementation of stream sources.  You can easily implement similar
  +  /// imperative mechanisms outside of the stream library.
   #endif
     type Src<'x>
   
  
positive.code: ﻿// Copyright (C) by Vesa Karvonen
  
  namespace Hopac
  
  
negative.code:   /// stream variable cannot be closed and always has a value.  Stream variables
    /// are one way to represent state, or the model, manipulated by a program
    /// using streams.
    ///
    /// Note that there are no special hidden mechanisms involved in the
    /// implementation of stream variables.  You can easily implement similar
    /// imperative mechanisms outside of the stream library.
  #endif
    type Var<'x>
  
  