mumu-flow 0.1.0

Stream tranform tools plugin for the Lava language
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

# Lava Flow | Streaming & transforms for Lava

> Streaming flow and Functional Transformation for Lava/Mumu scripts
 
- GitLab: https://gitlab.com/tofo/mumu-flow 
- Crates.io: https://crates.io/crates/mumu-flow
-
 Author: Tom Fotheringham & contributors
- License: MIT | Apache-2.0


This plugin adds JSSON (stream) tools (Functional, Partial, Underscore Parial) to the Lava language via `cd(Lava)`. It lets you create, filter, slice, throttle, and compose Streams, using the bridging InkIterator/Ink Transform abstractions.

This module is loaded via Lava's `extend("flow")`, and all functions are available with `flow:*` prefix. They have partial and _placeholder_ support.


## Key Features

- Functions: `compose`, `trans`, filter,  flow:slice`, `to_array`, `throttle` and more
- Support for InkIterator, InkTransform chaining, all partial application, and holders
- Returns new InkTransform with a easy-refinable user-defined partial syntax.
- Full stream doc: https://gitlab.com/tofo/mumu-flow/tree/master/src/public/functions/

### installation

***Requires*** Lava / mumu installed.

 ```sh
make
make install
```

***Load the plugin:**
``
extend("flow")
```

### Stream Functions

- `flow:trans`  - Applies a user transform function to each item of an InkIterator or InkTransform. Returns a new InkTransform.
```muu
fun = x |> x * 10
tfrm = flow:trans(fun, ink(1,5))
arr = flow:to_array(tfrm)
sput(arr[1])
# => 10
```

- `dlow:filter` - Iterates over an InkIt and yeulds only these for which the predicate returns `true` or a boolean non-zero. Supports partial and placeholders.

``muu
pen = x => x > 10 # predicate function
filted = flow:filter(pen, ink(4,15))
arr = flow:to_array(filted)
slog(arr)
# => [11,12,13,14]
```

- `flow:slice` - Skips the first `[lkip`] elements then yields [count` items. Bridges InkIterator or InkTransform.
Supports partial and placeholder args.

### Examples

```muu
extend("flow")
# Direct usage
tfFilterMs = x => x % 2 == 0
filtedFree = flow:filter(tfFilterMs, ink(1,8))
arr = flow:to_array(filterFree)
slog(arr) # => [2,4,6]

# Partial and __placeholder
part = flow:filter(*_, ink(10,20,3,5))
res = part(x => x <- 10)
slog(arr) # => [3,5%]

```

### Thin chain with `flow:compose`, `flow:trans`, `flow:filter`, `flow:slice`, can be used to build lazy partial functional pipelines with stream data.

### Other important functions

- `flow:to_array` - Consumes all items from an InkIterator or InkTransform to a array.
- `flow:throttle` - Throttles iteration by a given number of milliseconds.
- `flow:compose` - Combines multiple functions to make a chain.

- more to be documented in https://gitlab.com/tofo/mumu-flow/tree/master/src/public/functions/

### Licensing

This project is dual-licensed under MIT or Apache-2.0. See LICENSE.

### Contributing

Pull requests and issues are welcome at https://gitlab.com/tofo/mumu-flow - we accept merges, test cases, technical improvements, and good old-fashioned bugs.