anchor.diff:      ///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
  
positive.code:             return! foldPast inner (async.Return state) fr
          }
  
      module Operator =
      
          let (>>=) m f = bind f m
  
      module ComputationalExpression = 
          type Builder() =
              member inline this.Return(x : 'T) = pure' x
  
negative.code:             return Async.map ofEvent folded
          }
  
      ///Same as plan but discard the feed of results
      let plan_ fr = plan fr |> Sample.map Async.Ignore
          
      ///Discard all events outside the sample, then from the past folds all the events of Feed<'a> using an async state transition into a single state
      let transition (f : 's -> 'a -> Async<'s>) (state : 's) (allFeed : Feed<'a>)  : Sample<Async<'s>> =
          sample {
              let! fr = discardOutsideSample allFeed
  