A BIO(blocked IO) node.

A BIO node consist of two functions: push and pull. It can be used to describe different kinds of IO devices:

• BIO inp out describe an IO state machine(e.g. z_stream in zlib), which takes some input in block, then outputs.
• type Source out = BIO Void out described an IO source, which never takes input, but gives output until EOF when pulled.
• type Sink inp = BIO inp Void described an IO sink, which takes input and perform some IO effects, such as writing to terminal or files.

You can connect these BIO nodes with >|>, which connect left node's output to right node's input, and return a new BIO node with left node's input type and right node's output type.

You can run a BIO node in different ways:

• runBIO will continuously pull value from source, push to sink until source reaches EOF.
• runSource will continuously pull value from source, and perform effects along the way.
• runBlock will supply a single block of input as whole input, and return output if there's any.
• runBlocks will supply a list of blocks as whole input, and return a list of output blocks.

Note BIO usually contains some IO states, you can consider it as an opaque IORef:

• You shouldn't use a BIO node across multiple BIO chain unless the state can be reset.
• You shouldn't use a BIO node across multiple threads unless document states otherwise.

BIO is simply a convenient way to construct single-thread streaming computation, to use BIO in multiple threads, check Z.IO.BIO.Concurrent module.

Type alias for BIO node which never takes input.

push is not available by type system, and pull return Nothing when reaches EOF.

Type alias for BIO node which only takes input and perform effects.

push doesn't produce any meaningful output, and pull usually does a flush.

Exception when run BIO failed.

Note this exception is a sub-type of SomeIOException.

Exception when BIO parse failed, this exception is one of a particular BIOException.

Exception when BIO convert to json failed, this exception is one of a particular BIOException.

Connect two BIO nodes, feed left one's output to right one's input.

Flipped fmap for easier chaining.

Connect BIO to an effectful function.

Connect two BIO source, after first reach EOF, draw element from second.

Connect list of BIO sources, after one reach EOF, draw element from next.

Zip two BIO source into one, reach EOF when either one reached EOF.

Zip two BIO node into one, reach EOF when either one reached EOF.

The output item number should match, unmatched output will be discarded.

Fuse two BIO sinks, i.e. everything written to the fused sink will be written to left and right sink.

Flush result BIO will effectively flush both sink.

Fuse a list of BIO sinks, everything written to the fused sink will be written to every sink in the list.

Flush result BIO will effectively flush every sink in the list.

Run a BIO loop (source >|> ... >|> sink).

Drain a BIO source into a List in memory.

Drain a source without collecting result.

Supply a single block of input, then run BIO node until EOF.

Note many BIO node will be closed or not be able to take new input after drained.

Supply a single block of input, then run BIO node until EOF with collecting result.

Note many BIO node will be closed or not be able to take new input after drained.

Wrap a stream computation into a pure interface.

You can wrap a stateful BIO computation(including the creation of BIO node), when you can guarantee a computation is pure, e.g. compressing, decoding, etc.

Supply blocks of input, then run BIO node until EOF.

Note many BIO node will be closed or not be able to take new input after drained.

Supply blocks of input, then run BIO node until EOF with collecting result.

Note many BIO node will be closed or not be able to take new input after drained.

Wrap a stream computation into a pure interface.

Similar to unsafeRunBlock, but with a list of input blocks.

BIO node from a pure function.

BIO node made with this funtion are stateless, thus can be reused across chains.

BIO node from an IO function.

BIO node made with this funtion may not be stateless, it depends on if the IO function use IO state.

Source a list from memory.

Turn a file into a Bytes source.

Turn a BufferedInput into BIO source, map EOF to Nothing.

Turn an input device into a Bytes source.

Turn a UTF8 encoded BufferedInput into BIO source, map EOF to Nothing.

Turn an input device into a Text source.

Turn a JSON encoded BufferedInput into BIO source, ignoring any whitespaces bewteen JSON objects. If EOF reached, then return Nothing.

Turn an input device into a JSON source.

Turn buffered input device into a packet source.

Turn input device into a packet source.

Sink to a list in memory.

The list's IORef is not thread safe here, and list items are in reversed order during sinking(will be reversed when flushed, i.e. pulled), Please don't use it in multiple thread.

Turn a BufferedOutput into a Bytes sink.

Turn a BufferedOutput into a Builder sink.

Turn an Output into 'V,Bytes' sink.

push will write input to buffer, and pull_ will flush buffer.

Turn a file into a Bytes sink.

Note the file will be opened in O_APPEND .|. O_CREAT .|. O_WRONLY mode, bytes will be written after the end of the original file if there'are old bytes.

Turn an Output into Builder sink.

push will write input to buffer, and pull_ will flush buffer.

Turn an Output into BIO sink.

push will write input to buffer then perform flush, tend to degrade performance.

Read buffer and parse with Parser.

This function will continuously draw data from input before parsing finish. Unconsumed bytes will be returned to buffer.

Return Nothing if reach EOF before parsing, throw ParseException if parsing fail.

Make a chunk size divider.

A divider size divide each chunk's size to the nearest multiplier to granularity, last trailing chunk is directly returned.

Make a new UTF8 decoder, which decode bytes streams into text streams.

Note this node is supposed to be used with preprocess node such as compressor, decoder, etc. where bytes boundary cannot be controlled, UTF8 decoder will concat trailing bytes from last block to next one. Use this node directly with sourceFromBuffered / sourceFromInput will not be as efficient as directly use sourceTextFromBuffered / sourceTextFromInput, because BufferedInput provides push back capability, trailing bytes can be pushde back to reading buffer and returned with next block input together.

Make a new stream splitter based on magic byte.

Make a new stream splitter based on linefeed(rn or n).

The result bytes doesn't contain linefeed.

Make a new base64 encoder node.

Make a new base64 decoder node.

Make a hex encoder node.

Hex encoder is stateless, it can be reused across chains.

Make a new hex decoder node.

Make a new BIO node which counts items flow throught it.

Returned Counter is increased atomically, it's safe to read / reset the counter from other threads.

Make a new BIO node which counts items, and label item with a sequence number.

Returned Counter is increased atomically, it's safe to read / reset the counter from other threads.

Make a BIO node grouping items into fixed size arrays.