effectful 0.2.1

Effect<A, E, R> (sync + async), context/layers, pipe — interpreter-style, no bundled executor
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

# Built-in Schedules

effectful's current `Schedule` API is intentionally small. It covers fixed delays, exponential backoff, attempt limits, predicates, composition, and deterministic jitter.

## recurs

```rust,ignore
Schedule::recurs(5)
```

Allows five additional schedule steps with zero delay. Compose it with a delay schedule to cap retries or repeats.

## spaced

```rust,ignore
Schedule::spaced(Duration::from_secs(5))
```

Produces the same delay for every step. Use it for polling, heartbeats, and fixed-interval repeat loops.

## exponential

```rust,ignore
Schedule::exponential(Duration::from_millis(100))
// Delays: 100ms, 200ms, 400ms, 800ms, ...
```

The standard retry backoff. Compose with `Schedule::recurs(n)` to cap attempts.

```rust,ignore
let bounded = Schedule::exponential(Duration::from_millis(100))
    .compose(Schedule::recurs(5));
```

## recurs_while / recurs_until

```rust,ignore
use effectful::{Schedule, ScheduleInput};

let first_ten = Schedule::recurs_while(Box::new(|input: &ScheduleInput| input.attempt < 10));
let until_ten = Schedule::recurs_until(Box::new(|input: &ScheduleInput| input.attempt >= 10));
```

These schedules decide from the attempt counter.

## compose

```rust,ignore
let policy = Schedule::spaced(Duration::from_secs(1))
    .compose(Schedule::recurs(10));
```

`compose` continues only while both schedules continue. When both produce a delay, the larger delay wins.

## jittered

```rust,ignore
let policy = Schedule::exponential(Duration::from_millis(100))
    .jittered()
    .compose(Schedule::recurs(5));
```

`jittered` currently applies deterministic jitter. It is useful for exercising jitter paths without adding random behavior to tests.

## Not Present Yet

The current API does not include Fibonacci schedules, max-delay caps, total-duration caps, method-style `.retry()`, or method-style `.repeat()`. Use the free `retry` / `repeat` functions with factories.