pipes

The pipes ecosystem is organized into a core library and several specialized libraries designed for different streaming needs:

Core Libraries

• pipes: The theoretically-principled core.
• pipes-concurrency: Provides message passing and reactive programming capabilities.
• pipes-parse: Provides utilities for parsing streams.
• pipes-safe: Handles resource management and exception safety.

Derived Libraries

These libraries build upon the core ecosystem for specific tasks:

• pipes-network and pipes-network-tls: Networking support.
• pipes-attoparsec: High-efficiency streaming parsing.
• pipes-zlib: Compression and decompression.
• pipes-binary: Streaming serialization and deserialization.
• pipes-aeson: Streaming JSON encoding and decoding.

In the Request Category, the distributivity law ensures that a transformation (represented by (\>)) distributes over the composition of two Kleisli arrows ((>=>)).

Mathematically, the law is expressed as: fb' \> (k1 >=> k2) = (fb' \> k1) >=> (fb' \> k2)

This property is essential for maintaining consistency when applying transformations to composed request-response sequences.

The Distributivity Law defines how the reflect function interacts with Kleisli composition (>=>) and function composition (.). It ensures that reflecting a composed Kleisli arrow is equivalent to composing the reflections of the individual arrows.

Mathematical Goal: reflect . (f >=> g) = reflect . f >=> reflect . g

The respond operation in pipes is mathematically tied to the request operation through the reflect function.

Specifically, the framework satisfies the Respond Identity law:

reflect . respond = request

This implies that applying a response and then reflecting it is functionally identical to simply initiating a request. In pointful notation, this is expressed as:

reflect (respond x) = request x

The Pull Category is mathematically sound, adhering to the following laws:

• Left Identity: pull >+> f = f
• Right Identity: fb' >+> pull = fb'
• Associativity: fb' >+> (fc' >+> fd') = (fb' >+> fc') >+> fd'

These laws ensure that using pull as an identity element and re-grouping compositions does not change the behavior of the proxy pipeline.

The Respond Category follows specific identity laws for composing responses:

1. Right Identity: Composing a respond action with a function fb is equivalent to applying fb to the value (respond />/ fb = fb).
2. Left Identity: Composing a function fa with respond is equivalent to the original function (fa />/ respond = fa).

In the Kleisli Category, the composition operator (/>/) follows the Associativity Law. This ensures that when composing three functions (or Kleisli arrows) fa, fb, and fc, the grouping of the first two does not affect the final result.

Goal: (fa />/ fb) />/ fc = fa />/ (fb />/ fc)

-- Goal: (fa />/ fb) />/ fc = fa />/ (fb />/ fc)

-- Definition of (/>/)
\a -> ((fa />/ fb) a) //> fc

-- Definition of (/>/)
\a -> (fa a //> fb) //> fc

The Zero Law states that composing the return function (which wraps a value in a Pure context) with any function f is equivalent to just returning the value itself. This implies that return acts as an identity-like element for the (/>/) operator.

Goal: return />/ f = return

-- Goal: return />/ f = return

-- Definition of (/>/)
= \r -> return r //> f

-- [Respond Category - Zero Law - Pointful]
= \r -> return r

-- Eta reduce
= return

The framework defines how responding to a process interacts with composition. The Respond Composition law states that reflecting a composition of two processes (f />/ g) is equivalent to the composition of their reflected parts using the ▷\ operator:

reflect . (f />/ g) = reflect . g ▷\ reflect . f

Additionally, the framework satisfies the following identity for the (//>) operator:

reflect (p //> f) = reflect . f ▷\ reflect p

The Zero Law establishes that reflect is an identity operation with respect to the return function (which wraps a value in a Pure constructor). Applying reflect to a value wrapped by return is equivalent to simply using return.

Mathematical Goals:

• reflect . return = return (Functorial/Compositional form)
• reflect (return r) = return r (Pointwise form)

The Involution Law states that reflect is its own inverse. Applying reflect twice to a process or value returns the original structure. This implies that reflect acts as a dualizing operation between Request and Respond states.

Mathematical Goal: reflect . reflect = id (or reflect (reflect p) = p)

The pipes implementation of the Kleisli Category adheres to three fundamental mathematical laws, ensuring predictable composition of Proxy operations:

1. Left Identity: Composing return with a function f is equivalent to f itself (return >=> f = f).
2. Right Identity: Composing a function f with return is equivalent to f itself (f >=> return = f).
3. Associativity: The order of grouping in composition does not matter ((f >=> g) >=> h = f >=> (g >=> h)).