anchor.diff:              member inline this.Zero () = pure' ()
       
           let feed = Builder()
  -    
  +
  +///Debugging functionality for Feed
   module Debug =
  +    ///Debugging functions only for feed
       module Feed =
  +        
  +        ///maps and prints events when they are observered, if they are never observed then print will never occur
           let traceMap f fr = Feed.map (fun (t,v) -> printfn "%A: %A" (Time.toDateTime t) (f v); v) (Feed.timeStamp fr)
  +
  +        ///Same a traceMap but just tries to print the event
           let trace fr = traceMap id fr
positive.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)   
      
      let takeWhile (f : 'a -> bool) (fr : Feed<'a>) : Feed<'a> =            
          updateEvent (LazyList.delayed << takeWhile' (f << snd)) fr
  
  
      let skipWhile (f : 'a -> bool) (fr : Feed<'a>) : Feed<'a> = 
          updateEvent (LazyList.delayed << skipWhile' (f << snd)) fr
              
      let discardOlderExcl (time : Time)  fr : Feed<'a>=
          updateEvent (discardBeforeExcl time) fr
  
      let discardOlderIncl (time : Time)  fr : Feed<'a>=
          updateEvent (discardBeforeIncl time) fr
  
      let discardYoungerIncl (time : Time)  fr : Feed<'a>=
          updateEvent (discardAfterIncl time) fr
  
      let discardYoungerExcl (time : Time)  fr : Feed<'a>=
          updateEvent (discardAfterExcl time) fr
  
      let discardFuture fr =
          sample {
              let! finish = Period.finish
              return fr |> discardYoungerExcl finish
          }
  
      let discardPast fr =
          sample {
              let! beginning = Period.beginning
  
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
  