macro librarywork/xetal-ml/libs/Flow/src/Flow.xtlm

The value of a pipeline: the data, then each stage in turn, |> between them. A stage is a function (act:r_elu, [f_ g_], '{ x -> ... }), applied to the previous value, or an expression naming the previous value it (W nn:d_ense it; the order is written, never guessed). "$name" at a stage's end names its value for the later stages, the $ touching the name ("$(Q, K, V)" takes a tuple apart, as X_eTaL's S14 label is written and drawn); " [N O]" after the name is the shape the value must have, checked when the program runs (error[shape], naming the stage, its shape and the one expected). The left side is @; the right is a code string c"...", drawn as X_eTaL (|> and $ as triangles), and may put one stage per line; a plain or raw string reads the same.

      "flow:" u̲se< "Flow"

      x ← f̲loat 1 2 3 4

      @ ᶠˡᵒʷp̲ipe< c"x ▹s ▷ 2 × it ▷ it + s"
3.0 6.0 9.0 12.0

The pipeline written back from its reading, a string: the stages trimmed, " |> " between them, each name and shape as written. What the macro read is what was written, or the call was refused.

      "flow:" u̲se< "Flow"

      @ ᶠˡᵒʷt̲ext< c"x   ▹s ▷  2 × it   ▷ it + s"
x $s |> 2 * it |> it + s

The pipeline drawn as math, a LaTeX string: an aligned display of a row per stage, the data first, each later stage after an arrow, each label after its stage as X_eTaL draws $ (a triangle, the name, its shape); an equation stage ("H[i,k] | n d" e:e_q< "...") as Equations draws it (its e:t_ex<, the same strings), any other stage as code. The call is read as flow:p_ipe< reads it, or refused; KaTeX or LaTeX draws the result.

      "flow:" u̲se< "Flow"

      @ ᶠˡᵒʷm̲ath< c"x ▹s ▷ 2 × it ▷ it + s"
\begin{aligned} & x \qquad \triangleright \, s \\ \longrightarrow \; & \texttt{2 * it} \\ \longrightarrow \; & \texttt{it + s} \end{aligned}

Every stage's value, as one line of text: a record per value, " | " between them, each its stage's number, its label ("" for none), its shape, its smallest and largest item and its first 64 items, ";" between the fields; a tuple's parts a record each. For pages that show what each stage gives; the values are those flow:p_ipe< gives.

      "flow:" u̲se< "Flow"

      x ← f̲loat 1 2 3

      @ ᶠˡᵒʷs̲tages< c"x ▷ 2 × it ▹y"
1;;3;1.0;3.0;1.0 2.0 3.0 | 2;y;3;2.0;6.0;2.0 4.0 6.0

The stages of text as (expressions, names, shapes), each a boxed text per stage ("" for no name or no shape), every rule checked.

A stage's expression: its text before its label's $, trimmed.

What follows a stage's $, trimmed ("" for no label).

A stage's name (or tuple of names): the text after $ up to its shape's [, trimmed; "" for none.

A stage's shape as written, "[N O]", from its first [ on; "" for none.

Where the first $ outside brackets and strings is in s, or 0.

A stage's $ touches the name or tuple it gives ($m, $(Q, K)), as X_eTaL's own label does: $ m, or a $ with nothing after it, is refused ("" when the stage has no label or its $ touches).

A stage after the first is a function, or an expression naming the previous value it or a name bound before it (earlier, boxed); a stage that calls a macro (an equation, "Y[i] | n" e:e_q< "2 * it[i]") names them in its strings too. Else the call is refused with the text ("" when it is one of these).

Whether e names the previous value: the word it, outside strings, or in the strings of a macro call.

Whether e uses the name w: outside strings; in a macro call's strings too (the names an equation reads, x[i,j]).

Whether e calls a macro: a word ending in < outside strings (e:e_q<).

Whether the word w (a name) occurs whole in e: outside strings, or anywhere when inStrings holds.

Whether e is written as a function: a quoted function or lambda ('n_eg, '+ r_/, '{ x -> ... }), a train ([f_ g_]), or one function name (act:r_elu, t_ally: no blanks, an underline).

A name after $ is a plain name (letters and digits, a letter first) or a tuple of two or more, (Q, K, V); never it; else refused ("" when it is).

The names a binder binds, boxed: the name itself, or a tuple's parts.

Every name the stages bind, boxed, in order.

Whether b is a plain name: a letter, then letters or digits.

The shapes against their names, each stage: a shape needs a single name before it, is [extents] whole (names or numbers, blanks between) and nothing follows it; else refused with the text ("" each).

The expansion: a block binding each stage's value, one line per stage (a fresh name from []G_ENSYM, or the name given), the shape checks after their stages, and the last value as the result.

Stage i's line: the data as written; an expression naming it in a block of its own (it := the previous value); a function applied to the previous value; an expression of earlier names as written; then its shape check, if any.

A function stage as applied to a value: a quoted lambda or quoted name loses its quote ('{ x -> ... } and 'n_eg are the function passed, { x -> ... } v and n_eg v the call); a derived function ('+ r_/), a train and a name stay as written.

The check of stage i's shape sh, "" when it has none.

The run-time check of a stage's shape: nothing when it matches, else error[shape] naming the stage, its shape and the one expected (the extents are the caller's values when the program runs).

The display: the rows joined, inside \begin{aligned} ... \end{aligned}, as an expression of strings (an equation's row is its library's t_ex< call, expanded in turn).

Row i: an arrow before every stage but the data, the stage drawn, its label after it as X_eTaL draws $ (a small triangle, the name and its shape), a line break after every row but the last.

What comes before row i: the column for the data, an arrow then the column for each later stage.

What ends row i of n: a line break, but for the last.

A stage's label drawn after it: the triangle, the name, the extents of its shape (n \\times 16); "" when it has no name.

Stage i as drawn: in an equation, it, the previous value, under the name it came with when it has one (the previous stage's label, or the data when the data is a name), so it reads X[i,j], not it[i,j]; code as written.

The name stage i's value goes by: its label, or the data itself when it is a plain name; "" for none (a tuple label is no one name).

The i-th character of s, a blank before its start and past its end.

e with each whole word it written as name (e as it is for "").

A stage drawn, as an expression of a string: an equation by its library's t_ex< on the same strings (e:e_q< becomes e:t_ex<); a plain name as itself; anything else as code.

Code as LaTeX's typewriter text, its special characters escaped.

One character of code as LaTeX text.

s as a raw string literal, r#"s"#: a backslash stays a backslash.

The expansion as flow:p_ipe< writes it, the last line the records of every stage's value instead of the last value.

The records of stage i's value (the name it is bound to): one, or one per part of a tuple label, as code giving text.

One value's record, as code giving text.

The pipeline as read, one line: the stages with " |> " between, " $name" and " [shape]" where given.

pre and x, or "" when x is empty.

s as the inside of a string literal: a quote becomes \".

Nothing when ok holds; else the call is refused with message, at its text (the right side).

Characters of names: of values (Q, m1), of functions (act:r_elu, n_ame?, p_rint!), and digits.

Characters of plain names and numbers.

1 at each character of s inside a string literal (its quotes included).

The positions in s where sep starts outside brackets, braces, parentheses and strings.

s cut where sep starts outside brackets and strings: the pieces between, boxed (one piece when it never does).

The first of the boxed texts b ("" for none).

The first of the positions ps, or 0 for none.

Where the first ch is in s, or 0.