When used in the context of an input or output of an Auto, a Blip a represents a stream that occasionally, at "independent" or "discrete" points, emits a value of type a.

Contrast this to Interval, where things are meant to be "on" or "off" for contiguous chunks at a time; blip streams are "blippy", and Intervals are "chunky".

It's here mainly because it's a pretty useful abstraction in the context of the many combinators found in various modules of this library. If you think of an Auto m a (Blip b) as producing a "blip stream", then there are various combinators and functions that are specifically designed to manipulate blip streams.

For the purposes of the semantics of what Blip is supposed to represent, its constructors are hidden. (Almost) all of the various Blip combinators (and its very useful Functor instance) "preserve Blipness" --- one-at-a-time occurrences remain one-at-a-time under all of these combinators, and you should have enough so that direct access to the constructor is not needed.

If you are creating a framework, library, or backend, you might want to manually create blip stream-producing Autos for your users to access. In this case, you can import the constructors and useful internal (and, of course, semantically unsafe) functions from Control.Auto.Blip.Internal.

Takes an Auto m a b (an Auto that turns incoming as into outputting bs) into an Auto m (Blip a) (Blip b); the original Auto is lifted to only be applied to emitted contents of a blip stream.

When the stream emits, the original Auto is "stepped" with the emitted value; when it does not, it is paused and frozen until the next emission.

>>> let sums = perBlip (sumFrom 0)
>>> let blps = eachAt 2 [1,5,2]
>>> take 8 . streamAuto' blps $ repeat ()
[NoBlip, Blip 1, NoBlip, Blip 5, NoBlip, Blip 2, NoBlip, NoBlip]
>>> take 8 . streamAuto' (sums . blps) $ repeat ()
[NoBlip, Blip 1, NoBlip, Blip 6, NoBlip, Blip 8, NoBlip, NoBlip]

Merge two blip streams together; the result emits with either of the two merged streams emit. When both emit at the same time, emit the result of applying the given function on the two emitted values.

Note that this might be too strict for some purposes; see mergeL and mergeR for lazier alternatives.

Merges two blip streams together into one, which emits either of the original blip streams emit. If both emit at the same time, the left (first) one is favored.

Lazy on the second stream if the first stream is emitting.

If we discount laziness, this is merge const.

Merges two blip streams together into one, which emits either of the original blip streams emit. If both emit at the same time, the right (second) one is favored.

Lazy on the first stream if the second stream is emitting.

If we discount laziness, this is merge (flip const).

Merge all the blip streams together into one, favoring the first emitted value.

Merge all the blip streams together into one, favoring the last emitted value.

Merge all of the blip streams together, using the given merging function associating from the right.

Merge all of the blip streams together, using the given merging function associating from the left.

An Auto that runs every input through a a -> Maybe b test and produces a blip stream that emits the value inside every Just result.

Particularly useful with prisms from the lens package, where things like emitJusts (preview _Right) will emit the b whenever the input Either a b stream is a Right.

Warning! Carries all of the same dangers of emitOn. You can easily break blip semantics with this if you aren't sure what you are doing. Remember to only emit at discrete, separate occurences, and not for interval-like (on and off for chunks at a time) things. For interval semantics, we have Control.Auto.Interval.

See the examples of emitOn for more concrete good/bad use cases.

Produces a blip stream that emits the input value whenever the input satisfies a given predicate.

Warning! This Auto has the capability of "breaking" blip semantics. Be sure you know what you are doing when using this. Blip streams are semantically supposed to only emit at discrete, separate occurrences. Do not use this for interval-like (on and off for chunks at a time) things; each input should be dealt with as a separate thing.

For interval semantics, we have Interval from Control.Auto.Interval.

Good example:

-- is only emitting at discrete blips
emitOn even . iterator (+ 1) 0

Bad examples:

-- is emitting for "durations" or "intervals" of time.
emitOn (< 10) . iterator (+ 1) 0

emitOn (const True) . foo

These bad examples would be good use cases of Interval.

Can be particularly useful with prisms from the lens package, where things like emitOn (has _Right) and emitOn (hasn't _Right) will emit the input Either a b whenever it is or isn't a Right. See emitJusts for more common uses with lens.

An Auto that emits whenever it receives a Just input, with the value inside the Just.

Warning! Carries all of the same dangers of emitOn. You can easily break blip semantics with this if you aren't sure what you are doing. Remember to only emit at discrete, separate occurences, and not for interval-like (on and off for chunks at a time) things. For interval semantics, we have Control.Auto.Interval.

See the examples of emitOn for more concrete good/bad use cases.

fromBlips d is an Auto that decomposes the incoming blip stream by constantly outputting d except when the stream emits, and outputs the emitted value when it does.

fromBlipsWith d f is an Auto that decomposes the incoming blip stream by constantly outputting d except when the stream emits, and outputs the result of applying f to the emitted value when it does.

holdWith y0 is an Auto whose output is always the /most recently emitted/ value from the input blip stream. Before anything is emitted, y0 is outputted as a placeholder.

Contrast with hold from Control.Auto.Interval.

A non-serializing/non-resumable version of holdWith.

An Auto that ignores its input and produces a blip stream never emits.

Produces a blip stream that emits with the first received input value, and never again after that.

Often used with pure:

immediately . pure "Emit me!"

Or, in proc notation:

blp <- immediately -< "Emit me!"

to get a blip stream that emits a given value (eg., "Emit me!") once and stops emitting ever again.

>>> streamAuto' (immediately . pure "Emit me!") [1..5]
[Blip "Emit Me!", NoBlip, NoBlip, NoBlip, NoBlip]

Produces a blip stream that only emits once, with the input value on the given step number. It emits the input on that many steps.

immediately == inB 1

every n is an Auto that emits with the incoming inputs on every nth input value. First emitted value is on the nth step.

Will obviously break blip semantics when you pass in 1.

eachAt n xs is an Auto that ignores its input and creates a blip stream that emits each element of xs one at a time, evey n steps. First emitted value is at step n.

Once the list is exhausted, never emits again.

Obviously breaks blip semantics when you pass in 1.

The process of serializing and resuming this Auto is O(n) space and time with the length of xs. So don't serialize this if you plan on passing an infinite list :) See Control.Auto.Generate for more options.

eachAt n xs == perBlip (fromList xs) . every n

The non-serializing/non-resumable version of eachAt.

Re-emits every emission from the input blip stream, but replaces its value with the given value.

tagBlips x == modifyBlips (const x)

Re-emits every emission from the input blip stream, but applies the given function to the emitted value.

Takes two Autos producing blip streams and returns a "merged" Auto that emits when either of the original Autos emit. When both emit at the same time, the left (first) one is favored.

a1 <& a2 == mergeL <$> a1 <*> a2

Takes two Autos producing blip streams and returns a "merged" Auto that emits when either of the original Autos emit. When both emit at the same time, the right (second) one is favored.

a1 &> a2 == mergeR <$> a1 <*> a2

Supress all upstream emitted values except for the very first.

Suppress only the first emission coming from upstream, and let all the others pass uninhibited.

Takes in a blip stream and outputs a blip stream where each emission is delayed/lagged by one step.

>>> streamAuto' (emitOn (\x -> x `mod` 3 == 0)) [1..9]
>>> [NoBlip, NoBlip, Blip 3, NoBlip, NoBlip, Blip 6, NoBlip, NoBlip, Blip 9]
>>> streamAuto' (lagBlips . emitOn (\x -> x `mod` 3 == 0)) [1..9]
>>> [NoBlip, NoBlip, NoBlip, Blip 3, NoBlip, NoBlip, Blip 6, NoBlip, NoBlip]

The non-serializing/non-resuming version of lagBlips.

Suppress all upstream emissions when the predicate (on the emitted value) fails.

Splits a blip stream based on a predicate. Takes in one blip stream and produces two: the first emits whenever the input emits with a value that passes the predicate, and the second emits whenever the input emits with a value that doesn't.

Collapses a blip stream of blip streams into single blip stream. that emits whenever the inner-nested stream emits.

Applies the given function to every emitted value, and suppresses all those for which the result is Nothing. Otherwise, lets it pass through with the value in the Just.

takeB n allows only the first n emissions to pass; it suppresses all of the rest.

Allow all emitted valuesto pass until the first that fails the predicate.

dropB n suppresses the first n emissions from upstream and passes through the rest uninhibited.

Suppress all emited values until the first one satisfying the predicate, then allow the rest to pass through.

Accumulates all emissions in the incoming blip stream with a "folding function", with a given starting value. b -> a -> b, with a starting b, gives Auto m (Blip a) (Blip b).

The resulting blip stream will emit every time the input stream emits, but with the "accumulated value".

Basically accum, but on blip stream emissions.

accumB f x0 == perBlip (accum f x0)

The non-serializing/non-resuming version of accumB.

The output is the result of folding up every emitted value seen thus far, with the given folding function and initial value.

scanB f x0 == holdWith x0 . accumB f x0

>>> let a = scanB (+) 0 . eachAt 2 [1,2,3]
>>> take 8 . streamAuto' a $ repeat ()
[0, 1, 1, 3, 3, 6, 6, 6, 6]

The non-serializing/non-resuming version of scanB.

The output is the mconcat (monoid sum) of all emitted values seen this far.

The non-serializing/non-resuming version of mscanB.

The output is the number of emitted values received from the upstream blip stream so far.

Blip stream that emits whenever the input value changes. Emits with the new value.

Warning: Note that, when composed on a value that is never expected to keep the same value twice, this technically breaks blip semantics.

The non-serializing/non-resumable version of onChange.

Blip stream that emits whenever the predicate applied to the input switches from false to true. Emits with the triggering input value.

The non-serializing/non-resumable version of became.

Like became, but emits a '()' instead of the triggering input value.

Useful because it can be serialized without the output needing a Serialize instance.

Blip stream that emits whenever the predicate applied to the input switches from true to false. Emits with the triggering input value.

The non-serializing/non-resumable version of noLonger.

Like noLonger, but emits a '()' instead of the triggering input value.

Useful because it can be serialized without the output needing a Serialize instance.

Blip stream that emits whenever the predicate applied to the input switches from true to false or false to true. Emits with the triggering input value.

The non-serializing/non-resumable version of onFlip.

Like onFlip, but emits a '()' instead of the triggering input value.

Useful because it can be serialized without the output needing a Serialize instance.