Libraries
what a library is, and the standard libraries at work

Table of Contents

A library is an ordinary X_eTaL file whose exported names are written with l:; its helpers, written with h:, are private to it. A program imports a library with the u_se< macro, choosing the prefix its names get: "s:" u_se< "Stats" makes the library's l:m_ean the program's s:m_ean. The prefix is required, so every name says where it comes from. Four libraries are built into xetal (their source is in lib/); a library of your own is imported by its path. Every block below is run by xetal through ob-xetal, and its result recorded under it.

Stats

A small statistics library. Its whole source:

⍝│ Stats: a small statistics library (a standard library, built into
⍝│ xetal). Import it with an alias of your choice: "s:" u_se< "Stats".
⍝│ It is a demo library, loaded only by that import: a small subset of
⍝│ X_eTaL-libraries' Statistics, which has much more (a program may use
⍝│ either).
⍝│ Names with l: are exported; names with h: are private to this file.

⍝━━ Center

⍝│ The arithmetic mean, of Int or Float numbers.
⍝│ >> "s:" u_se< "Stats"
⍝│ >> s:m_ean 2 4 4 4 5 5 7 9
⍝│ 5.0
ˡm̲ean ← [[f̲loat '+ r̲/] ÷ [f̲loat t̲ally]]

⍝│ Each number times itself.
ʰs̲quare ← { ⍵ × ⍵ }                       ⍝ private: not visible outside
⍝│ How far each number is from the mean, as Floats.
ʰd̲eviations ← [f̲loat − ˡm̲ean]

⍝━━ Spread

⍝│ The variance: the mean squared deviation from the mean.
⍝│ >> "s:" u_se< "Stats"
⍝│ >> s:v_ariance 2 4 4 4 5 5 7 9
⍝│ 4.0
ˡv̲ariance ← [ˡm̲ean [ʰs̲quare ʰd̲eviations]]

⍝│ The standard deviation: the square root of the variance.
⍝│ >> "s:" u_se< "Stats"
⍝│ >> s:s_d 2 4 4 4 5 5 7 9
⍝│ 2.0
ˡs̲d ← { (ˡv̲ariance ⍵) ^ 0.5 }

⍝│ The range: the largest minus the smallest.
⍝│ >> "s:" u_se< "Stats"
⍝│ >> s:s_pread 2 4 4 4 5 5 7 9
⍝│ 7
ˡs̲pread ← ['m̲ax r̲/ − 'm̲in r̲/]

⍝ typed:
⍝   l:m_ean := [[f_loat '+ r_/] / [f_loat t_ally]]
⍝   h:s_quare := { _r * _r }                  # private: not visible outside
⍝   h:d_eviations := [f_loat - l:m_ean]
⍝   l:v_ariance := [l:m_ean [h:s_quare h:d_eviations]]
⍝   l:s_d := { (l:v_ariance _r) ^ 0.5 }
⍝   l:s_pread := ['m_ax r_/ - 'm_in r_/]

h:s_quare and h:d_eviations are helpers, written with h:, so a program cannot see them; the rest it imports:

"s:" u̲se< "Stats"
ˢm̲ean 1 2 3 4

⍝ typed:
⍝   "s:" u_se< "Stats"
⍝   s:m_ean 1 2 3 4
2.5

The mean is a Float for Int numbers too. The variance, the standard deviation and the range:

ˢv̲ariance 2 4 4 4 5 5 7 9
ˢs̲d 2 4 4 4 5 5 7 9
ˢs̲pread 3 9 1 7

⍝ typed:
⍝   s:v_ariance 2 4 4 4 5 5 7 9
⍝   s:s_d 2 4 4 4 5 5 7 9
⍝   s:s_pread 3 9 1 7
4.0
2.0
8

Maybe

A value that may be missing, and the monad that chains computations which can fail. A maybe is Church-encoded: a function of two arguments, what to give when it is empty and what to do with its value. j_ust x holds a value, n_othing holds none, and d m:o_r m is the value, or d when there is none:

"m:" u̲se< "Maybe"
ᵘd̲iv ← { a b → b = 0 ? 'ᵐn̲othing◆ ᵐj̲ust a ÷ b }
-1 ᵐo̲r 100 ᵘd̲iv 4
-1 ᵐo̲r 100 ᵘd̲iv 0

⍝ typed:
⍝   "m:" u_se< "Maybe"
⍝   u:d_iv := { a b -> b = 0 ? 'm:n_othing; m:j_ust a / b }
⍝   -1 m:o_r 100 u:d_iv 4
⍝   -1 m:o_r 100 u:d_iv 0
25.0
-1.0

b_ind chains a step that can itself fail; the first failure gives the default, and the steps after it never run:

ᵘh̲alf ← { ᵐj̲ust ⍵ ÷ 2 }
-1 ᵐo̲r 'ᵘh̲alf ᵐb̲ind 100 ᵘd̲iv 4
-1 ᵐo̲r 'ᵘh̲alf ᵐb̲ind 100 ᵘd̲iv 0

⍝ typed:
⍝   u:h_alf := { m:j_ust _r / 2 }
⍝   -1 m:o_r 'u:h_alf m:b_ind 100 u:d_iv 4
⍝   -1 m:o_r 'u:h_alf m:b_ind 100 u:d_iv 0
12.5
-1.0

Combinators

Every bird Raymond Smullyan names in To Mock a Mockingbird that type-checks, under its letter. K keeps its first argument, C swaps the arguments of a function, and B composes (here negate after reverse):

"c:" u̲se< "Combinators"
1 ᶜK̲ 2
10 '− ᶜC̲ 3
'n̲eg 'r̲ev ᶜB̲ 1 2 3

⍝ typed:
⍝   "c:" u_se< "Combinators"
⍝   1 c:K_ 2
⍝   10 '- c:C_ 3
⍝   'n_eg 'r_ev c:B_ 1 2 3
1
-7
-3 -2 -1

The aviary meets them all.

Turtle

Turtle graphics as arrays: a walk is a vector of turns in degrees, one before each step, and its points are running sums of cosines and sines, two rows (x over y) that []P_ATH draws. Its whole source:

⍝│ Turtle: turtle graphics as arrays (a standard library, built into
⍝│ xetal). Import it with an alias of your choice: "t:" u_se< "Turtle".
⍝│ A walk is a vector of turns in degrees, one before each step forward;
⍝│ the turtle starts at the origin facing east (0 degrees, counting
⍝│ anticlockwise). No turtle moves: the headings are a running sum of
⍝│ the turns, the steps are their cosines and sines, and the positions
⍝│ are running sums of the steps. Draw the points with []P_ATH.
⍝│ Names with l: are exported; names with h: are private to this file.

⍝│ Degrees as radians, a Float.
ʰr̲adians ← { (f̲loat ⍵) × (p̲i @) ÷ 180 }         ⍝ private

⍝━━ Points of a walk

⍝│ The points of a walk with steps of the given lengths, 2 rows (x over
⍝│ y), starting at the origin: lengths ᵗw̲alk turns; a single length
⍝│ serves every step. A walk of n turns gives n + 1 points.
⍝│ >> "t:" u_se< "Turtle"
⍝│ >> f_loor 0.5 + 2 t:w_alk 0 90 90
⍝│ 0 2 2 0
⍝│ 0 0 2 2
ˡw̲alk ← { lengths turns →
  h ← ʰr̲adians '+ s̲\ turns
  xs ← 0 c̲at '+ s̲\ (f̲loat lengths) × c̲os h
  ys ← 0 c̲at '+ s̲\ (f̲loat lengths) × s̲in h
  (2 c̲at t̲ally xs) r̲eshape xs c̲at ys
}

⍝│ The points of a walk of unit steps: ᵗp̲oints turns.
⍝│ >> "t:" u_se< "Turtle"
⍝│ >> f_loor 0.5 + t:p_oints t:p_olygon 4
⍝│ 0 0 -1 -1 0
⍝│ 0 1  1  0 0
ˡp̲oints ← { turns → 1 ˡw̲alk turns }

⍝━━ Building walks

⍝│ The walk w with t degrees more turned before its first step: how
⍝│ pieces of a curve are joined (60 ᵗt̲urn w).
⍝│ >> "t:" u_se< "Turtle"
⍝│ >> 60 t:t_urn 0 120 120
⍝│ 60 120 120
ˡt̲urn ← { t w → (t + 1 t̲ake w) c̲at 1 d̲rop w }

⍝│ A regular polygon of n sides, as a walk: n turns of 360 / n degrees,
⍝│ so it closes where it began.
⍝│ >> "t:" u_se< "Turtle"
⍝│ >> t:p_olygon 4
⍝│ 90.0 90.0 90.0 90.0
ˡp̲olygon ← { n → n r̲eshape 360 ÷ n }

⍝ typed:
⍝   h:r_adians := { (f_loat _r) * (p_i @) / 180 }   # private
⍝   l:w_alk := { lengths turns ->
⍝     h := h:r_adians '+ s_\ turns
⍝     xs := 0 c_at '+ s_\ (f_loat lengths) * c_os h
⍝     ys := 0 c_at '+ s_\ (f_loat lengths) * s_in h
⍝     (2 c_at t_ally xs) r_eshape xs c_at ys
⍝   }
⍝   l:p_oints := { turns -> 1 l:w_alk turns }
⍝   l:t_urn := { t w -> (t + 1 t_ake w) c_at 1 d_rop w }
⍝   l:p_olygon := { n -> n r_eshape 360 / n }

A square, one unit a side, its points rounded (the cosine of a right angle is only nearly 0):

"t:" u̲se< "Turtle"
ᵗp̲olygon 4
f̲loor 0.5 + ᵗp̲oints ᵗp̲olygon 4

⍝ typed:
⍝   "t:" u_se< "Turtle"
⍝   t:p_olygon 4
⍝   f_loor 0.5 + t:p_oints t:p_olygon 4
90.0 90.0 90.0 90.0
0 0 -1 -1 0
0 1  1  0 0

Classic programs, drawn uses it for Koch's snowflake and Sierpinski's arrowhead.

TTTML

A machine that learns tic-tac-toe by playing itself: its model is an ordinary value, passed to the library's functions and returned by them. TTTML trains it and plays it.

A library of your own

Hello, library writes one and uses it. In short: write the exported names with l: and save the file; a program then imports it by name from beside it, or by its path, "g:" u_se< "lib/Geometry.xtl". In the live demo, Save as a name like Geometry.xtl keeps it in the browser, and "g:" u_se< "Geometry" imports it; saved under a standard library's name (Stats.xtl), your copy is the one imported. A library cannot define u: names, and a program cannot define l: names.

Literate documents · Live demo · Repository