necoherence/transition

Types

Capacity

opaque

A bound on how many outputs one transition may accumulate.

pub opaque type Capacity

CapacityError

pub type CapacityError {
  CapacityNegative(value: Int)
}

Constructors

```
CapacityNegative(value: Int)
```

Consumption

What one application of the caller’s advance function decided about the input it was given.

pub type Consumption(state, output) {
  Consumed(state: state, outputs: List(output))
  Reprocess(state: state, outputs: List(output))
}

Constructors

Consumed(state: state, outputs: List(output))

Reprocess(state: state, outputs: List(output))

LimitError

pub type LimitError {
  LimitNotPositive(value: Int)
}

Constructors

```
LimitNotPositive(value: Int)
```

PositiveLimit

opaque

A positive bound on how many times one input may be reprocessed.

pub opaque type PositiveLimit

StepFailure

Why a transition stopped without consuming its input.

pub type StepFailure {
  ReprocessLimitExhausted(limit: Int)
  CapacityExceeded(capacity: Int, attempted: Int)
}

Constructors

```
ReprocessLimitExhausted(limit: Int)
```

CapacityExceeded(capacity: Int, attempted: Int)

StepTransition

The closed result of one transition.

pub type StepTransition(state, output) {
  Settled(state: state, outputs: List(output), applications: Int)
  Failed(
    state: state,
    outputs: List(output),
    failure: StepFailure,
  )
}

Constructors

Settled(state: state, outputs: List(output), applications: Int)

Failed(state: state, outputs: List(output), failure: StepFailure)

Values

capacity_new

pub fn capacity_new(
  value: Int,
) -> Result(Capacity, CapacityError)

capacity_value

pub fn capacity_value(capacity: Capacity) -> Int

positive_limit_new

pub fn positive_limit_new(
  value: Int,
) -> Result(PositiveLimit, LimitError)

positive_limit_value

pub fn positive_limit_value(limit: PositiveLimit) -> Int

step

pub fn step(
  state: state,
  input: input,
  advance: fn(state, input) -> Consumption(state, output),
  limit: PositiveLimit,
  capacity: Capacity,
) -> StepTransition(state, output)

Evaluate one input to a closed result in a single call.

advance is applied to the same input until it reports Consumed, at most limit times. Outputs keep the order in which advance produced them and never exceed capacity.