 doc.fn "observable.flatMapFirst(f)", """
 like flatMap, but doesn't spawns a new
 stream only if the previously spawned stream has ended.
+
+The [Function Construction rules](#function-construction-rules) below apply here.
+"""
+
+doc.fn "observable.flatMapWithConcurrencyLimit(@ : Observable[A], limit : Number, f : A -> Observable[B] | Event[B] | B) : EventStream[B]", """
+a super method of *flatMap* family. It limits the number of open spawned streams and buffers incoming events.
+`flatMapConcat` is `flatMapWithConcurrencyLimit(1)` (only one input active),
+and `flatMap` is `flatMapWithConcurrencyLimit ∞` (all inputs are piped to output).
+
+The [Function Construction rules](#function-construction-rules) below apply here.
+"""
+
+doc.fn "observable.flatMapConcat(@ : Observable[A], f : A -> Observable[B] | Event[B] | B) : EventStream[B]", """
+a `flatMapWithConcurrencyLimit` with limit of 1.
+
+The [Function Construction rules](#function-construction-rules) below apply here.
+"""
+
+doc.fn "observable.rateLimit(@ : Observable[A], minimumInterval) : EventStream[A]", """
+rate limits and buffers changes in the observable, so at most one event in minimumInteval is issued.
 """
 
 doc.fn "observable.scan(seed, f) : Property[A]", """

"""

doc.fn "observable.flatMapLatest(f)", """
like flatMap, but instead of including events from
all spawned streams, only includes them from the latest spawned stream.
You can think this as switching from stream to stream.
Note that instead of a function, you can provide a stream/property too.

  .input("Bacon.sequentially(200, [9,0,2,0,0,3]).filter(function(x) { return x })")
  .input("Bacon.sequentially(200, [0,1,0,12,8,0]).filter(function(x) { return x })")
  .output("function(a,b) { return a.merge(b) }")

doc.fn "stream.holdWhen(@ : EventStream[A], valve : Observable[B]) : EventStream[A]", """
pauses and buffers the event stream if last event in valve is truthy.
All buffered events are released when valve becomes falsy.
"""

doc.fn "stream.startWith(value)", """
adds a starting value to the stream, i.e. concats a
