anchor.diff:              return! foldPast inner (async.Return state) fr
           }
   
  +    ///Provide operator syntax for bind
       module Operator =
       
  +        //Identical to bind
           let (>>=) m f = bind f m
   
  +     ///Setup for computational expression(Do Notation in haskell) for Feed, to better understand how this works, consider two event streams firing after each other a computation is made each time,
  +     //one of the events is fired.
       module ComputationalExpression = 
           type Builder() =
               member inline this.Return(x : 'T) = pure' x
  
positive.code:             return Async.map ofEvent folded
          }
  
      let plan_ fr = plan fr |> Sample.map Async.Ignore
          
      let transition (f : 's -> 'a -> Async<'s>) (state : 's) (allFeed : Feed<'a>)  : Sample<Async<'s>> =
          sample {
              let! fr = discardOutsideSample allFeed
  
negative.code:     ///Partitions the feed into two feeds, the first satisfy the predicate and the second does not satisfy
      let partition (f : 'a -> bool) (fr : Feed<'a>) : (Feed<'a> * Feed<'a>) = (filter f fr, filter (not << f) fr)   
      
      ///Take events from the feed until the predicate is no longer satisfied
      let takeWhile (f : 'a -> bool) (fr : Feed<'a>) : Feed<'a> =            
          updateEvent (LazyList.delayed << takeWhile' (f << snd)) fr
  
      ///Discard events from the feed until the predicate is no longer satisfied
      let skipWhile (f : 'a -> bool) (fr : Feed<'a>) : Feed<'a> = 
          updateEvent (LazyList.delayed << skipWhile' (f << snd)) fr
              
      ///Discard events occuring before the specified time, excluding events occuring exactly at the time
      let discardOlderExcl (time : Time)  fr : Feed<'a>=
          updateEvent (discardBeforeExcl time) fr
  
      ///Discard events occuring before the specified time, including events occuring exactly at the time
      let discardOlderIncl (time : Time)  fr : Feed<'a>=
          updateEvent (discardBeforeIncl time) fr
          
      ///Discard events occuring after the specified time, including events occuring exactly at the time
      let discardYoungerIncl (time : Time)  fr : Feed<'a>=
          updateEvent (discardAfterIncl time) fr
          
      ///Discard events occuring after the specified time, excluding events occuring exactly at the time
      let discardYoungerExcl (time : Time)  fr : Feed<'a>=
          updateEvent (discardAfterExcl time) fr
  
      ///Discard all events occuring after the sample finish time, excluding events occuring exactly at the finish time
      let discardFuture fr =
          sample {
              let! finish = Period.finish
              return fr |> discardYoungerExcl finish
          }
          
      ///Discard all events occuring before the sample beginning time, including events occuring exactly at the beginning time
      let discardPast fr =
          sample {
              let! beginning = Period.beginning
  