X_eTaL documentation

Files

program demos/lora-hello/lora-hello.xtl: LoRA hello: what does a small adapter add to a layer whose weights do not change? The question behind it: how can a model learn something new without every one of its numbers being retrained (the cost) or overwritten (the forgetting)? LoRA's answer is to freeze the weights and train a small correction beside them. Here is one layer of that, shrunk to 4 rows and 4 columns so every number can be read: a frozen table W and an adapter of rank 1, with X_eTaL-ML's LoRA library. Nothing is trained here (the adapter's numbers are made up): this shows what an adapter is, where it sits, what it adds and what it costs. The layer is y = W x + s B (A x): W stays as it is, and only A (1 row of 4) and B (1 column of 4) would be trained.
library work/xetal-ml/libs/LoRA/src/LoRA.xtl: LoRA: low-rank adapters: the adapted forward pass in factored form, the merge, the counts, the gradients and steps, LoRA-FA
library work/xetal-ml/libs/Optim/src/Optim.xtl: Optim: optimizers as steps: gradient descent and Adam on a weight array and its averages
program demos/lora-lab/lora-lab.xtl: LoRA lab: how an adapter's correction is worked out, number by number, and what its rank changes. A frozen table W of 8 rows and 8 columns, and an adapter of rank r beside it: A (r rows of 8) and B (8 rows of r). The layer is y = W x + s B (A x), written here as a pipeline of four stages so that every stage's numbers can be shown: the input x; the squeeze h = A x (r numbers); the spread u = B h (8 numbers); and the output y = W x + s u. The layer is the one of X_eTaL-ML's LoRA explorer (its W, A, B and x, made up by fixed ripples). Nothing is trained here.
library work/xetal-libraries/libs/Equations/src/Equations.xtl: Equations: sums as printed in papers, written in one macro call (e:e_q<, e:t_ex<, e:b_oth< in Equations.xtlm); here the valid 2-D cross-correlation of a CNN layer, as array code, which checks the macro. Import it with an alias of your choice: "e:" u_se< "Equations". Put libs/Equations/src on XETAL_PATH ("just path"); the reference is libs/Equations/docs. Names with l: are exported; those under h: are private to this file.
macro library work/xetal-libraries/libs/Equations/src/Equations.xtlm: Equations: its macro library -- e_q<, t_ex< and b_oth<: an equation as printed in a paper, to its value, its LaTeX, or both. Imported with the functions, under one alias: "e:" u_se< "Equations". A macro is a function from the source text written left and right of its call to the source that replaces the call, run before the program is compiled (X_eTaL MC10). Names with m: are macros; those under h: are private to this file.
macro library work/xetal-ml/libs/Flow/src/Flow.xtlm: Flow: ML data flow written left to right, |> between stages -- each stage becomes one line of X_eTaL
program demos/lora-training/lora-training.xtl: LoRA training: where the numbers of A and B come from. A frozen 8 x 8 layer W; examples (inputs with the outputs wanted) made by a hidden shift of it, W + T; an adapter that starts as LoRA does, B at 0 and A seeded. One step of training as a pipeline, stage by stage: the prediction, the error (which is the loss's gradient at the output), the gradients of A and B, the update; checked against the library's own step, W untouched. Then training by Adam with a record: the loss on the examples trained on and on examples held out, every few steps, and the adapter at each record, so a page can step back without training again.
library work/xetal-libraries/libs/Plot/src/Plot.xtl: Plot: text charts -- bars, sparklines, histograms, scatter plots on a character grid -- and line charts as pictures, with axes, labels and several lines in one chart. Import it with an alias of your choice: "p:" u_se< "Plot". Put libs/Plot/src on XETAL_PATH ("just path"); the reference is libs/Plot/docs. Names with l: are exported; those under h: are private to this file.
library work/xetal-libraries/libs/Strings/src/Strings.xtl: Strings: text functions -- case, trimming, words, split and join, search, replace, padding. Import it with an alias of your choice: "t:" u_se< "Strings". Put libs/Strings/src on XETAL_PATH ("just path"); the reference is libs/Strings/docs. Names with l: are exported; those under h: are private to this file.
library work/xetal-libraries/libs/Format/src/Format.xtl: Format: number formatting -- fixed decimals, thousands separators, percentages, aligned columns, text tables. Import it with an alias of your choice: "f:" u_se< "Format". Put libs/Format/src on XETAL_PATH ("just path"); the reference is libs/Format/docs. Names with l: are exported; those under h: are private to this file.
library work/xetal-libraries/libs/Lists/src/Lists.xtl: Lists: list functions -- differences, windows, moving means, run lengths, chunks, shifts, interleaving, binary search, raze. Import it with an alias of your choice: "li:" u_se< "Lists". Put libs/Lists/src on XETAL_PATH ("just path"); the reference is libs/Lists/docs. Names with l: are exported; those under h: are private to this file.
library std/Svg.xtl: Svg: pictures as SVG text, written for you (a standard library, built into xetal). Import it with an alias of your choice: "v:" u_se< "Svg". An element is its SVG text; a picture is elements joined with c_at inside v:p_icture, which []S_HOW shows and the command line writes. Points are a 2-row matrix, x over y, as []P_ATH and Geometry3D's g:p_roject give them; y grows downward, as SVG's does. Attributes are text made by v:a_ttr, v:f_ill, v:s_troke and the transforms, so no program writes a quote mark or an angle bracket of its own. Names with l: are exported; names with h: are private to this file.
system macros std/System.xtlm: The system macros (lang-choices MC18, MC19, MC24), loaded before every file with no import and no alias: each is called unprefixed, as "c" i_f< "a; b". A macro is a function of the source text on each side of its call; the text it gives replaces the call. @ on a side means the macro takes nothing there (MC22). What only the compiler knows comes from hooks (MC20), usable only in a macro body.
program demos/rank-and-scaling/rank-and-scaling.xtl: Rank and scaling: the adapter's rank swept from 1 to 8 on the learning task of lesson 3 (a frozen 8 x 8 layer, examples from a hidden shift of it, 8 trained on and 4 held out), under two rules for the strength s: LoRA's alpha / r (lo:s_caling) and rsLoRA's alpha / sqrt r (lo:s_calingRs). For each rank and rule, after the same number of Adam steps from the same kind of start: the numbers trained (analytical), the strength (analytical), the loss per example on the examples trained on and on the held-out ones (measured), and the size of the adapter's table s B A (measured: the square root of the sum of its squares).
program demos/welcome/welcome.xtl: Welcome: one small calculation on which a newcomer is shown how these lessons work (the page steps through it, pictures it, writes one of its sums out). It is the layer of the first lesson, LoRA hello: a frozen table W of 4 rows and 4 columns with an adapter of rank 1, written this time as a pipeline: the input x, then the squeeze h = A x, then the spread u = B h, then the output y = W x + s u. X_eTaL-ML's Flow runs the pipeline and can report every stage's value, which is what a page steps through.

Items

name	kind	type
W	value	`Float`
A	value	`Float`
B	value	`Float`
x	value	`Float`
s	value	`Float`
h	value	`Float`
base	value	`Float`
y	value	`Float`
correction	value	`Float`
table	value	`Float`
merged	value	`Float`
counts	value	`Int`
big	value	`Int`
ˡs̲caling	function	`Num a => Float -> a -> Float`
ˡs̲calingRs	function	`Num a => Float -> a -> Float`
ˡf̲orward	function	`Num a => (a, a, a, a) -> a -> a`
ˡd̲elta	function	`Num a => (a, a, a) -> a`
ˡm̲erge	function	`Num a => (a, a, a, a) -> a`
ˡl̲oss	function	`(Float, Float, Float, Float) -> (Float, Float) -> Float`
ˡg̲rads	function	`Num a => (a, a, a, a) -> (a, a) -> (a, a, a)`
ˡs̲gd	function	`Num a => a -> ((a, a, a, a), (a, a)) -> (a, a, a, a)`
ˡa̲damStart	function	`(Any a, Any b, Num c) => (a, Float, Float, b) -> ((a, Float, Float, b), (Float, Float, Float, Float), c)`
ˡa̲dam	function	`Float -> (((Float, Float, Float, Float), (Float, Float, Float, Float), Float), (Float, Float)) -> ((Float, Float, Float, Float), (Float, Float, Float, Float), Float)`
ˡs̲eeded	function	`Num a => a -> Int -> Float`
ˡg̲radsFA	function	`Num a => (a, a, a, a) -> (a, a) -> (a, a)`
ˡs̲gdFA	function	`Num a => a -> ((a, a, a, a), (a, a)) -> (a, a, a, a)`
ˡa̲damStartFA	function	`(Any a, Any b, Any c, Num d) => (a, b, Float, c) -> ((a, b, Float, c), (Float, Float), d)`
ˡa̲damFA	function	`Float -> (((Float, Float, Float, Float), (Float, Float), Float), (Float, Float)) -> ((Float, Float, Float, Float), (Float, Float), Float)`
ʰs̲tep	function	`Num a => Float -> (Float, Int, a) -> (Float, Int, a)`
ˡr̲ank	function	`Num a => Float -> a`
ˡp̲arams	function	`Num a => a -> a -> a`
ˡe̲xpert	function	`Num a => a -> a -> a`
ˡe̲xpertFA	function	`Num a => a -> a -> a`
ˡb̲ytes	function	`Num a => a -> a -> Float`
ˡc̲osts	function	`Num a => a -> a -> a`
ˡs̲gd	function	`Num a => a -> (a, a) -> a`
ˡa̲damWith	function	`(Float, Float, Float, Float) -> (Float, Float, Float, Float) -> (Float, Float, Float)`
ˡa̲dam	function	`(Float, Float) -> (Float, Float, Float, Float) -> (Float, Float, Float)`
r	value	`Int`
alpha	value	`Float`
s	value	`Float`
c	value	`Float`
W	value	`Float`
d	value	`Float`
A	value	`Float`
B	value	`Float`
X	value	`Float`
q	value	`Int`
y	value	`Float`
base	value	`Float`
correction	value	`Float`
ˡc̲orrelate	function	`Num a => a -> a -> a`
ᵐe̲q<	macro	`Char -> Char -> Char`
ᵐt̲ex<	macro	`Char -> Char -> Char`
ᵐt̲exSymbols<	macro	`Char -> Char -> Char`
ᵐb̲oth<	macro	`Char -> Char -> Char`
ᵐc̲onvolve<	macro	`Char -> Char -> Char`
ᵐc̲orrelate<	macro	`Char -> Char -> Char`
ᵐc̲onvolveTex<	macro	`Char -> Char -> Char`
ᵐc̲orrelateTex<	macro	`Char -> Char -> Char`
modes	value	`Box Char`
ʰs̲lide	function	`Char -> (Char, Char) -> Char`
ʰs̲lideTex	function	`Char -> (Char, Char) -> Char`
ʰp̲lus	function	`Char -> Char`
ʰs̲lideLeft	function	`Char -> (Char, Char, Char)`
ʰs̲lideRight	function	`Char -> (Char, Char)`
ʰo̲therIndex	function	`Char -> (Char, Char, Char) -> Char`
ʰf̲ree	function	`Char -> (Box Char, Box Char)`
ʰc̲hecked	function	`Char -> Char`
ʰw̲hole	function	`Char -> Char`
nameChars	value	`Char`
alphabet	value	`Char`
words	value	`Box Char`
functions	value	`Box Char`
rules	value	`Box Char`
defaultBy	value	`Char`
infinities	value	`Box Char`
ʰp̲ickText	function	`Truthy a => a -> (Char, Char) -> Char`
ʰp̲ickCount	function	`Truthy a => a -> (Int, Int) -> Int`
ʰk̲ind	function	`Char -> Char`
ʰf̲n?	function	`Truthy a => Char -> a`
ʰf̲nParts	function	`Char -> (Char, Box Char)`
ʰs̲umParts	function	`Char -> (Box Char, Box Char, Box Char, Box Char, Box Char, Char)`
ʰb̲inding	function	`Char -> (Char, Char, Char, Char, Char)`
ʰi̲nfinite?	function	`(Num a, Truthy a) => Char -> a`
ʰo̲ptionsOk	function	`(Truthy a, Truthy b) => (a, Int, Char) -> b`
ʰo̲ption?	function	`Truthy a => Char -> a`
ʰr̲uleSteps	function	`Char -> (Char, Int)`
ʰu̲pTo	function	`Int -> Char -> Char`
ʰp̲ast	function	`(Int, Int) -> Char -> Char`
ʰb̲oxed	function	`(Char, Char, Char, Char, Char) -> Box Char`
ʰa̲tom	function	`Char -> Char`
ʰv̲alue	function	`(Box Char, Box Char) -> Char -> Char`
ʰg̲ridLines	function	`(Char, Char, Box Char) -> Char`
ʰv̲alueOf	function	`(Box Char, Box Char, Box Char, Char, (Char, Char, Char)) -> Char -> Char`
ʰv̲alueChain	function	`(Box Char, Box Char, Box Char, Char, (Char, Char, Char)) -> (Char, Char) -> Char`
ʰv̲alueFold	function	`(Box Char, Box Char, Box Char, Char, (Char, Char, Char)) -> (Char, Char, Box Char) -> Char`
ʰv̲aluePow	function	`(Box Char, Box Char, Box Char, Char, (Char, Char, Char)) -> Char -> Char`
ʰv̲alueSum	function	`(Box Char, Box Char, Box Char, Char, (Char, Char, Char)) -> Char -> Char`
ʰw̲ordLen	function	`Char -> Int`
ʰr̲enamed	function	`(Char, Char) -> Char -> Char`
ʰh̲asPrev?	function	`Truthy a => Char -> a`
ʰv̲alueScan	function	`((Box Char, Box Char, Box Char, Char, (Char, Char, Char)), Char, Char, Char, Char, Char) -> Char`
ʰq̲uadrature	function	`Box Char -> (Char, Char, Char, Char) -> Box Char`
ʰw̲eights	function	`Char -> Int -> Char`
ʰw̲eighted	function	`(Char, Char, Int) -> Char`
ʰr̲educer	function	`Char -> Char`
ʰb̲ound	function	`Box Char -> Char -> Char`
ʰs̲paced	function	`Char -> Char`
ʰv̲alueFn	function	`(Box Char, Box Char, Box Char, Char, (Char, Char, Char)) -> Char -> Char`
ʰv̲alueRef	function	`(Box Char, Box Char, Box Char, Char, (Char, Char, Char)) -> Char -> Char`
ʰh̲orner	function	`(Box Char, Box Char, Box Char, Char, (Char, Char, Char)) -> (Char, Box Char, Int) -> Char`
ʰv̲alueAtom	function	`(Box Char, Box Char, Box Char, Char, (Char, Char, Char)) -> Char -> Char`
ʰc̲hecks	function	`(Char, Char) -> Char`
ʰt̲ex	function	`Num a => a -> Char -> Char -> Char`
ʰm̲ark	function	`Num a => (a, Box Char) -> Char -> Char -> Char`
ʰt̲exBody	function	`Num a => (a, Box Char) -> Char -> Char`
ʰt̲exOf	function	`Num a => (a, Box Char) -> Char -> Char`
ʰt̲exAtom	function	`Num a => (a, Box Char) -> Char -> Char`
ʰt̲exChain	function	`Num a => (a, Box Char) -> Char -> Char -> Char`
ʰt̲exFold	function	`Num a => (a, Box Char) -> (Char, Char, Box Char) -> Char`
ʰt̲exBare	function	`Num a => (a, Box Char) -> Char -> Char`
ʰt̲exJoin	function	`(Char, Char, Char) -> Char`
ʰt̲exPow	function	`Num a => (a, Box Char) -> Char -> Char`
ʰt̲exSum	function	`Num a => (a, Box Char) -> (Char, Char) -> Char -> Char`
ʰt̲exIndex	function	`(Char, Char) -> Char`
ʰg̲reek	function	`Char -> Char`
greek	value	`Char`
ʰs̲ymbol	function	`Char -> Char`
ʰt̲exFn	function	`Num a => (a, Box Char) -> Char -> Char`
ʰt̲exRef	function	`Num a => (a, Box Char) -> Char -> Char`
ʰs̲ubscript	function	`Char -> Char`
ʰp̲lain	function	`Char -> Char`
ʰp̲lainChain	function	`Char -> Char -> Char`
ʰp̲lainFold	function	`(Char, Char, Box Char) -> Char`
ʰp̲lainPow	function	`Char -> Char`
ʰp̲lainSum	function	`Char -> Char`
ʰp̲lainBy	function	`Char -> Char`
ʰp̲lainFn	function	`Char -> Char`
ʰp̲lainRef	function	`Char -> Char`
ʰj̲oinWith	function	`Char -> Box Char -> Char`
ᵐp̲ipe<	macro	`Unit -> Char -> Char`
ᵐt̲ext<	macro	`Unit -> Char -> Char`
ᵐm̲ath<	macro	`Unit -> Char -> Char`
ᵐs̲tages<	macro	`Unit -> Char -> Char`
ʰr̲ead	function	`Char -> (Box Char, Box Char, Box Char)`
ʰe̲xpr	function	`Char -> Char`
ʰa̲fter	function	`Char -> Char`
ʰb̲inder	function	`Char -> Char`
ʰs̲hapeOf	function	`Char -> Char`
ʰl̲abel	function	`Char -> Int`
ʰt̲ouches?	function	`Char -> Char`
ʰs̲tage?	function	`Box Char -> Char -> Char`
ʰi̲t?	function	`Truthy a => Char -> a`
ʰu̲ses?	function	`Truthy a => Char -> Char -> a`
ʰm̲acro?	function	`Truthy a => Char -> a`
ʰw̲ord?	function	`(Truthy a, Truthy b) => (Char, a) -> Char -> b`
ʰf̲unction?	function	`Truthy a => Char -> a`
ʰb̲inder?	function	`Char -> Char`
ʰp̲arts	function	`Char -> Box Char`
ʰf̲latten	function	`Box Char -> Box Char`
ʰn̲ame?	function	`Truthy a => Char -> a`
ʰs̲hapes?	function	`(Box Char, Box Char) -> Int -> Box Char`
ʰw̲rite	function	`(Box Char, Box Char, Box Char) -> Char`
ʰl̲ine	function	`(Box Char, Box Char, Box Char) -> Int -> Char`
ʰa̲pplied	function	`Char -> Char`
ʰc̲heckOf	function	`(Int, Char) -> Char -> Char`
ʰc̲heck	function	`(Int, Char) -> Char -> Char`
ʰd̲raw	function	`(Box Char, Box Char, Box Char) -> Char`
ʰr̲ow	function	`(Box Char, Box Char, Box Char) -> Int -> Char`
ʰi̲nto	function	`Int -> Char`
ʰb̲reak	function	`Int -> Int -> Char`
ʰn̲amed	function	`(Char, Char) -> Char`
ʰs̲hown	function	`(Box Char, Box Char) -> Int -> Char`
ʰi̲ncoming	function	`(Box Char, Box Char) -> Int -> Char`
ʰc̲hr	function	`Char -> Int -> Char`
ʰa̲s	function	`Char -> Char -> Char`
ʰd̲rawn	function	`Char -> Char`
ʰt̲t	function	`Char -> Char`
ʰl̲atexChar	function	`Char -> Char`
ʰr̲aw	function	`Char -> Char`
ʰt̲race	function	`(Box Char, Box Char, Box Char) -> Char`
ʰr̲ecords	function	`(Int, Char, Char) -> Char`
ʰr̲ecord	function	`(Int, Char) -> Char -> Char`
ʰs̲how	function	`(Box Char, Box Char, Box Char) -> Char`
ʰo̲pt	function	`Char -> Char -> Char`
ʰe̲scape	function	`Char -> Char`
ʰr̲equire	function	`Truthy a => a -> Char -> Char`
nameChars	value	`Char`
plainChars	value	`Char`
letters	value	`Char`
ʰq̲uoted	function	`Char -> Int`
ʰo̲utside	function	`Char -> Char -> Int`
ʰs̲plit	function	`Char -> Char -> Box Char`
ʰf̲irstText	function	`Box Char -> Char`
ʰf̲irst	function	`Int -> Int`
ʰf̲irstOf	function	`Char -> Char -> Int`
r	value	`Int`
alpha	value	`Float`
lr	value	`Float`
n	value	`Int`
chunks	value	`Int`
every	value	`Int`
i	value	`Float`
W	value	`Float`
p	value	`Float`
T	value	`Float`
c	value	`Float`
X	value	`Float`
Y	value	`Float`
Xt	value	`Float`
Yt	value	`Float`
Xh	value	`Float`
Yh	value	`Float`
s	value	`Float`
q	value	`Int`
A	value	`Float`
B	value	`Float`
a0	value	`(Float, Float, Float, Float)`
step	value	`(Float, Float, Float, Float)`
Ws	value	`Float`
As	value	`Float`
Bs	value	`Float`
W2	value	`Float`
A2	value	`Float`
B2	value	`Float`
lossT	value	`Float`
lossH	value	`Float`
recA	value	`Float`
recB	value	`Float`
recD	value	`Float`
_	function	`Char`
blocks	value	`Char`
width	value	`Int`
ʰs̲cale	function	`(Num a, Num b) => a -> b -> Int`
ˡb̲ars	function	`Num a => Box Char -> a -> Char`
ˡs̲park	function	`Num a => a -> Char`
ˡh̲istogram	function	`Num a => Int -> a -> Char`
ˡs̲catter	function	`Num a => Int -> a -> Char`
ˡl̲ine!	function	`Num a => a -> Char`
ˡl̲ines!	function	`Num a => Box Char -> Box a -> Char`
ˡc̲hart!	function	`Num a => Box Char -> Box a -> Char`
ˡl̲inspace	function	`(Num a, Num b) => Int -> (a, b) -> Float`
ˡf̲unction!	function	`Float -> Char`
ˡf̲unctions!	function	`Box Char -> Box Float -> Char`
ˡf̲unctionChart!	function	`Box Char -> Box Float -> Char`
ʰx̲box	function	`Float -> Float`
ʰx̲boxAll	function	`Box Float -> Float`
ʰW	value	`Float`
ʰH	value	`Float`
ʰL	value	`Float`
ʰR	value	`Float`
ʰT	value	`Float`
ʰB	value	`Float`
ʰcolors	value	`Box Char`
ʰj̲oined	function	`Box Float -> Float`
ʰc̲hart	function	`Box Char -> Box Float -> Char`
ʰp̲ad	function	`Float -> Float -> Float`
ʰj̲oinText	function	`Box Char -> Char`
ʰc̲olor	function	`Int -> Box Char -> Char`
ʰx̲at	function	`Int -> Int -> Float`
ʰr̲ound	function	`Float -> Float`
ʰy̲at	function	`Float -> Float -> Float`
ʰx̲atValue	function	`Float -> Float -> Float`
ʰs̲eriesXY	function	`Char -> Box Float -> Char`
ʰs̲eries	function	`Char -> Box Float -> Char`
ʰsmall	value	`Char`
ʰf̲rame	function	`Int -> Float -> Char`
ʰf̲rameXY	function	`Float -> Float -> Char`
ʰc̲hartXY	function	`Box Char -> (Float, Box Float) -> Char`
ʰt̲itles	function	`Box Char -> Char`
ʰk̲ept	function	`Char -> Char -> Char`
blanks	value	`Char`
ˡu̲pper	function	`Char -> Char`
ˡl̲ower	function	`Char -> Char`
ˡt̲rimStart	function	`Char -> Char`
ˡt̲rimEnd	function	`Char -> Char`
ˡt̲rim	function	`Char -> Char`
ˡw̲ords	function	`Char -> Box Char`
ˡj̲oin	function	`Char -> Box Char -> Char`
ˡs̲queeze	function	`Char -> Char`
ˡf̲ind	function	`Eq a => a -> a -> Int`
ʰa̲part	function	`Num a => a -> a -> a`
ˡo̲ccurrences	function	`Eq a => a -> a -> Int`
ˡs̲plit	function	`Eq a => a -> a -> Box a`
ˡl̲ines	function	`Char -> Box Char`
ˡr̲eplace	function	`Box Char -> Char -> Char`
ˡp̲refix?	function	`(Match a, Truthy b) => a -> a -> b`
ˡs̲uffix?	function	`(Match a, Truthy b) => a -> a -> b`
ˡi̲nfix?	function	`(Eq a, Truthy b) => a -> a -> b`
ˡp̲adLeft	function	`Int -> a -> a`
ˡp̲adRight	function	`Int -> a -> a`
ˡc̲enter	function	`Int -> a -> a`
ˡr̲epeat	function	`Int -> a -> a`
ˡm̲ix	function	`Box a -> a`
digits	value	`Char`
ʰp̲added	function	`Int -> Int -> Char`
ʰo̲ne	function	`Num a => Int -> a -> Char`
ˡf̲ixed	function	`Num a => Int -> a -> Box Char`
ʰc̲ommas	function	`a -> Char`
ʰg̲rouped	function	`Num a => a -> Char`
ʰa̲mount1	function	`Num a => Int -> a -> Char`
ˡt̲housands	function	`Num a => a -> Box Char`
ˡa̲mount	function	`Num a => Int -> a -> Box Char`
ˡp̲ercent	function	`Num a => Int -> a -> Box Char`
ʰr̲ows	function	`Int -> Box a -> a`
ˡc̲olumn	function	`Box a -> a`
ʰn̲umeric?	function	`Truthy a => Char -> a`
ˡt̲able	function	`Box Char -> Char`
ˡd̲eltas	function	`Num a => a -> a`
ˡw̲indows	function	`Int -> a -> a`
ˡm̲ovingMean	function	`Num a => Int -> a -> Float`
ʰs̲tarts	function	`(Eq a, Num b, Truthy b) => a -> b`
ˡr̲unValues	function	`Eq a => a -> a`
ˡr̲unLengths	function	`Eq a => a -> Int`
ˡc̲hunks	function	`Int -> a -> Box a`
ˡr̲aze	function	`Box a -> a`
ˡs̲hift	function	`Int -> a -> a`
ˡi̲nterleave	function	`a -> a -> a`
ʰb̲s	function	`Ord a => a -> a -> Int -> Int -> Int`
ˡb̲search	function	`Ord a => a -> a -> Int`
ˡa̲ttr	function	`Char -> Char -> Char`
ˡe̲scape	function	`Char -> Char`
ˡf̲ill	function	`Char -> Char`
ˡr̲gb	function	`Num a => a -> Char`
ˡs̲troke	function	`Char -> a -> Char`
ˡp̲olygon	function	`Char -> a -> Char`
ˡp̲olyline	function	`Char -> a -> Char`
ˡa̲t	function	`a -> Char`
ˡt̲ext	function	`Char -> Char -> Char`
ˡs̲pan	function	`Char -> Char -> Char`
ˡs̲ized	function	`a -> Char -> Char`
ˡm̲arkup	function	`Char -> Char -> Char`
ˡg̲roup	function	`Char -> Char -> Char`
ˡt̲ranslate	function	`a -> Char`
ˡr̲otate	function	`a -> Char`
ˡm̲atrix	function	`Num a => a -> Char`
ˡs̲cale	function	`a -> Char`
ˡc̲lip	function	`Char -> a -> Char`
ˡc̲lipped	function	`Char -> Char -> Char`
ˡg̲radient	function	`Char -> Box Char -> Char`
ˡp̲icture	function	`a -> Char -> Char`
ˡp̲ictureWith	function	`a -> Box Char -> Char`
ʰe̲sc	function	`Char -> Char`
ʰj̲oin	function	`Box Char -> Char`
ʰp̲airs	function	`a -> Char`
ˢu̲se<	built-in macro	`Char -> Char -> Unit`
ˢi̲f<	macro	`Char -> Char -> Char`
ˢu̲nless<	macro	`Char -> Char -> Char`
ˢe̲ach<	macro	`Char -> Char -> Char`
ˢl̲ine<	macro	`Unit -> Unit -> Char`
ˢf̲ile<	macro	`Unit -> Unit -> Char`
ˢi̲nclude<	macro	`Unit -> Char -> Char`
ˢc̲fg<	macro	`Unit -> Char -> Char`
ˢe̲rror<	macro	`Char -> Char -> Char`
ˢd̲bg<	macro	`Unit -> Char -> Char`
ˢa̲ssert<	macro	`Char -> a -> Char`
ˢf̲ormat<	macro	`Unit -> Char -> Char`
ˢp̲anic<	macro	`Unit -> Char -> Char`
ˢt̲odo<	macro	`Unit -> Char -> Char`
ˢt̲ry<	macro	`Char -> Char -> Char`
ˢc̲atch<	macro	`Char -> Char -> Char`
ˢf̲inally<	macro	`Char -> Char -> Char`
ˢr̲ecover<	macro	`Unit -> Char -> Char`
ˢr̲etry<	macro	`Unit -> Unit -> Char`
ˢh̲alt<	macro	`Unit -> Unit -> Char`
ˢc̲ontinue<	macro	`Unit -> Unit -> Char`
catchCodes	value	`Char`
ʰm̲atchCode	function	`Char -> Char`
ifArgs	value	`Char`
eachAlone	value	`Char`
eachHole	value	`Char`
ʰt̲rim	function	`Char -> Char`
ʰw̲ords	function	`Char -> Box Char`
ʰs̲eps	function	`Truthy a => Char -> a`
ʰh̲oles	function	`(Num a, Truthy a) => Char -> a`
ʰj̲oin	function	`Box Char -> Char`
ʰq̲uote	function	`Char -> Char`
ʰc̲opy	function	`Char -> Char -> Char`
ʰw̲hy	function	`Char -> Char`
ʰo̲rEmpty	function	`Char -> Char`
ʰl̲it	function	`Char -> Char`
ʰc̲j	function	`Char -> Char -> Char`
ʰp̲ieces	function	`Char -> Char`
alpha	value	`Float`
lr	value	`Float`
n	value	`Int`
steps	value	`Int`
i	value	`Float`
W	value	`Float`
p	value	`Float`
T	value	`Float`
c	value	`Float`
X	value	`Float`
Y	value	`Float`
Xt	value	`Float`
Yt	value	`Float`
Xh	value	`Float`
Yh	value	`Float`
table	value	`Float`
M	value	`Float`
w0	value	`(Float, Float, Float, Float)`
_	function	`Char`
_	function	`Char`
_	function	`Char`
W	value	`Float`
A	value	`Float`
B	value	`Float`
X	value	`Float`
s	value	`Float`
y	value	`Float`