mkAggregator read (using, input, out)
          
          
            Signature: read:('?7728 -> '?7729 -> '?7730 -> Async<'?7731>) -> (using:(('?7728 -> '?7731) -> '?7732) * input:'?7730 * out:'?7729) -> '?7732 
                          Type parameters: '?7728, '?7729, '?7730, '?7731, '?7732           
         | 
        
            
               
               
            
          Aggregate inputs and/or emit at any time.
input: incoming tuple.
out: do something with the output.
using: provide context for the select.
transform: transform the input using a context. 
         | 
      
      
        
          
            mkJoiner toKey
          
          
            Signature: toKey:('?7722 -> '?7723) -> ('?7722 -> '?7724 option -> bool * '?7725) -> ('?7723 -> '?7722 -> '?7725 -> '?7726) -> '?7722 * ('?7726 -> unit) -> unit 
                          Type parameters: '?7722, '?7723, '?7724, '?7725, '?7726           
         | 
        
            
               
               
            
          Join multiple streams into a single output.
toKey: select a key from the input tuple.
toOutput: select output tuple.
aggregate: join new tuple to available tuples and return the (complete,result). 
         | 
      
      
        
          
            mkJoinerWith (...)
          
          
            Signature: (ttl:(type) * numberOfAgents:int) -> toKey:('?7716 -> '?7717) -> aggregate:('?7716 -> '?7718 option -> bool * '?7719) -> toOutput:('?7717 -> '?7716 -> '?7719 -> '?7720) -> '?7716 * ('?7720 -> unit) -> unit 
                          Type parameters: '?7716, '?7717, '?7718, '?7719, '?7720           
         | 
        
            
               
               
            
          Join multiple streams into a single output.
toKey: select a key from the input tuple (has to privide meaningful conversion to string!).
toOutput: select output tuple.
aggregate: join new tuple to available tuples and return the (complete,result).
ttl: time to live for cached data
numberOfAgents: parallelism for mailbox processor doing the join
input: incoming tuple. 
         | 
      
      
        
          
            mkNotifier ofTuple (input, publish)
          
          
            Signature: ofTuple:('?7710 -> '?7711) -> (input:'?7710 * publish:(type)) -> unit 
                          Type parameters: '?7710, '?7711           
         | 
        
            
               
               
            
          Create a simple publisher bolt that always publishes to the same topic.
ofTuple: conversion function
publisher: event stream publisher 
         | 
      
      
        
          
            mkPersister persist (using, input)
          
          
            Signature: persist:('?7699 -> '?7700 -> Async<'?7701>) -> (using:(('?7699 -> Async<'?7701>) -> '?7702) * input:'?7700) -> '?7702 
                          Type parameters: '?7699, '?7700, '?7701, '?7702           
         | 
        
            
               
               
            
          Persist the input in the given context.
input: incoming tuple.
using: provides call context for update.
persist: persit the input using specified context. 
         | 
      
      
        
          
            mkSignalAggregator signals
          
          
            Signature: signals:bigint list -> 't -> bigint list option -> bool * bigint list 
                          Type parameters: 't           
         | 
        
            
               
               
            
          Join aggregator for signals 
         | 
      
      
        
          
            mkTopicNotifier (...)
          
          
            Signature: ofTuple:('?7713 -> '?7714 * string) -> (input:'?7713 * mkPublish:(string -> (type))) -> unit 
                          Type parameters: '?7713, '?7714           
         | 
        
            
               
               
            
          Create a publisher bolt that formats a topic at runtime
ofTuple: conversion function for message and topic format parameter
input: incoming tuple
mkPublish: function taking formatted topic and returning event stream publisher 
         | 
      
      
        
          
            mkTransformer (...)
          
          
            Signature: transform:('?7704 -> '?7705 -> Async<'?7706>) -> (using:(('?7704 -> Async<unit>) -> '?7708) * input:'?7705 * out:('?7707 -> unit)) -> '?7708 
                          Type parameters: '?7704, '?7705, '?7706, '?7707, '?7708           
         | 
        
            
               
               
            
          Transform input into a seq and emit.
input: incoming tuple.
out: do something with the output.
using: provide context for the select.
transform: transform the input using a context. 
         |