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:             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:             let! fr' = discardFuture fr
              return! discardPast fr'
          }
          
      ///Span, applied to a predicate p and a feed, returns a tuple of feed where the first feed  satisfy p and second element is the remainder of the list: 
      let span (p : 'a -> bool) (fr : Feed<'a>) : (Feed<'a> * Feed<'a>) = 
          (takeWhile p fr, skipWhile p fr)
      
      ///Groups elements together where f is satisfied
      let groupBy (f : 'a -> 'a -> bool) (fr : Feed<'a>) : Feed<Feed<'a>> =
          let mapl l = (fst <| LazyList.head l, ofEvent l)
          updateEvent (fun l -> LazyList.map mapl <| groupBy (fun a b -> f (snd a) (snd b)) l) fr
                                
      ///Return a new feed consisting of the results of applying the given accumulating function to the newests events of the feed
      let scan f s = updateEvent (LazyList.scan (fun (_,s) (t,a) -> (t, f s a)) (Time.origin,s))
  
      //Combines mapping events and the results of applying the given accumulating function to the newests events of the feed
      let mapScan (f : 's -> 'a -> ('s * 'b)) (s : 's) (fr : Feed<'a>) : Feed<'s * 'b>= 
          updateEvent (LazyList.ofSeq << fst << (Seq.mapFold (fun s (t,a)  -> let (b, s') = f s a in ((t, (b, s'))), b) s) ) fr
  
      ///Discards all events outside the sample, then scanMaps from the past
      let mapScanPast (f : 's -> 'a -> ('s * 'b)) (state : 's) (fr : Feed<'a>) : (Sample<Feed<'s * 'b>>) =
          sample {
              let! fr' = discardOutsideSample fr
  