X_eTaL documentation
Files
- library 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 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: "q:" 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.
- 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.
- library 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 libs/Bits/src/Bits.xtl: Bits: bits -- binary digits and back, popcount, and, or, xor on whole numbers, shifts, single bits, Gray codes. Import it with an alias of your choice: "b:" u_se< "Bits". Put libs/Bits/src on XETAL_PATH ("just path"); the reference is libs/Bits/docs. Names with l: are exported; those under h: are private to this file.
- library libs/Check/src/Check.xtl: Check: assertions that report as text, for tests and teaching. Import it with an alias of your choice: "k:" u_se< "Check". Put libs/Check/src on XETAL_PATH ("just path"); the reference is libs/Check/docs. Names with l: are exported; those under h: are private to this file.
- library libs/Combinatorics/src/Combinatorics.xtl: Combinatorics: counting and listing -- factorials, binomials, combinations, permutations, subsets, Cartesian products. Import it with an alias of your choice: "cb:" u_se< "Combinatorics". Put libs/Combinatorics/src on XETAL_PATH ("just path"); the reference is libs/Combinatorics/docs. Names with l: are exported; those under h: are private to this file.
- library libs/Csv/src/Csv.xtl: Csv: comma-separated values -- lines to fields (quoted fields kept whole), a table of texts, columns by number or name, numbers, and back to text. Import it with an alias of your choice: "cs:" u_se< "Csv". Put libs/Csv/src on XETAL_PATH ("just path"); the reference is libs/Csv/docs. Names with l: are exported; those under h: are private to this file.
- library libs/Dates/src/Dates.xtl: Dates: dates -- day numbers from calendar dates and back, weekdays, leap years, month lengths, ISO text, month calendars. Import it with an alias of your choice: "d:" u_se< "Dates". Put libs/Dates/src on XETAL_PATH ("just path"); the reference is libs/Dates/docs. Names with l: are exported; those under h: are private to this file.
- library libs/Eigencube/src/Eigencube.xtl: Eigencube: a Rubik's cube as rotation matrices, turned by matrix products and solved by search. A port of Steffen Smolka's eigencube.py (github.com/smolkaj/eigencube, MIT). Each of the 26 cubelets is the integer point c of {-1, 0, 1}^3 where it sits in the solved cube and carries a rotation matrix R: it sits now at R c. A quarter turn of the face with outward normal v moves the cubelets with v . (R c) > 0, multiplying R by one rotation matrix. A batch of cubes is one array, n by 26 by 3 by 3, so all twelve turns of every cube in a search are two matrix products. Import it with an alias of your choice: "ec:" u_se< "Eigencube". Put libs/Eigencube/src on XETAL_PATH ("just path"); the reference is libs/Eigencube/docs. Names with l: are exported; those under h: are private to this file.
- library libs/Geometry/src/Geometry.xtl: Geometry: plane geometry -- points as 2-row matrices, distances, polygon area and centroid, rotation, scaling and moves, convex hulls, pictures. Import it with an alias of your choice: "ge:" u_se< "Geometry". Put libs/Geometry/src on XETAL_PATH ("just path"); the reference is libs/Geometry/docs. Names with l: are exported; those under h: are private to this file.
- library libs/Graphs/src/Graphs.xtl: Graphs: graphs as adjacency matrices -- from edges, degrees, reachability, shortest paths, breadth-first levels, connected components. Import it with an alias of your choice: "g:" u_se< "Graphs". Put libs/Graphs/src on XETAL_PATH ("just path"); the reference is libs/Graphs/docs. Names with l: are exported; those under h: are private to this file.
- library libs/Grouping/src/Grouping.xtl: Grouping: grouping by key -- the groups, and counts, sums, means, least and greatest per key, or any function per key. Import it with an alias of your choice: "gr:" u_se< "Grouping". Put libs/Grouping/src on XETAL_PATH ("just path"); the reference is libs/Grouping/docs. Names with l: are exported; those under h: are private to this file.
- library libs/Matrix/src/Matrix.xtl: Matrix: matrices -- identity, diagonal, trace, product, determinant, inverse, solving linear systems. Import it with an alias of your choice: "mx:" u_se< "Matrix". Put libs/Matrix/src on XETAL_PATH ("just path"); the reference is libs/Matrix/docs. Names with l: are exported; those under h: are private to this file.
- library libs/Numbers/src/Numbers.xtl: Numbers: number theory -- gcd and lcm, primes, factors, divisors, digits, integer square roots, Fibonacci numbers. Import it with an alias of your choice: "n:" u_se< "Numbers". Put libs/Numbers/src on XETAL_PATH ("just path"); the reference is libs/Numbers/docs. Names with l: are exported; those under h: are private to this file.
- library 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 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.
- library libs/Polynomials/src/Polynomials.xtl: Polynomials: polynomials -- evaluation, sums, products, derivatives, integrals, real roots, text. Import it with an alias of your choice: "py:" u_se< "Polynomials". Put libs/Polynomials/src on XETAL_PATH ("just path"); the reference is libs/Polynomials/docs. Names with l: are exported; those under h: are private to this file.
- library libs/Random/src/Random.xtl: Random: randomness -- shuffles, deals, choices, uniform and normal samples, weighted picks. Import it with an alias of your choice: "r:" u_se< "Random". Put libs/Random/src on XETAL_PATH ("just path"); the reference is libs/Random/docs. Names with l: are exported; those under h: are private to this file.
- library libs/Search/src/Search.xtl: Search: searching and ranking -- positions in sorted lists, merges, the k largest, ranks with ties, nearest items, order statistics, ranges. Import it with an alias of your choice: "sr:" u_se< "Search". Put libs/Search/src on XETAL_PATH ("just path"); the reference is libs/Search/docs. Names with l: are exported; those under h: are private to this file.
- library libs/Sets/src/Sets.xtl: Sets: vectors as sets -- union, intersection, difference, subset, and how often each item occurs. Import it with an alias of your choice: "se:" u_se< "Sets". Put libs/Sets/src on XETAL_PATH ("just path"); the reference is libs/Sets/docs. Names with l: are exported; those under h: are private to this file.
- library libs/Statistics/src/Statistics.xtl: Statistics: statistics -- median, quantiles, five-number summaries, z-scores, covariance, correlation, a least-squares line, binned counts; builds on the standard Stats. Import it with an alias of your choice: "sx:" u_se< "Statistics". Put libs/Statistics/src on XETAL_PATH ("just path"); the reference is libs/Statistics/docs. Names with l: are exported; those under h: are private to this file.
- library std/Stats.xtl: 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.
- macro library libs/Bits/src/Bits.xtlm: Bits: its macro library -- f_ields<, named bit fields. Imported with the functions, under one alias: "b:" u_se< "Bits". 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 libs/Check/src/Check.xtlm: Check: its macro library -- c_ases<, table-driven checks named by their own source text. Imported with the functions, under one alias: "k:" u_se< "Check". 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 libs/Csv/src/Csv.xtlm: Csv: its macro library -- c_olumns<, a table's columns as named, typed variables. Imported with the functions, under one alias: "cs:" u_se< "Csv". 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 libs/Dates/src/Dates.xtlm: Dates: its macro library -- d_ate<, date literals checked at compile time. Imported with the functions, under one alias: "d:" u_se< "Dates". 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 libs/Graphs/src/Graphs.xtlm: Graphs: its macro library -- g_raph<, a graph written by its names. Imported with the functions, under one alias: "g:" u_se< "Graphs". 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 libs/Polynomials/src/Polynomials.xtlm: Polynomials: its macro library -- p_oly<, maths notation compiled. Imported with the functions, under one alias: "py:" u_se< "Polynomials". 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.
- program libs/Bits/demos/nim.xtl: Nim: heaps of counters; take any number from one heap; whoever takes the last counter wins. The winning move makes the xor of the heaps (the nim-sum) zero, worked out for every heap at once. Run with "just demo Bits nim".
- program libs/Bits/demos/record.xtl: A packed record: a device register keeps three settings in one whole number. f_ields< names its bit fields when the program is compiled: it writes a getter and a setter per field, the shifts and masks worked out as plain numbers, so the program reads and writes fields by name. Run with "just demo Bits record".
- program libs/Check/demos/grading.xtl: Grading a function with Check: a student's median, tested against cases with known answers. Run with "just demo Check grading".
- program libs/Check/demos/table.xtl: Table-driven checks: c_ases< writes one check per row when the program is compiled, each named by its own source text, so a failing case says which without writing the expression twice. The last row is wrong on purpose (# shows failures). Run with "just demo Check table".
- program libs/Combinatorics/demos/lottery.xtl: Lottery odds and a tiny tournament. Run with "just demo Combinatorics lottery".
- program libs/Csv/demos/cities.xtl: A small dataset as CSV: read it into a table, take columns by name, summarize them with Statistics, and set a report with Format. The data is the file cities.csv beside this program, built in when the program is compiled (X_eTaL's system macro i_nclude<), so it needs no file access when it runs, in a terminal or in the browser. Run with "just demo Csv cities".
- program libs/Csv/demos/schema.xtl: A table's columns as named, typed variables: c_olumns< reads the schema when the program is compiled and writes a definition per column, so the program speaks of city and population, and their kinds are checked like any variable's. Run with "just demo Csv schema".
- program libs/Dates/demos/calendar.xtl: A year's dates as arrays: this month's calendar, every Friday the 13th of 2026 at once, and how many days lie between two dates. Run with "just demo Dates calendar".
- program libs/Dates/demos/literals.xtl: Date literals: d_ate< turns each into its day number when the program is compiled, so the program holds plain numbers and nothing parses a date when it runs. Run with "just demo Dates literals".
- program libs/Eigencube/demos/solve.xtl
- program libs/Format/demos/invoice.xtl: An invoice: items, quantities and prices set as a table, money to 2 places, a total with thousands separated, the tax as a percentage. Run with "just demo Format invoice".
- program libs/Geometry/demos/hull.xtl: A fence round scattered trees: the convex hull of 40 random points (seeded, so it repeats), its corners, the area it encloses and its center, and its picture. Run with "just demo Geometry hull".
- program libs/Graphs/demos/stations.xtl: A subway map written by its station names: g_raph< defines a variable per station and the map as a matrix when the program is compiled, so the program speaks of stations, not numbers. Run with "just demo Graphs stations".
- program libs/Graphs/demos/subway.xtl: A small subway map: eight stations on a red line, a blue line and a branch, with the minutes between stations. How long from the Airport to everywhere, how many stops from the Center, and what a closure cuts off. Run with "just demo Graphs subway".
- program libs/Grouping/demos/sales.xtl: A month of sales: totals, averages and the best sale per region, set as a table, and the totals as bars. Run with "just demo Grouping sales".
- program libs/Lists/demos/temperatures.xtl: A fortnight of temperatures: day-to-day changes, a 3-day moving mean, the longest warming streak, and where 20 degrees falls in the sorted readings. Run with "just demo Lists temperatures".
- program libs/Matrix/demos/line-fit.xtl: A straight line through noisy points by least squares: the normal equations (X' X) b = X' y, solved. Run with "just demo Matrix line-fit".
- program libs/Numbers/demos/primes.xtl: Primes: twin primes, Goldbach's conjecture and perfect numbers, each one array expression. Run with "just demo Numbers primes".
- program libs/Plot/demos/weather.xtl: A year of weather in text charts: rainfall by month as bars, temperatures as a sparkline, a scatter of temperature against rain, and the temperatures as a line chart picture. Run with "just demo Plot weather".
- program libs/Polynomials/demos/curve.xtl: A curve through five points: the polynomial of degree 4 through them (solving with the Matrix library), where it crosses zero, where it turns (the roots of its derivative), and its picture. Run with "just demo Polynomials curve".
- program libs/Polynomials/demos/notation.xtl: Polynomials written as maths: p_oly< reads the notation when the program is compiled and writes the coefficients in its place. Run with "just demo Polynomials notation".
- program libs/Random/demos/dice.xtl: Two dice, 6000 throws: how often each total comes up, drawn as a bar of stars per total, beside what theory says (36ths). Run with "just demo Random dice".
- program libs/Search/demos/exam.xtl: Exam results: the top three, everyone's rank (ties share it), the score at each grade boundary, and who scored between 60 and 79. Run with "just demo Search exam".
- program libs/Sets/demos/clubs.xtl: Clubs: who is in which club, as sets of names. Run with "just demo Sets clubs".
- program libs/Statistics/demos/heights.xtl: Heights and weights of twelve people: a summary of each, how they relate, the line through them, and who is unusual. Run with "just demo Statistics heights".
- program libs/Strings/demos/word-count.xtl: Word count: the words of a text, how often each occurs, the most frequent first. Run with "just demo Strings word-count".
Items
| name | kind | type |
|---|---|---|
| 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 |
| ˡ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 |
| ˢ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 |
| 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 |
| w | value | Int |
| ʰc̲ols | function | Int -> Int |
| ˡb̲its | function | Int -> Int -> Int |
| ˡv̲alue | function | Num a => a -> a |
| ˡp̲opcount | function | Int -> Int |
| ˡa̲nd | function | Int -> Int -> Int |
| ˡo̲r | function | Int -> Int -> Int |
| ˡx̲or | function | Int -> Int -> Int |
| ˡs̲hl | function | Num a => a -> a -> a |
| ˡs̲hr | function | Int -> Int -> Int |
| ˡb̲it? | function | Truthy a => Int -> Int -> a |
| ˡm̲ask | function | Num a => a -> a |
| ˡg̲ray | function | Int -> Int |
| ˡu̲ngray | function | Int -> Int |
| ʰn̲l | function | Unit -> Char |
| ʰo̲neLine | function | Char -> Char |
| ʰs̲hown | function | a -> Char |
| ʰf̲ail | function | a -> b -> Char |
| ˡi̲s | function | Match a => a -> a -> Char |
| ˡn̲ear | function | Num a => a -> a -> Char |
| ˡt̲rue | function | Truthy a => a -> Char |
| ˡt̲est | function | Char -> Char -> Char |
| ˡa̲nd | function | Char -> Char -> Char |
| ˡc̲ount | function | Char -> Int |
| ˡf̲ailures | function | Char -> Int |
| ˡp̲assed? | function | Truthy a => Char -> a |
| ˡr̲eport | function | Char -> Char |
| ˡf̲actorial | function | Int -> Int |
| ʰc̲h | function | Int -> Int -> Int |
| ˡc̲hoose | function | Int -> Int -> Int |
| ˡc̲ombinations | function | Int -> Int -> Int |
| ʰf̲irstThen | function | (Num a, Truthy a) => a -> a -> a |
| ˡp̲ermutations | function | Int -> Int |
| ˡs̲ubsets | function | Int -> Int |
| ˡp̲owerset | function | a -> Box a |
| ˡp̲roduct | function | a -> a -> a |
| dq | value | Char |
| ʰu̲nquote | function | Char -> Char |
| ˡf̲ields | function | Char -> Box Char |
| ˡr̲ows | function | Char -> Box Char |
| ˡc̲olumn | function | Int -> a -> a |
| ˡf̲ield | function | Eq a => a -> Box a -> Box a |
| ˡn̲umbers | function | Char -> Box Char -> Float |
| ʰq̲uote | function | Char -> Char |
| ˡt̲ext | function | Box Char -> Char |
| ˡd̲ays | function | Int -> Int |
| ˡc̲ivil | function | Int -> Int |
| ˡt̲oday | function | Unit -> Int |
| ˡw̲eekday | function | Int -> Int |
| ˡl̲eap? | function | Truthy a => Int -> a |
| ˡd̲aysIn | function | (Num a, Truthy a) => Int -> Int -> a |
| ʰt̲wo | function | a -> Char |
| ˡi̲so | function | Int -> Box Char |
| ˡc̲alendar | function | Int -> Int -> Int |
| ˡm̲onth | function | Int -> Int -> Char |
| pts | value | Int |
| C | value | Int |
| kind | value | Int |
| z | value | Int |
| I | value | Int |
| ˡsolved | value | Int |
| N | value | Int |
| ˡfaces | value | Char |
| V | value | Int |
| dir | value | Int |
| E | value | Int |
| Mf | value | Int |
| M | value | Int |
| ʰt̲urns | function | Int -> Int |
| ʰp̲os | function | Int -> Int |
| ʰc̲hildren | function | Int -> Int |
| ˡt̲urn | function | Int -> Int -> Int |
| ˡd̲o | function | Int -> Int -> Int |
| across | value | Int |
| down | value | Int |
| ˡs̲tickers | function | Int -> Int |
| ʰg̲row | function | Int -> Int |
| G | value | Int |
| Tm | value | Int |
| ʰo̲rient | function | Int -> Int |
| at | value | Int |
| layer | value | Int |
| ʰn̲ext | function | Int -> Int |
| ʰr̲elax | function | Num a => a -> a |
| ʰd̲istances | function | Num a => a -> a |
| colDev | value | Int |
| Dsolved | value | Int |
| ˡs̲olved? | function | Truthy a => Int -> a |
| posDev | value | Int |
| Dplace | value | Int |
| yellowDown | value | Int |
| sets | value | Int |
| ʰs̲pec | function | Num a => a -> a |
| ʰo̲f | function | Int -> Int -> Int |
| ʰr̲elevant | function | Truthy a => Int -> a |
| ʰp̲roject | function | Num a => a -> a -> a |
| ʰs̲core | function | Int -> Int -> Float |
| batch | value | Int |
| greed | value | Float |
| ˡi̲nverse | function | Int -> Int |
| ʰf̲ace | function | Int -> Int |
| ʰc̲ubes | function | Int -> Int |
| ʰk̲ey | function | Num a => a -> a |
| macros | value | Box Int |
| middle | value | Int |
| bottom | value | Int |
| ʰa̲ctions | function | (Num a, Num b) => a -> b -> Int |
| ʰa̲long | function | Int -> Int -> Int |
| ʰm̲acros | function | Int -> Int -> Int |
| ʰe̲xpand | function | Int -> Int -> Int |
| ʰf̲latten | function | Int -> Int |
| ʰs̲tep | function | Num a => (Int, Int) -> (Int, Int, Int, Int, a, Float, Int) -> Int |
| ʰt̲race | function | (Int, Int) -> Int -> Int |
| ʰs̲earch | function | (Int, Int) -> Int -> Int |
| ʰs̲tage | function | Num a => a -> (Int, Int, Int) -> (Int, Int, Int) |
| twist | value | Int |
| bottomTurn | value | Int |
| ʰo̲riented? | function | Int -> Int |
| ʰc̲orner | function | (Int, Int) -> (Int, Int) |
| ʰf̲inish | function | (Int, Int) -> (Int, Int) |
| ˡs̲olve | function | Num a => a -> Int -> (Int, Int, Int) |
| ˡn̲ame | function | Int -> Char |
| ˡp̲arse | function | Char -> Int |
| ʰx̲s | function | Num a => a -> Float |
| ʰy̲s | function | Num a => a -> Float |
| ˡd̲istances | function | Num a => a -> Float |
| ʰs̲igned | function | Num a => a -> Float |
| ˡa̲rea | function | Num a => a -> Float |
| ˡc̲entroid | function | Num a => a -> Float |
| ˡr̲otate | function | (Num a, Num b) => a -> b -> Float |
| ʰc̲olumn | function | (Num a, Num b) => a -> b -> Float |
| ˡs̲cale | function | (Num a, Num b) => a -> b -> Float |
| ˡm̲ove | function | (Num a, Num b) => a -> b -> Float |
| ʰc̲ross | function | Num a => a -> Int -> Float |
| ʰn̲ext | function | Num a => a -> Int -> Int |
| ʰw̲alk | function | Num a => a -> Int -> Int -> Int -> Int |
| ˡh̲ull | function | Num a => a -> a |
| ˡs̲how! | function | Num a => a -> Char |
| far | value | Float |
| ˡa̲djacency | function | (Num a, Truthy a) => Int -> Int -> a |
| ˡw̲eighted | function | Int -> Int -> Int |
| ˡu̲ndirected | function | (Truthy a, Truthy b) => a -> b |
| ˡo̲utDegree | function | Num a => a -> a |
| ˡi̲nDegree | function | Num a => a -> a |
| ʰc̲lose | function | Truthy a => a -> a |
| ˡr̲each | function | (Num a, Truthy b) => a -> b |
| ʰr̲elax | function | Num a => a -> a |
| ˡs̲hortest | function | Num a => a -> Float |
| ʰb̲fs | function | (Num a, Truthy a) => a -> a -> a -> a -> a -> a |
| ˡl̲evels | function | Int -> Int -> Int |
| ˡc̲omponents | function | Truthy a => a -> Int |
| ˡg̲roups | function | Eq a => a -> b -> Box b |
| ˡb̲y | function | Eq c => (a -> b) -> c -> a -> b |
| ˡc̲ount | function | Eq a => a -> Int |
| ˡs̲um | function | (Eq a, Num b) => a -> b -> b |
| ˡm̲ean | function | (Eq a, Num b) => a -> b -> Float |
| ˡl̲east | function | (Eq a, Num b) => a -> b -> b |
| ˡg̲reatest | function | (Eq a, Num b) => a -> b -> b |
| ˡi̲dentity | function | Num a => Int -> a |
| ˡd̲iag | function | a -> a |
| ˡt̲race | function | Num a => a -> a |
| ˡm̲ul | function | Num a => a -> a -> a |
| ʰs̲wapping | function | Int -> Int -> Int -> Int |
| ʰp̲ivot | function | Num a => Int -> a -> Int |
| ʰg̲j | function | Int -> Int -> Float -> Float |
| ˡs̲olve | function | Num a => a -> a -> Float |
| ˡi̲nverse | function | Num a => a -> Float |
| ʰd̲etF | function | Float -> Float |
| ˡd̲et | function | Num a => a -> Float |
| ʰe̲uclid | function | Int -> Int -> Int |
| ˡg̲cd | function | Int -> Int -> Int |
| ˡl̲cm | function | Int -> Int -> Int |
| ˡi̲sqrt | function | Int -> Int |
| ʰs̲ieve | function | Int -> Int |
| ˡp̲rimes | function | Int -> Int |
| ʰp̲rime1 | function | Truthy a => Int -> a |
| ˡp̲rime? | function | Truthy a => Int -> a |
| ˡf̲actors | function | Int -> Int |
| ˡd̲ivisors | function | Int -> Int |
| ˡb̲ase | function | Int -> Int -> Int |
| ˡd̲igits | function | Int -> Int |
| ˡf̲ib | function | Num a => Int -> a |
| 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 |
| ʰ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 |
| ʰs̲eries | function | Char -> Box Float -> Char |
| ʰsmall | value | Char |
| ʰf̲rame | function | Int -> Float -> Char |
| ʰt̲itles | function | Box Char -> Box Float -> Char |
| ʰk̲ept | function | Char -> Char -> Char |
| ˡ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 |
| ˡa̲t | function | (Num a, Num b) => a -> b -> Float |
| ʰt̲rim | function | Num a => a -> a |
| ˡp̲lus | function | (Num a, Num b) => a -> b -> Float |
| ˡt̲imes | function | (Num a, Num b) => a -> b -> Float |
| ˡd̲erivative | function | Num a => a -> Float |
| ˡi̲ntegral | function | Num a => a -> Float |
| ʰs̲tep | function | Num a => a -> Float -> Float |
| ˡr̲oots | function | Num a => a -> Float |
| ʰs̲ize | function | Float -> Char |
| ʰp̲ow | function | Num a => a -> Char |
| ʰt̲erm | function | Num a => Float -> a -> Char |
| ʰs̲ep | function | Float -> Char |
| ˡt̲ext | function | Num a => a -> Char |
| big | value | Int |
| ʰk̲eys! | function | Int -> Int |
| ˡs̲huffle! | function | a -> a |
| ˡd̲eal! | function | Int -> Int -> Int |
| ˡc̲hoice! | function | a -> a |
| ˡs̲ample! | function | Int -> a -> a |
| ˡu̲niform! | function | Int -> Float |
| ˡn̲ormal! | function | Int -> Float |
| ˡw̲eighted! | function | Num a => a -> Int -> Int |
| ˡp̲osition | function | Ord a => a -> a -> Int |
| ˡm̲erge | function | Ord a => a -> a -> a |
| ˡt̲opAt | function | Num a => Int -> a -> Int |
| ˡt̲op | function | Num a => Int -> a -> a |
| ˡk̲th | function | Ord a => Int -> a -> a |
| ˡr̲ank | function | Ord a => a -> Float |
| ˡd̲enseRank | function | Ord a => a -> Int |
| ˡn̲earest | function | (Num a, Num b) => a -> b -> Int |
| ˡb̲etween | function | (Ord a, Truthy b) => a -> a -> b |
| ˡu̲nion | function | Eq a => a -> a -> a |
| ˡi̲ntersect | function | Eq a => a -> a -> a |
| ˡd̲ifference | function | Eq a => a -> a -> a |
| ˡs̲ymmetric | function | Eq a => a -> a -> a |
| ˡs̲ubset? | function | (Eq a, Truthy b) => a -> a -> b |
| ˡs̲ame? | function | (Eq a, Truthy b) => a -> a -> b |
| ˡd̲isjoint? | function | (Eq a, Truthy b) => a -> a -> b |
| ˡc̲ounts | function | Eq a => a -> Int |
| ˡm̲ode | function | Eq a => a -> a |
| ʰq̲1 | function | Float -> Float -> Float |
| ˡq̲uantile | function | (Num a, Num b) => a -> b -> Float |
| ˡm̲edian | function | Num a => a -> Float |
| ˡf̲ive | function | Num a => a -> Float |
| ˡz̲scores | function | Num a => a -> Float |
| ˡc̲ovariance | function | (Num a, Num b) => a -> b -> Float |
| ˡc̲orrelation | function | (Num a, Num b) => a -> b -> Float |
| ˡf̲it | function | (Num a, Num b) => a -> b -> Float |
| ˡb̲ins | function | Num a => Int -> a -> Int |
| ˡm̲ean | function | Num a => a -> Float |
| ʰs̲quare | function | Num a => a -> a |
| ʰd̲eviations | function | Num a => a -> Float |
| ˡv̲ariance | function | Num a => a -> Float |
| ˡs̲d | function | Num a => a -> Float |
| ˡr̲ange | function | Num a => a -> a |
| lowers | value | Char |
| uppers | value | Char |
| letters | value | Char |
| ʰn̲ame | function | Char -> Int |
| ʰf̲ieldName | function | Char -> Char |
| ʰf̲ieldWidth | function | Char -> Int |
| ʰf̲ield? | function | Truthy a => Char -> a |
| ʰg̲etter | function | Char -> Char |
| ʰs̲etter | function | Char -> Char |
| ᵐf̲ields< | macro | Unit -> Char -> Char |
| bs | value | Char |
| dq | value | Char |
| ʰe̲scaped | function | Char -> Char |
| ʰr̲ow? | function | Truthy a => Char -> a |
| ʰc̲heck | function | Char -> Char -> Char |
| ᵐc̲ases< | macro | Char -> Char -> Char |
| lowers | value | Char |
| letters | value | Char |
| ʰn̲ame? | function | Truthy a => Char -> a |
| ʰc̲ut | function | Char -> Int |
| ʰc̲olName | function | Char -> Char |
| ʰc̲olKind | function | Char -> Char |
| ʰc̲olumn? | function | Truthy a => Char -> a |
| ʰc̲ode | function | Char -> Char -> Char |
| ᵐc̲olumns< | macro | Char -> Char -> Char |
| digits | value | Char |
| ʰs̲paced | function | Char -> Char |
| ʰf̲ormed? | function | Truthy a => Char -> a |
| ʰv̲alid? | function | Truthy a => Int -> a |
| ᵐd̲ate< | macro | Unit -> Char -> Char |
| lowers | value | Char |
| letters | value | Char |
| ʰr̲aze | function | Box a -> a |
| ʰn̲ame? | function | Truthy a => Char -> a |
| ʰp̲aths | function | Char -> Box (Box Char) |
| ᵐg̲raph< | macro | Char -> Char -> Char |
| allowed | value | Char |
| ʰs̲queezed | function | Char -> Char |
| ʰt̲erms | function | Char -> Box Char |
| ʰs̲ign | function | Char -> Float |
| ʰb̲ody | function | Char -> Char |
| ʰw̲ell? | function | Truthy a => Char -> a |
| ʰn̲umeral? | function | Truthy a => Char -> a |
| ʰp̲ower | function | Char -> Int |
| ʰc̲oefficient | function | Char -> Float |
| ᵐp̲oly< | macro | Unit -> Char -> Char |
| heaps | value | Int |
| nimsum | value | Int |
| target | value | Int |
| after | value | Int |
| ᵘo̲n | function | Int -> Int |
| ᵘs̲etOn | function | Int -> Int -> Int |
| ᵘm̲ode | function | Int -> Int |
| ᵘs̲etMode | function | Int -> Int -> Int |
| ᵘl̲evel | function | Int -> Int |
| ᵘs̲etLevel | function | Int -> Int -> Int |
| reg | value | Int |
| reg | value | Int |
| reg | value | Int |
| reg | value | Int |
| ᵘm̲edian | function | Ord a => a -> a |
| a | value | Char |
| b | value | Char |
| c | value | Char |
| d | value | Char |
| ᵘc̲lamp | function | Num a => a -> a |
| tickets | value | Int |
| k | value | Int |
| ways | value | Int |
| teams | value | Char |
| m | value | Int |
| data | value | Char |
| t | value | Box Char |
| pop | value | Float |
| area | value | Float |
| density | value | Float |
| t | value | Box Char |
| city | value | Box Char |
| population | value | Float |
| area | value | Float |
| thirteenths | value | Int |
| landing | value | Int |
| landing | value | Int |
| sc | value | Int |
| x | value | Int |
| %10 | value | Int |
| sol | value | Int |
| lens | value | Int |
| e | value | |
| items | value | Box Char |
| qty | value | Int |
| price | value | Float |
| amount | value | Float |
| body | value | Box Char |
| total | value | Float |
| rate | value | Float |
| discount | value | Float |
| total | value | Float |
| trees | value | Float |
| fence | value | Float |
| picture | value | Char |
| airport | value | Int |
| bridge | value | Int |
| center | value | Int |
| docks | value | Int |
| exchange | value | Int |
| fair | value | Int |
| garden | value | Int |
| harbor | value | Int |
| town | value | Int |
| names | value | Box Char |
| lines | value | Int |
| w | value | Int |
| open | value | Bool |
| region | value | Box Char |
| amount | value | Int |
| regions | value | Box Char |
| n | value | Int |
| cells | value | Box Char |
| t | value | Int |
| d | value | Int |
| up | value | Bool |
| x | value | Float |
| y | value | Float |
| X | value | Float |
| Xt | value | Float |
| b | value | Float |
| r | value | Float |
| p | value | Int |
| twin | value | Int |
| ᵘg̲oldbach | function | Int -> Int |
| v | value | Int |
| s | value | Int |
| months | value | Box Char |
| rain | value | Int |
| temp | value | Int |
| picture | value | Char |
| both | value | Char |
| x | value | Float |
| y | value | Float |
| V | value | Float |
| c | value | Float |
| t | value | Float |
| picture | value | Char |
| p | value | Float |
| n | value | Int |
| throws | value | Int |
| totals | value | Int |
| counts | value | Int |
| expected | value | Int |
| names | value | Box Char |
| score | value | Int |
| grade | value | Char |
| chess | value | Box Char |
| drama | value | Box Char |
| choir | value | Box Char |
| all | value | Box Char |
| height | value | Int |
| weight | value | Int |
| f | value | Float |
| z | value | Float |
| ᵘm̲eanOr0 | function | Num a => a -> Float |
| text | value | Char |
| clean | value | Char |
| words | value | Box Char |
| distinct | value | Box Char |
| counts | value | Int |
| order | value | Int |