normalized lib <h3> back to markdown

This commit is contained in:
Anton Dyudin 2015-08-11 14:32:57 -07:00
parent 70ba8eba40
commit de75d74065
38 changed files with 1131 additions and 1131 deletions

View File

@ -1,7 +1,7 @@
volume 0, Kelvin Versioning.
===========================
<h3 id="++hoon"><code>++hoon</code></h3>
### `++hoon`
++ hoon %164 :: version stub

View File

@ -3,7 +3,7 @@ volume 1, Hoon Structures
------------------------------------------------------------------------
<h3 id="++abel"><code>++abel</code></h3>
### `++abel`
++ abel typo :: original sin: type
@ -16,7 +16,7 @@ See also: `++typo`
------------------------------------------------------------------------
<h3 id="++axis"><code>++axis</code></h3>
### `++axis`
++ axis ,@ :: tree address
@ -36,7 +36,7 @@ See also: `++clue`, `++limb`, `++slot`, `++peg`, and Section 2fC
------------------------------------------------------------------------
<h3 id="++also"><code>++also</code></h3>
### `++also`
++ also ,[p=term q=wing r=type] :: alias
@ -44,7 +44,7 @@ XX unused?
------------------------------------------------------------------------
<h3 id="++base"><code>++base</code></h3>
### `++base`
++ base ?([%atom p=odor] %noun %cell %bean %null) :: axils, @ * ^ ? ~
@ -66,7 +66,7 @@ See also: `++tile`, `++twig`
------------------------------------------------------------------------
<h3 id="++bean"><code>++bean</code></h3>
### `++bean`
++ bean ,? :: 0=&=yes, 1=|=no
@ -83,7 +83,7 @@ The Urbit version of a boolean, which we call a loobean. 0 or & is
------------------------------------------------------------------------
<h3 id="++beer"><code>++beer</code></h3>
### `++beer`
++ beer $|(@ [~ p=twig]) :: simple embed
@ -98,7 +98,7 @@ See also: `++phax`, `++scat`, section 2fD
------------------------------------------------------------------------
<h3 id="++beet"><code>++beet</code></h3>
### `++beet`
++ beet $| @ :: advanced embed
$% [%a p=twig] :: take tape
@ -114,7 +114,7 @@ See also: `++sail`, section 2fD
------------------------------------------------------------------------
<h3 id="++bloq"><code>++bloq</code></h3>
### `++bloq`
++ bloq ,@ :: blockclass
@ -129,7 +129,7 @@ See also: section 2cA
------------------------------------------------------------------------
<h3 id="++calf"><code>++calf</code></h3>
### `++calf`
++ calf ,[p=(map ,@ud wine) q=wine] ::
@ -150,7 +150,7 @@ See also: `++wine`, `++dole`, `++doge`, `++dish`, section 2fC
------------------------------------------------------------------------
<h3 id="++char"><code>++char</code></h3>
### `++char`
++ char ,@tD :: UTF-8 byte
@ -167,7 +167,7 @@ See also: `++tape`, `++lust`, `++just`, `++mask`, chapter 2f
------------------------------------------------------------------------
<h3 id="++chub"><code>++chub</code></h3>
### `++chub`
++ chub :: registered battery
$: p=(pair chum tyre) :: definition
@ -181,7 +181,7 @@ See also: Section 2fB.
------------------------------------------------------------------------
<h3 id="++chum"><code>++chum</code></h3>
### `++chum`
++ chum $? lef=term :: jet name
[std=term kel=@] :: kelvin version
@ -205,7 +205,7 @@ See also: `++twig`, `++clue`
------------------------------------------------------------------------
<h3 id="++clue"><code>++clue</code></h3>
### `++clue`
++ clue ,[p=axis q=chum r=tyre] :: battery definition
@ -217,7 +217,7 @@ See also: section 2fB
------------------------------------------------------------------------
<h3 id="++coil"><code>++coil</code></h3>
### `++coil`
++ coil $: p=?(%gold %iron %lead %zinc) :: core type
q=type ::
@ -232,7 +232,7 @@ See also: `++core`, Section 2fB
------------------------------------------------------------------------
<h3 id="++coin"><code>++coin</code></h3>
### `++coin`
++ coin $% [%$ p=dime] ::
[%blob p=*] ::
@ -264,7 +264,7 @@ See also: `++so`, `++co`, Section 2eL, `++dime`
------------------------------------------------------------------------
<h3 id="++cord"><code>++cord</code></h3>
### `++cord`
++ cord ,@t :: text atom (UTF-8)
@ -287,7 +287,7 @@ See also: `++trip`, `++crip`, Section 2eJ
------------------------------------------------------------------------
<h3 id="++date"><code>++date</code></h3>
### `++date`
++ date ,[[a=? y=@ud] m=@ud t=tarp] :: parsed date
@ -302,7 +302,7 @@ See also: `++year`, `++yore`, Section 2cH, `++stud`, `++dust`, Section
------------------------------------------------------------------------
<h3 id="++dime"><code>++dime</code></h3>
### `++dime`
++ dime ,[p=@ta q=@] ::
@ -319,7 +319,7 @@ See also: `++so`, `++co`, Section 2eL, `++coin`
------------------------------------------------------------------------
<h3 id="++dram"><code>++dram</code></h3>
### `++dram`
++ dram $% [| p=(map ,@tas dram)] :: simple unix dir
[& p=@ud q=@] ::
@ -333,7 +333,7 @@ XX Unused
------------------------------------------------------------------------
<h3 id="++each"><code>++each</code></h3>
### `++each`
++ each |*([a=$+(* *) b=$+(* *)] $%([& p=a] [| p=b])) :: either a or b
@ -345,7 +345,7 @@ Tile generator: produces a dicriminated fork between two types.
------------------------------------------------------------------------
<h3 id="++edge"><code>++edge</code></h3>
### `++edge`
++ edge ,[p=hair q=(unit ,[p=* q=nail])] :: parsing output
@ -360,7 +360,7 @@ See also: Section 2eD, `++rule`
------------------------------------------------------------------------
<h3 id="++foot"><code>++foot</code></h3>
### `++foot`
++ foot $% [%ash p=twig] :: dry arm, geometric
[%elm p=twig] :: wet arm, generic
@ -386,7 +386,7 @@ See also: `++ap`, `++ut`, Section 2fB, Section 2fC
------------------------------------------------------------------------
<h3 id="++gate"><code>++gate</code></h3>
### `++gate`
++ gate $+(* *) :: general gate
@ -407,7 +407,7 @@ See also: `++lift`, `++cork`, Core Language Doc
------------------------------------------------------------------------
<h3 id="++hair"><code>++hair</code></h3>
### `++hair`
++ hair ,[p=@ud q=@ud] :: parsing trace
@ -427,7 +427,7 @@ See also: `++last`, Section 2eB
------------------------------------------------------------------------
<h3 id="++like"><code>++like</code></h3>
### `++like`
++ like |* a=_,* :: generic edge
|= b=_`*`[(hair) ~] ::
@ -455,7 +455,7 @@ See also: `++easy`, `++just`/`++jest`, `++knee`, `++mask`, `++shim`,
------------------------------------------------------------------------
<h3 id="++limb"><code>++limb</code></h3>
### `++limb`
++ limb $|(term $%([%& p=axis] [%| p=@ud q=term])) ::
@ -474,7 +474,7 @@ See also: section 2fC-2fD
------------------------------------------------------------------------
<h3 id="++line"><code>++line</code></h3>
### `++line`
++ line ,[p=[%leaf p=odor q=@] q=tile] :: %kelp case
@ -501,7 +501,7 @@ Used in compilation and grammar, section 2fC-2fD
------------------------------------------------------------------------
<h3 id="++list"><code>++list</code></h3>
### `++list`
++ list |* a=_,* :: null-term list
$|(~ [i=a t=(list a)]) ::
@ -520,7 +520,7 @@ See also: `++turn`, `++snag`, section 2bB.
------------------------------------------------------------------------
<h3 id="++lone"><code>++lone</code></h3>
### `++lone`
++ lone |*(a=$+(* *) ,p=a) :: just one thing
@ -530,7 +530,7 @@ Tile generator. `++lone` puts face of `p` on something.
------------------------------------------------------------------------
<h3 id="++mane"><code>++mane</code></h3>
### `++mane`
++ mane $|(@tas [@tas @tas]) :: XML name/space
@ -549,7 +549,7 @@ See also: `++sail` doc, Section 3bD
------------------------------------------------------------------------
<h3 id="++manx"><code>++manx</code></h3>
### `++manx`
++ manx ,[g=marx c=marl] :: XML node
@ -561,7 +561,7 @@ See also: `++sail` doc, Section 3bD
------------------------------------------------------------------------
<h3 id="++marl"><code>++marl</code></h3>
### `++marl`
++ marl (list manx) :: XML node list
@ -573,7 +573,7 @@ See also: `++sail` doc
------------------------------------------------------------------------
<h3 id="++mars"><code>++mars</code></h3>
### `++mars`
++ mars ,[t=[n=%$ a=[i=[n=%$ v=tape] t=~]] c=~] :: XML cdata
@ -583,7 +583,7 @@ See also: `++sail` doc
------------------------------------------------------------------------
<h3 id="++mart"><code>++mart</code></h3>
### `++mart`
++ mart (list ,[n=mane v=tape]) :: XML attributes
@ -596,7 +596,7 @@ See also: `++sail` doc
------------------------------------------------------------------------
<h3 id="++marx"><code>++marx</code></h3>
### `++marx`
++ marx ,[n=mane a=mart] :: XML tag
@ -609,7 +609,7 @@ See also: `++sail` doc
------------------------------------------------------------------------
<h3 id="++metl"><code>++metl</code></h3>
### `++metl`
++ metl ?(%gold %iron %zinc %lead) :: core variance
@ -619,7 +619,7 @@ See also: `++coil`
------------------------------------------------------------------------
<h3 id="++noun"><code>++noun</code></h3>
### `++noun`
++ noun ,* :: any noun
@ -630,7 +630,7 @@ Used nowhere XX
------------------------------------------------------------------------
<h3 id="++null"><code>++null</code></h3>
### `++null`
++ null ,~ :: null, nil, etc
@ -642,7 +642,7 @@ Used nowhere XX
------------------------------------------------------------------------
<h3 id="++odor"><code>++odor</code></h3>
### `++odor`
++ odor ,@ta :: atom format
@ -657,7 +657,7 @@ See also: `++base`, odor reference
------------------------------------------------------------------------
<h3 id="++tarp"><code>++tarp</code></h3>
### `++tarp`
++ tarp ,[d=@ud h=@ud m=@ud s=@ud f=(list ,@ux)] :: parsed time
@ -677,7 +677,7 @@ See also: `++date`, `++yell`/`++yule`, Section 2cH
------------------------------------------------------------------------
<h3 id="++time"><code>++time</code></h3>
### `++time`
++ time ,@da :: galactic time
@ -693,7 +693,7 @@ See also: `++date`, odor reference
------------------------------------------------------------------------
<h3 id="++tree"><code>++tree</code></h3>
### `++tree`
++ tree |* a=_,* :: binary tree
$|(~ [n=a l=(tree a) r=(tree a)]) ::
@ -706,7 +706,7 @@ left/right sub `++tree`s of the same type. Pretty-printed with `{}`.
------------------------------------------------------------------------
<h3 id="++nail"><code>++nail</code></h3>
### `++nail`
++ nail ,[p=hair q=tape] :: parsing input
@ -721,7 +721,7 @@ See also: `++roll`
------------------------------------------------------------------------
<h3 id="++numb"><code>++numb</code></h3>
### `++numb`
++ numb ,@ :: just a number
@ -729,7 +729,7 @@ Used nowhere XX
------------------------------------------------------------------------
<h3 id="++pair"><code>++pair</code></h3>
### `++pair`
++ pair |*([a=$+(* *) b=$+(* *)] ,[p=a q=b]) :: just a pair
@ -740,7 +740,7 @@ Tile generator. Produces a tuple of two of the types passed in.
------------------------------------------------------------------------
<h3 id="++pass"><code>++pass</code></h3>
### `++pass`
++ pass ,@ :: public key
@ -750,7 +750,7 @@ See also: `++acru`, `++crua`, `++crub`
------------------------------------------------------------------------
<h3 id="++path"><code>++path</code></h3>
### `++path`
++ path (list span) :: filesys location
@ -762,7 +762,7 @@ A filesystem path. A `++path` is a list of `++span`, `@ta`. Used in
------------------------------------------------------------------------
<h3 id="++pint"><code>++pint</code></h3>
### `++pint`
++ pint ,[p=[p=@ q=@] q=[p=@ q=@]] :: line/column range
@ -777,7 +777,7 @@ hairs indicating from - to.
------------------------------------------------------------------------
<h3 id="++pole"><code>++pole</code></h3>
### `++pole`
++ pole |* a=_,* :: nameless list
$|(~ [a (pole a)]) ::
@ -790,7 +790,7 @@ without the `i=` and `t=`.
------------------------------------------------------------------------
<h3 id="++port"><code>++port</code></h3>
### `++port`
++ port $: p=axis ::
$= q ::
@ -808,7 +808,7 @@ Type and location of core-shaped thing? XX Compiler Internals
------------------------------------------------------------------------
<h3 id="++post"><code>++post</code></h3>
### `++post`
++ post $: p=axis ::
$= q ::
@ -827,7 +827,7 @@ Type and location of possibly core-shaped thing? XX Compiler Internals
------------------------------------------------------------------------
<h3 id="++prop"><code>++prop</code></h3>
### `++prop`
++ prop $: p=axis ::
$= q ::
@ -843,7 +843,7 @@ Verified core-shaped thing? XX Compiler Internals
------------------------------------------------------------------------
<h3 id="++qual"><code>++qual</code></h3>
### `++qual`
++ qual |* [a=$+(* *) b=$+(* *) c=$+(* *) d=$+(* *)] :: just a quadruple
,[p=a q=b r=c s=d] ::
@ -855,7 +855,7 @@ Tile generator. A `++qual` is a tuple of four of the types passed in..
------------------------------------------------------------------------
<h3 id="++rege"><code>++rege</code></h3>
### `++rege`
++ rege $| ?(%dote %ende %sart %empt %boun %bout) :: parsed regex
$% [%lite p=char] :: literal
@ -885,7 +885,7 @@ See also: `++rexp`, `++repg`, `++pars`
------------------------------------------------------------------------
<h3 id="++ring"><code>++ring</code></h3>
### `++ring`
++ ring ,@ :: private key
@ -895,7 +895,7 @@ See also: `++acru`, `++crua`, `++crub`.
------------------------------------------------------------------------
<h3 id="++rule"><code>++rule</code></h3>
### `++rule`
++ rule |=(tub=nail `edge`[p.tub ~ ~ tub]) :: parsing rule
@ -916,7 +916,7 @@ See also: `++cold`, Section 2eC
------------------------------------------------------------------------
<h3 id="++span"><code>++span</code></h3>
### `++span`
++ span ,@ta :: text-atom (ASCII)
@ -941,7 +941,7 @@ besides numbers and lowercase letters are permitted.
------------------------------------------------------------------------
<h3 id="++spot"><code>++spot</code></h3>
### `++spot`
++ spot ,[p=path q=pint] :: range in file
@ -957,7 +957,7 @@ See also: `++pint`
------------------------------------------------------------------------
<h3 id="++tang"><code>++tang</code></h3>
### `++tang`
++ tang (list tank) :: general error
@ -965,7 +965,7 @@ Unused XX
------------------------------------------------------------------------
<h3 id="++tank"><code>++tank</code></h3>
### `++tank`
++ tank $% [%leaf p=tape] :: printing formats
$: %palm ::
@ -996,7 +996,7 @@ list of `++tank` delimted by the strings in `p`.
------------------------------------------------------------------------
<h3 id="++tape"><code>++tape</code></h3>
### `++tape`
++ tape (list char) :: like a string
@ -1010,7 +1010,7 @@ list of chars.
------------------------------------------------------------------------
<h3 id="++term"><code>++term</code></h3>
### `++term`
++ term ,@tas :: Hoon ASCII subset
@ -1030,7 +1030,7 @@ always preceded by `%`. This means a term is always cubical. The empty
------------------------------------------------------------------------
<h3 id="++tiki"><code>++tiki</code></h3>
### `++tiki`
++ tiki :: test case
$% [& p=(unit term) q=wing] :: simple wing
@ -1062,13 +1062,13 @@ A `++wing` or `++twig`.
------------------------------------------------------------------------
<h3 id="++tile"><code>++tile</code></h3>
### `++tile`
See the Tile section of the Hoon Reference.
------------------------------------------------------------------------
<h3 id="++toga"><code>++toga</code></h3>
### `++toga`
++ toga :: face control
$| p=term :: two togas
@ -1104,7 +1104,7 @@ using `^=`.
------------------------------------------------------------------------
<h3 id="++trap"><code>++trap</code></h3>
### `++trap`
++ trap ,_|.(_*) :: makes perfect sense
@ -1121,7 +1121,7 @@ See also: `|.`
------------------------------------------------------------------------
<h3 id="++trel"><code>++trel</code></h3>
### `++trel`
++ trel |* [a=$+(* *) b=$+(* *) c=$+(* *)] :: just a triple
,[p=a q=b r=c] ::
@ -1133,7 +1133,7 @@ Tile generator. `++trel` is a tuple of three of the types passed in.
------------------------------------------------------------------------
<h3 id="++tuna"><code>++tuna</code></h3>
### `++tuna`
++ tuna :: tagflow
$% [%a p=twig] :: plain text
@ -1154,13 +1154,13 @@ See also: `++sail`
------------------------------------------------------------------------
<h3 id="++twig"><code>++twig</code></h3>
### `++twig`
See Twig section of Hoon reference
------------------------------------------------------------------------
<h3 id="++tine"><code>++tine</code></h3>
### `++tine`
++ tine (list ,[p=tile q=twig]) ::
@ -1186,7 +1186,7 @@ See also: `++twig`
------------------------------------------------------------------------
<h3 id="++tusk"><code>++tusk</code></h3>
### `++tusk`
++ tusk (list twig) ::
@ -1202,7 +1202,7 @@ See also: `++twig`
------------------------------------------------------------------------
<h3 id="++tyre"><code>++tyre</code></h3>
### `++tyre`
++ tyre (list ,[p=term q=twig]) ::
@ -1212,7 +1212,7 @@ See also: `++twig`
------------------------------------------------------------------------
<h3 id="++tyke"><code>++tyke</code></h3>
### `++tyke`
++ tyke (list (unit twig)) ::
@ -1227,7 +1227,7 @@ where the `=` are inferred from your current path.
------------------------------------------------------------------------
<h3 id="++tram"><code>++tram</code></h3>
### `++tram`
++ tram (list ,[p=wing q=twig]) ::
@ -1246,7 +1246,7 @@ See also: `++twig`
------------------------------------------------------------------------
<h3 id="++nock"><code>++nock</code></h3>
### `++nock`
++ nock $& [p=nock q=nock] :: autocons
$% [%0 p=@] :: axis select
@ -1272,7 +1272,7 @@ See Nock doc
------------------------------------------------------------------------
<h3 id="++tone"><code>++tone</code></h3>
### `++tone`
++ tone $% [%0 p=*] :: success
[%1 p=(list)] :: blocks
@ -1314,7 +1314,7 @@ trace is not yet rendered.
------------------------------------------------------------------------
<h3 id="++toon"><code>++toon</code></h3>
### `++toon`
++ toon $% [%0 p=*] :: success
[%1 p=(list)] :: blocks
@ -1337,7 +1337,7 @@ requests blocked on (`%1`), or failure with stack trace (`%2`).
------------------------------------------------------------------------
<h3 id="++tune"><code>++tune</code></h3>
### `++tune`
++ tune $% [%0 p=vase] ::
[%1 p=(list)] ::
@ -1350,7 +1350,7 @@ Probably typed `tone`?
------------------------------------------------------------------------
<h3 id="++twin"><code>++twin</code></h3>
### `++twin`
++ twin ,[p=term q=wing r=axis s=type] :: alias info
@ -1368,13 +1368,13 @@ Aliasing. Used in `%bull` `++type` to typecheck aliased faces.
------------------------------------------------------------------------
<h3 id="++type"><code>++type</code></h3>
### `++type`
See Type section of Hoon reference
------------------------------------------------------------------------
<h3 id="++typo"><code>++typo</code></h3>
### `++typo`
++ typo type :: old type
@ -1385,7 +1385,7 @@ See also: `++seem`, `++vise`, `++type`
------------------------------------------------------------------------
<h3 id="++udal"><code>++udal</code></h3>
### `++udal`
++ udal :: atomic change (%b)
$: p=@ud :: blockwidth
@ -1396,7 +1396,7 @@ XX Unused
------------------------------------------------------------------------
<h3 id="++udon"><code>++udon</code></h3>
### `++udon`
++ udon :: abstract delta
$: p=umph :: preprocessor
@ -1412,7 +1412,7 @@ See `%clay` doc
------------------------------------------------------------------------
<h3 id="++umph"><code>++umph</code></h3>
### `++umph`
++ umph :: change filter
$| $? %a :: no filter
@ -1426,7 +1426,7 @@ See `%clay` doc
------------------------------------------------------------------------
<h3 id="++unce"><code>++unce</code></h3>
### `++unce`
++ unce |* a=_,* :: change part
$% [%& p=@ud] :: skip[copy]
@ -1437,7 +1437,7 @@ See `%clay` doc
------------------------------------------------------------------------
<h3 id="++unit"><code>++unit</code></h3>
### `++unit`
++ unit |* a=_,* :: maybe
$|(~ [~ u=a]) ::
@ -1455,7 +1455,7 @@ See also: `++bind`, Section 2bA
------------------------------------------------------------------------
<h3 id="++upas"><code>++upas</code></h3>
### `++upas`
++ upas :: tree change (%d)
$& [p=upas q=upas] :: cell
@ -1468,7 +1468,7 @@ See `%clay` doc
------------------------------------------------------------------------
<h3 id="++urge"><code>++urge</code></h3>
### `++urge`
++ urge |*(a=_,* (list (unce a))) :: list change
@ -1476,7 +1476,7 @@ See `%clay` doc
------------------------------------------------------------------------
<h3 id="++vase"><code>++vase</code></h3>
### `++vase`
++ vase ,[p=type q=*] :: type-value pair
@ -1490,7 +1490,7 @@ See `%arvo` doc
------------------------------------------------------------------------
<h3 id="++vise"><code>++vise</code></h3>
### `++vise`
++ vise ,[p=typo q=*] :: old vase
@ -1500,7 +1500,7 @@ See `++typo`, `++seer`
------------------------------------------------------------------------
<h3 id="++wall"><code>++wall</code></h3>
### `++wall`
++ wall (list tape) :: text lines (no \n)
@ -1523,7 +1523,7 @@ See also: `++wash`
------------------------------------------------------------------------
<h3 id="++wain"><code>++wain</code></h3>
### `++wain`
++ wain (list cord) :: text lines (no \n)
@ -1556,7 +1556,7 @@ See also: `++lore`, `++role`
------------------------------------------------------------------------
<h3 id="++wing"><code>++wing</code></h3>
### `++wing`
++ wing (list limb) ::
@ -1572,7 +1572,7 @@ See also: `++twig`
------------------------------------------------------------------------
<h3 id="++wine"><code>++wine</code></h3>
### `++wine`
++ wine $| ?(%noun %path %tank %void %wall %wool %yarn)
$% [%atom p=term] ::
@ -1654,7 +1654,7 @@ See also: `++calf`
------------------------------------------------------------------------
<h3 id="++wonk"><code>++wonk</code></h3>
### `++wonk`
++ wonk |*(veq=edge ?~(q.veq !! p.u.q.veq)) ::
:: ::
@ -1682,7 +1682,7 @@ See also: `++edge`, Section 2eC
------------------------------------------------------------------------
<h3 id="++map"><code>++map</code></h3>
### `++map`
++ map |* [a=_,* b=_,*] :: associative tree
$|(~ [n=[p=a q=b] l=(map a b) r=(map a b)]) ::
@ -1700,7 +1700,7 @@ See also: `++by`
------------------------------------------------------------------------
<h3 id="++qeu"><code>++qeu</code></h3>
### `++qeu`
++ qeu |* a=_,* :: queue
$|(~ [n=a l=(qeu a) r=(qeu a)]) ::
@ -1717,7 +1717,7 @@ See also: `++to`
------------------------------------------------------------------------
<h3 id="++set"><code>++set</code></h3>
### `++set`
++ set |* a=_,* :: set
$|(~ [n=a l=(set a) r=(set a)]) ::
@ -1736,7 +1736,7 @@ See also: `++in`
------------------------------------------------------------------------
<h3 id="++jar"><code>++jar</code></h3>
### `++jar`
++ jar |*([a=_,* b=_,*] (map a (list b))) :: map of lists
@ -1760,7 +1760,7 @@ See also: `++ja`, `++by`, `++map`, `++list`
------------------------------------------------------------------------
<h3 id="++jug"><code>++jug</code></h3>
### `++jug`
++ jug |*([a=_,* b=_,*] (map a (set b))) :: map of sets

View File

@ -1,7 +1,7 @@
chapter 2a, basic unsigned math
===============================
<h3 id="++add"><code>++add</code></h3>
### `++add`
Add
@ -28,7 +28,7 @@ Produces the sum of `a` and `b` as an atom.
------------------------------------------------------------------------
<h3 id="++cap"><code>++cap</code></h3>
### `++cap`
Tree head
@ -59,7 +59,7 @@ within the tail.
------------------------------------------------------------------------
<h3 id="++dec"><code>++dec</code></h3>
### `++dec`
Decrement
@ -86,7 +86,7 @@ Produces `a-1` as an atom.
------------------------------------------------------------------------
<h3 id="++div"><code>++div</code></h3>
### `++div`
Divide
@ -117,7 +117,7 @@ Computes `a` divided by `b`, producing an atom.
------------------------------------------------------------------------
<h3 id="++fac"><code>++fac</code></h3>
### `++fac`
Factorial
@ -142,7 +142,7 @@ Computes the factorial of `a`, producing an atom.
------------------------------------------------------------------------
<h3 id="++gte"><code>++gte</code></h3>
### `++gte`
Greater-than/equal
@ -168,7 +168,7 @@ Tests whether `a` is greater than a number `b`, producing a loobean.
------------------------------------------------------------------------
<h3 id="++gth"><code>++gth</code></h3>
### `++gth`
Greater-than
@ -192,7 +192,7 @@ Tests whether `a` is greater than `b`, producing a loobean.
------------------------------------------------------------------------
<h3 id="++lte"><code>++lte</code></h3>
### `++lte`
Less-than/equal
@ -219,7 +219,7 @@ Tests whether `a` is less than or equal to `b`, producing a loobean.
------------------------------------------------------------------------
<h3 id="++lth"><code>++lth</code></h3>
### `++lth`
Less-than
@ -252,7 +252,7 @@ Tests whether `a` is less than `b`, producing a loobean.
------------------------------------------------------------------------
<h3 id="++mas"><code>++mas</code></h3>
### `++mas`
Axis within head/tail
@ -287,7 +287,7 @@ Computes the axis of `a` within the head or the tail, producing an atom.
~zod/try=> (mas 1)
! exit
<h3 id="++max"><code>++max</code></h3>
### `++max`
Maximum
@ -314,7 +314,7 @@ Computes the maximum of `a` and `b`, producing an atom.
------------------------------------------------------------------------
<h3 id="++min"><code>++min</code></h3>
### `++min`
Minimum
@ -341,7 +341,7 @@ Computes the minimum of `a` and `b`, producing an atom.
------------------------------------------------------------------------
<h3 id="++mod"><code>++mod</code></h3>
### `++mod`
Modulus
@ -361,7 +361,7 @@ Computes the remainder of dividing `a` by `b`, producing an atom.
------------------------------------------------------------------------
<h3 id="++mul"><code>++mul</code></h3>
### `++mul`
Multiply
@ -388,7 +388,7 @@ Multiplies `a` by `b`, producing an atom.
------------------------------------------------------------------------
<h3 id="++peg"><code>++peg</code></h3>
### `++peg`
Axis within axis
@ -419,7 +419,7 @@ Computes the axis of `b` within axis `a`, producing an atom.
------------------------------------------------------------------------
<h3 id="++sub"><code>++sub</code></h3>
### `++sub`
Subtract

View File

@ -4,7 +4,7 @@ chapter 2b, basic containers
Section 2bA, units
------------------
<h3 id="++biff"><code>++biff</code></h3>
### `++biff`
Unit as argument
@ -27,7 +27,7 @@ Applies a gate that produces a unit, `b`, to the value (`u.a`) of a unit
------------------------------------------------------------------------
<h3 id="++bind"><code>++bind</code></h3>
### `++bind`
Bind
@ -51,7 +51,7 @@ unit.
------------------------------------------------------------------------
<h3 id="++bond"><code>++bond</code></h3>
### `++bond`
Replace null
@ -77,7 +77,7 @@ unit is not empty, then the original unit is produced.
------------------------------------------------------------------------
<h3 id="++both"><code>++both</code></h3>
### `++both`
Group unit values
@ -101,7 +101,7 @@ Produces a unit whose value is a cell of the values of two input units
------------------------------------------------------------------------
<h3 id="++clap"><code>++clap</code></h3>
### `++clap`
Apply gate to two units
@ -133,7 +133,7 @@ two units `a` and `b`.
------------------------------------------------------------------------
<h3 id="++drop"><code>++drop</code></h3>
### `++drop`
Unit list
@ -155,7 +155,7 @@ Produces a [list]() of the value from a unit `a`.
------------------------------------------------------------------------
<h3 id="++fall"><code>++fall</code></h3>
### `++fall`
Default unit
@ -177,7 +177,7 @@ null.
------------------------------------------------------------------------
<h3 id="++lift"><code>++lift</code></h3>
### `++lift`
Fmap
@ -201,7 +201,7 @@ produces a unit value.
------------------------------------------------------------------------
<h3 id="++mate"><code>++mate</code></h3>
### `++mate`
Choose
@ -237,7 +237,7 @@ produces that value. If the assertion fails, `++mate` crashes with
------------------------------------------------------------------------
<h3 id="++need"><code>++need</code></h3>
### `++need`
Unwrap
@ -262,7 +262,7 @@ Retrieve the value from a unit and crash if the unit is null.
------------------------------------------------------------------------
<h3 id="++some"><code>++some</code></h3>
### `++some`
Unify
@ -286,7 +286,7 @@ section 2bB, lists
Reverse
<h3 id="++flop"><code>++flop</code></h3>
### `++flop`
++ flop :: reverse
~/ %flop
@ -306,7 +306,7 @@ Produces the list `a` in reverse order.
~zod/try=> (flop a)
~[3 2 1]
<h3 id="++homo"><code>++homo</code></h3>
### `++homo`
Homogenize
@ -332,7 +332,7 @@ list `a`.
~zod/try=> (homo a)
~[1 2 3]
<h3 id="++limo"><code>++limo</code></h3>
### `++limo`
List Constructor
@ -350,7 +350,7 @@ Turns a null-terminated tuple into a list.
~zod/try=> (limo [1 2 3 ~])
[i=1 t=[i=2 t=[i=3 t=~]]]
<h3 id="++lent"><code>++lent</code></h3>
### `++lent`
List length
@ -374,7 +374,7 @@ Produces the length of any list `a` as an atom.
------------------------------------------------------------------------
<h3 id="++levy"><code>++levy</code></h3>
### `++levy`
"and" to list
@ -402,7 +402,7 @@ passed to gate `b`.
------------------------------------------------------------------------
<h3 id="++lien"><code>++lien</code></h3>
### `++lien`
"or" to list
@ -430,7 +430,7 @@ passed to gate `b`.
------------------------------------------------------------------------
<h3 id="++murn"><code>++murn</code></h3>
### `++murn`
Maybe transform
@ -454,7 +454,7 @@ Produces a new list with all the results that do not produce `~`.
~zod/try=> (murn (limo [0 1 2 3 ~]) a)
[i=12 t=[i=13 t=~]]
<h3 id="++reap"><code>++reap</code></h3>
### `++reap`
Replicate
@ -479,7 +479,7 @@ Replicate: produces a list containing `a` copies of `b`.
------------------------------------------------------------------------
<h3 id="++reel"><code>++reel</code></h3>
### `++reel`
Right fold
@ -511,7 +511,7 @@ the final value of the accumulator.
------------------------------------------------------------------------
<h3 id="++roll"><code>++roll</code></h3>
### `++roll`
Left fold
@ -543,7 +543,7 @@ producing the final value of the accumulator.
------------------------------------------------------------------------
<h3 id="++skid"><code>++skid</code></h3>
### `++skid`
Separate
@ -567,7 +567,7 @@ true when slammed to gate `b` and those who produce `%.n`.
------------------------------------------------------------------------
<h3 id="++skim"><code>++skim</code></h3>
### `++skim`
Suffix
@ -593,7 +593,7 @@ producing a list of all of the members that produce `%.y`. Inverse of
------------------------------------------------------------------------
<h3 id="++skip"><code>++skip</code></h3>
### `++skip`
Except
@ -619,7 +619,7 @@ producing a list of all of the members that produce `%.n`. Inverse of
------------------------------------------------------------------------
<h3 id="++scag"><code>++scag</code></h3>
### `++scag`
Prefix
@ -644,7 +644,7 @@ the front of the list.
------------------------------------------------------------------------
<h3 id="++slag"><code>++slag</code></h3>
### `++slag`
Suffix
@ -670,7 +670,7 @@ Accepts an atom `a` and list `b`, producing the remaining elements from
------------------------------------------------------------------------
<h3 id="++snag"><code>++snag</code></h3>
### `++snag`
Index
@ -697,7 +697,7 @@ of `a`and failing if the list is null. Lists are 0-indexed.
------------------------------------------------------------------------
<h3 id="++sort"><code>++sort</code></h3>
### `++sort`
Quicksort
@ -726,7 +726,7 @@ sorted according to `b`.
------------------------------------------------------------------------
<h3 id="++swag"><code>++swag</code></h3>
### `++swag`
Infix
@ -748,7 +748,7 @@ inclusive index `a`, producing `b` number of characters.
------------------------------------------------------------------------
<h3 id="++turn"><code>++turn</code></h3>
### `++turn`
Gate to list
@ -774,7 +774,7 @@ to each element of the original list.
------------------------------------------------------------------------
<h3 id="++weld"><code>++weld</code></h3>
### `++weld`
Concatenate
@ -797,7 +797,7 @@ Concatenate two lists `a` and `b`.
------------------------------------------------------------------------
<h3 id="++welp"><code>++welp</code></h3>
### `++welp`
Perfect weld
@ -827,7 +827,7 @@ to homogenization.
------------------------------------------------------------------------
<h3 id="++wild"><code>++wild</code></h3>
### `++wild`
XXDELETE
@ -873,7 +873,7 @@ individually.
------------------------------------------------------------------------
<h3 id="++zing"><code>++zing</code></h3>
### `++zing`
Cons

View File

@ -4,7 +4,7 @@ chapter 2c, simple noun surgery
section 2cA, bit surgery
------------------------
<h3 id="++bex"><code>++bex</code></h3>
### `++bex`
Binary exponent
@ -28,7 +28,7 @@ Computes the result of `2^a`, producing an atom.
------------------------------------------------------------------------
<h3 id="++xeb"><code>++xeb</code></h3>
### `++xeb`
Binary logarithm
@ -57,7 +57,7 @@ Computes the base-2 logarithm of `a`, producing an atom.
------------------------------------------------------------------------
<h3 id="++can"><code>++can</code></h3>
### `++can`
Assemble
@ -91,7 +91,7 @@ value.
------------------------------------------------------------------------
<h3 id="++cat"><code>++cat</code></h3>
### `++cat`
Concatenate
@ -130,7 +130,7 @@ atom.
------------------------------------------------------------------------
<h3 id="++cut"><code>++cut</code></h3>
### `++cut`
Slice
@ -167,7 +167,7 @@ Produces an atom.
------------------------------------------------------------------------
<h3 id="++end"><code>++end</code></h3>
### `++end`
Tail
@ -203,7 +203,7 @@ Produces an atom by taking the last `b` blocks of size `a` from `c`.
------------------------------------------------------------------------
<h3 id="++fil"><code>++fil</code></h3>
### `++fil`
Fill bloqstream
@ -235,7 +235,7 @@ Produces an atom by repeating `c` for `b` blocks of size `a`.
------------------------------------------------------------------------
<h3 id="++lsh"><code>++lsh</code></h3>
### `++lsh`
Left-shift
@ -267,7 +267,7 @@ Produces an atom by left-shifting `c` by `b` blocks of size `a`.
------------------------------------------------------------------------
<h3 id="++met"><code>++met</code></h3>
### `++met`
Measure
@ -299,7 +299,7 @@ Computes the number of blocks of size `a` in `b`, producing an atom.
------------------------------------------------------------------------
<h3 id="++rap"><code>++rap</code></h3>
### `++rap`
Assemble non-zero
@ -327,7 +327,7 @@ Concatenate a list of atoms `b` using blocksize `a`, producing an atom.
------------------------------------------------------------------------
<h3 id="++rep"><code>++rep</code></h3>
### `++rep`
Assemble single
@ -363,7 +363,7 @@ Produces an atom by assembling a list of atoms `b` using block size `a`.
------------------------------------------------------------------------
<h3 id="++rip"><code>++rip</code></h3>
### `++rip`
Disassemble
@ -399,7 +399,7 @@ Produces a list of atoms from the bits of `b` using block size `a`.
------------------------------------------------------------------------
<h3 id="++rsh"><code>++rsh</code></h3>
### `++rsh`
Right-shift
@ -441,7 +441,7 @@ Right-shifts `c` by `b` blocks of size `a`, producing an atom.
------------------------------------------------------------------------
<h3 id="++swap"><code>++swap</code></h3>
### `++swap`
Reverse block order
@ -470,7 +470,7 @@ reversing the block order of `b` using block size `a`.
section 2cB, bit logic
----------------------
<h3 id="++con"><code>++con</code></h3>
### `++con`
Binary OR
@ -513,7 +513,7 @@ atom.
------------------------------------------------------------------------
<h3 id="++dis"><code>++dis</code></h3>
### `++dis`
Binary AND
@ -560,7 +560,7 @@ atom.
------------------------------------------------------------------------
<h3 id="++mix"><code>++mix</code></h3>
### `++mix`
Binary XOR
@ -599,7 +599,7 @@ Produces the bit-wise logical XOR of `a` and `b`, producing an atom.
------------------------------------------------------------------------
<h3 id="++not"><code>++not</code></h3>
### `++not`
Binary NOT
@ -633,7 +633,7 @@ of `c`.
section 2cC, noun orders
------------------------
<h3 id="++aor"><code>++aor</code></h3>
### `++aor`
Alphabetic order
@ -680,7 +680,7 @@ loobean.
------------------------------------------------------------------------
<h3 id="++dor"><code>++dor</code></h3>
### `++dor`
Numeric order
@ -719,7 +719,7 @@ loobean.
------------------------------------------------------------------------
<h3 id="++gor"><code>++gor</code></h3>
### `++gor`
Hash order
@ -758,7 +758,7 @@ XX revisit
------------------------------------------------------------------------
<h3 id="++hor"><code>++hor</code></h3>
### `++hor`
Hash order
@ -789,7 +789,7 @@ Recursive hash comparator gate.
------------------------------------------------------------------------
<h3 id="++vor"><code>++vor</code></h3>
### `++vor`
++ vor :: v-order
~/ %vor
@ -814,7 +814,7 @@ Double hash comparator gate.
section 2cD, insecure hashing
-----------------------------
<h3 id="++fnv"><code>++fnv</code></h3>
### `++fnv`
++ fnv |=(a=@ (end 5 1 (mul 16.777.619 a))) :: FNV scrambler
@ -833,7 +833,7 @@ of size 5 off the product's end, producing atom.
------------------------------------------------------------------------
<h3 id="++mum"><code>++mum</code></h3>
### `++mum`
++ mum :: mug with murmur3
~/ %mum
@ -889,7 +889,7 @@ XX document
~zod/try=> (mum ~[1 2 3 4 5])
1.517.902.092
<h3 id="++mug"><code>++mug</code></h3>
### `++mug`
++ mug :: 31bit nonzero FNV1a
~/ %mug
@ -929,7 +929,7 @@ algorithm, producing an atom.
section 2cE, phonetic base
--------------------------
<h3 id="++po"><code>++po</code></h3>
### `++po`
++ po
~/ %po
@ -975,7 +975,7 @@ contained in this section.
------------------------------------------------------------------------
<h3 id="++ind"><code>++ind</code></h3>
### `++ind`
Parse prefix
@ -998,7 +998,7 @@ Produces the byte of the right-hand syllable `a`.
------------------------------------------------------------------------
<h3 id="++ins"><code>++ins</code></h3>
### `++ins`
Parse suffix
@ -1023,7 +1023,7 @@ Produces the byte of the left-hand phonetic syllable `b`.
------------------------------------------------------------------------
<h3 id="++tod"><code>++tod</code></h3>
### `++tod`
Fetch prefix
@ -1050,7 +1050,7 @@ atom.
------------------------------------------------------------------------
<h3 id="++tos"><code>++tos</code></h3>
### `++tos`
Fetch suffix
@ -1074,7 +1074,7 @@ atom.
section 2cF, signed and modular ints
------------------------------------
<h3 id="++si"><code>++si</code></h3>
### `++si`
++ si !: :: signed integer
|%
@ -1083,7 +1083,7 @@ Container for the signed integer functions.
------------------------------------------------------------------------
<h3 id="++abs"><code>++abs</code></h3>
### `++abs`
++ abs |=(a=@s (add (end 0 1 a) (rsh 0 1 a))) :: absolute value
@ -1100,7 +1100,7 @@ Produces the absolute value of a signed integer.
------------------------------------------------------------------------
<h3 id="++dif"><code>++dif</code></h3>
### `++dif`
++ dif |= [a=@s b=@s] :: subtraction
(sum a (new !(syn b) (abs b)))
@ -1122,7 +1122,7 @@ Produces the difference between two signed integers `b` and `c`.
------------------------------------------------------------------------
<h3 id="++dul"><code>++dul</code></h3>
### `++dul`
++ dul |= [a=@s b=@] :: modulus
=+(c=(old a) ?:(-.c (mod +.c b) (sub b +.c)))
@ -1146,7 +1146,7 @@ Produces the modulus of two signed integers.
------------------------------------------------------------------------
<h3 id="++fra"><code>++fra</code></h3>
### `++fra`
++ fra |= [a=@s b=@s] :: divide
(new =(0 (mix (syn a) (syn b))) (div (abs a) (abs b)))
@ -1164,7 +1164,7 @@ Produces the quotient of two signed integers.
------------------------------------------------------------------------
<h3 id="++new"><code>++new</code></h3>
### `++new`
++ new |= [a=? b=@] :: [sign value] to @s
`@s`?:(a (mul 2 b) ?:(=(0 b) 0 +((mul 2 (dec b)))))
@ -1184,7 +1184,7 @@ Produces a signed integer from a loobean sign value `a` and an atom `b`.
------------------------------------------------------------------------
<h3 id="++old"><code>++old</code></h3>
### `++old`
++ old |=(a=@s [(syn a) (abs a)]) :: [sign value]
@ -1206,7 +1206,7 @@ Produces the cell `[sign value]` representations of a signed integer.
------------------------------------------------------------------------
<h3 id="++pro"><code>++pro</code></h3>
### `++pro`
++ pro |= [a=@s b=@s] :: multiplication
(new =(0 (mix (syn a) (syn b))) (mul (abs a) (abs b)))
@ -1228,7 +1228,7 @@ Produces the product of two signed integers.
------------------------------------------------------------------------
<h3 id="++rem"><code>++rem</code></h3>
### `++rem`
++ rem |=([a=@s b=@s] (dif a (pro b (fra a b)))) :: remainder
@ -1251,7 +1251,7 @@ Produces the remainder from a division of two signed integers.
------------------------------------------------------------------------
<h3 id="++sum"><code>++sum</code></h3>
### `++sum`
++ sum |= [a=@s b=@s] :: addition
~| %si-sum
@ -1285,7 +1285,7 @@ Sum two signed integers.
------------------------------------------------------------------------
<h3 id="++sun"><code>++sun</code></h3>
### `++sun`
++ sun |=(a=@u (mul 2 a)) :: @u to @s
@ -1309,7 +1309,7 @@ inferred as an unsigned integer in the type system.
------------------------------------------------------------------------
<h3 id="++syn"><code>++syn</code></h3>
### `++syn`
++ syn |=(a=@s =(0 (end 0 1 a))) :: sign test
@ -1326,7 +1326,7 @@ Produce the sign of a signed integer, `&` being posiitve, `|` negative.
------------------------------------------------------------------------
<h3 id="++cmp"><code>++cmp</code></h3>
### `++cmp`
++ cmp |= [a=@s b=@s] :: compare
^- @s
@ -1359,7 +1359,7 @@ Compare two signed integers.
~zod/try=> (cmp:si -10 --7)
-1
<h3 id="++dif"><code>++dif</code></h3>
### `++dif`
++ dif |=([b=@ c=@] (sit (sub (add out (sit b)) (sit c))))
@ -1389,7 +1389,7 @@ representation.
------------------------------------------------------------------------
<h3 id="++inv"><code>++inv</code></h3>
### `++inv`
++ inv |=(b=@ (sub (dec out) (sit b)))
@ -1412,7 +1412,7 @@ Inverts the order of the modular field.
------------------------------------------------------------------------
<h3 id="++net"><code>++net</code></h3>
### `++net`
++ net |= b=@ ^- @
=> .(b (sit b))
@ -1476,7 +1476,7 @@ Reverse bytes within block.
------------------------------------------------------------------------
<h3 id="++out"><code>++out</code></h3>
### `++out`
++ out (bex (bex a))
@ -1503,7 +1503,7 @@ The maximum integer value that the current block can store.
------------------------------------------------------------------------
<h3 id="++rol"><code>++rol</code></h3>
### `++rol`
++ rol |= [b=bloq c=@ d=@] ^- @ :: roll left
=+ e=(sit d)
@ -1532,7 +1532,7 @@ Roll `d` to the left by `c` `b`-sized blocks.
------------------------------------------------------------------------
<h3 id="++ror"><code>++ror</code></h3>
### `++ror`
++ ror |= [b=bloq c=@ d=@] ^- @ :: roll right
=+ e=(sit d)
@ -1563,7 +1563,7 @@ Roll `d` to the right by `c` `b`-sized blocks.
------------------------------------------------------------------------
<h3 id="++sum"><code>++sum</code></h3>
### `++sum`
++ sum |=([b=@ c=@] (sit (add b c))) :: wrapping add
@ -1588,7 +1588,7 @@ Sum two numbers in this modular field.
~zod/try=> (~(sum fe 4) 10.000 100.000)
44.464
<h3 id="++sit"><code>++sit</code></h3>
### `++sit`
++ sit |=(b=@ (end a 1 b)) :: enforce modulo
@ -1635,7 +1635,7 @@ format. We use this for many of our examples.
~zod/try=> -<-
~2014.8.4..19.39.59..9288
<h3 id="++year"><code>++year</code></h3>
### `++year`
++ year :: date to @d
|= det=date
@ -1657,7 +1657,7 @@ its `@d`representation.
------------------------------------------------------------------------
<h3 id="++yore"><code>++yore</code></h3>
### `++yore`
++ yore :: @d to date
|= now=@d
@ -1678,7 +1678,7 @@ Produces a `++date` from a `@d`
~zod/try=> (yore -<-)
[[a=%.y y=2.014] m=8 t=[d=4 h=20 m=28 s=53 f=~[0x7b82]]]
<h3 id="++yell"><code>++yell</code></h3>
### `++yell`
++ yell :: tarp from @d
|= now=@d
@ -1712,7 +1712,7 @@ Produce a parsed daily time format from an atomic date.
------------------------------------------------------------------------
<h3 id="++yule"><code>++yule</code></h3>
### `++yule`
++ yule :: time atom
|= rip=tarp
@ -1752,7 +1752,7 @@ Accept a [`++tarp`](/doc/hoon/library/1#++tarp), a parsed daily time, and produc
------------------------------------------------------------------------
<h3 id="++yall"><code>++yall</code></h3>
### `++yall`
++ yall :: day # to day of year
|= day=@ud
@ -1792,7 +1792,7 @@ day from a number of days from the beginning of time.
------------------------------------------------------------------------
<h3 id="++yawn"><code>++yawn</code></h3>
### `++yawn`
++ yawn :: days since Jesus
|= [yer=@ud mot=@ud day=@ud]
@ -1837,7 +1837,7 @@ tuple `[yer=@ud mot=@ud day=@ud]`.
------------------------------------------------------------------------
<h3 id="++yelp"><code>++yelp</code></h3>
### `++yelp`
++ yelp :: leap year
|= yer=@ud ^- ?
@ -1859,14 +1859,14 @@ loobean.
------------------------------------------------------------------------
<h3 id="++yo"><code>++yo</code></h3>
### `++yo`
++ yo :: time constants
Useful constants for interacting with earth time.
<h3 id="++cet"><code>++cet</code></h3>
### `++cet`
|% ++ cet 36.524 :: (add 24 (mul 100 365))
@ -1883,7 +1883,7 @@ days from leap years in a century (24).
------------------------------------------------------------------------
<h3 id="++day"><code>++day</code></h3>
### `++day`
++ day 86.400 :: (mul 24 hor)
@ -1896,7 +1896,7 @@ Number of seconds in a day.
------------------------------------------------------------------------
<h3 id="++era"><code>++era</code></h3>
### `++era`
++ era 146.097 :: (add 1 (mul 4 cet))
@ -1904,7 +1904,7 @@ XX Revisit
------------------------------------------------------------------------
<h3 id="++hor"><code>++hor</code></h3>
### `++hor`
++ hor 3.600 :: (mul 60 mit)
@ -1918,7 +1918,7 @@ seconds in a minute by the minutes in an hour.
------------------------------------------------------------------------
<h3 id="++jes"><code>++jes</code></h3>
### `++jes`
++ jes 106.751.991.084.417 :: (mul 730.692.561 era)
@ -1929,7 +1929,7 @@ XX Revisit
------------------------------------------------------------------------
<h3 id="++mit"><code>++mit</code></h3>
### `++mit`
++ mit 60
@ -1940,7 +1940,7 @@ The number of seconds in a minute.
------------------------------------------------------------------------
<h3 id="++moh"><code>++moh</code></h3>
### `++moh`
++ moh `(list ,@ud)`[31 28 31 30 31 30 31 31 30 31 30 31 ~]
@ -1955,7 +1955,7 @@ month at the year at that index.
------------------------------------------------------------------------
<h3 id="++moy"><code>++moy</code></h3>
### `++moy`
++ moy `(list ,@ud)`[31 29 31 30 31 30 31 31 30 31 30 31 ~]
@ -1970,7 +1970,7 @@ month at the leap-year at that index.
------------------------------------------------------------------------
<h3 id="++qad"><code>++qad</code></h3>
### `++qad`
++ qad 126.144.001 :: (add 1 (mul 4 yer))
@ -1982,7 +1982,7 @@ number of seconds in four years.
------------------------------------------------------------------------
<h3 id="++yer"><code>++yer</code></h3>
### `++yer`
++ yer 31.536.000 :: (mul 365 day)
@ -1997,7 +1997,7 @@ seconds in a day by 365.
section 2cI, almost macros
--------------------------
<h3 id="++cury"><code>++cury</code></h3>
### `++cury`
++ cury
|* [a=_|=(^ _*) b=*]
@ -2018,7 +2018,7 @@ Curry a gate, binding the head of its sample
------------------------------------------------------------------------
<h3 id="++curr"><code>++curr</code></h3>
### `++curr`
++ curr
|* [a=_|=(^ _*) c=*]
@ -2039,7 +2039,7 @@ Right curry a gate, binding the tail of its sample
------------------------------------------------------------------------
<h3 id="++cork"><code>++cork</code></h3>
### `++cork`
++ cork |*([a=_,* b=gate] (corl b a)) :: compose forward
@ -2059,7 +2059,7 @@ Build `f` such that `(f x) .= (b (a x))`.
------------------------------------------------------------------------
<h3 id="++corl"><code>++corl</code></h3>
### `++corl`
++ corl :: compose backwards
|* [a=gate b=_,*]
@ -2079,7 +2079,7 @@ XX Revisit
------------------------------------------------------------------------
<h3 id="++hard"><code>++hard</code></h3>
### `++hard`
++ hard
|* han=$+(* *)
@ -2103,7 +2103,7 @@ not.
------------------------------------------------------------------------
<h3 id="++soft"><code>++soft</code></h3>
### `++soft`
++ soft
|* han=$+(* *)

View File

@ -1,7 +1,7 @@
section 2dA, sets
=================
<h3 id="++apt"><code>++apt</code></h3>
### `++apt`
Set verification
@ -29,7 +29,7 @@ Produces a loobean indicating whether `a` is a set or not.
------------------------------------------------------------------------
<h3 id="++in"><code>++in</code></h3>
### `++in`
Set operations
@ -44,7 +44,7 @@ Input arm.
`a` is a [set]()
<h3 id="+-all:in"><code>+-all:in</code></h3>
### `+-all:in`
Logical AND
@ -73,7 +73,7 @@ producing a loobean.
------------------------------------------------------------------------
<h3 id="+-any:in"><code>+-any:in</code></h3>
### `+-any:in`
Logical OR
@ -101,7 +101,7 @@ Computes the logical OR on every element of `a` slammed with `b`.
------------------------------------------------------------------------
<h3 id="+-del:in"><code>+-del:in</code></h3>
### `+-del:in`
Remove noun
@ -140,7 +140,7 @@ Removes `b` from the set `a`.
------------------------------------------------------------------------
<h3 id="+-dig:in"><code>+-dig:in</code></h3>
### `+-dig:in`
Axis a in b
@ -175,7 +175,7 @@ Produce the axis of `b` within `a`.
------------------------------------------------------------------------
<h3 id="+-gas:in"><code>+-gas:in</code></h3>
### `+-gas:in`
Concatenate
@ -203,7 +203,7 @@ Insert the elements of a list `b` into a set `a`.
------------------------------------------------------------------------
<h3 id="+-has:in"><code>+-has:in</code></h3>
### `+-has:in`
b in a?
@ -234,7 +234,7 @@ Checks if `b` is an element of `a`, producing a loobean.
------------------------------------------------------------------------
<h3 id="+-int:in"><code>+-int:in</code></h3>
### `+-int:in`
Intersection
@ -272,7 +272,7 @@ Produces a set of the intersection between two sets of the same type,
------------------------------------------------------------------------
<h3 id="+-put:in"><code>+-put:in</code></h3>
### `+-put:in`
Put b in a
@ -312,7 +312,7 @@ Add an element `b` to the set `a`.
------------------------------------------------------------------------
<h3 id="+-rep:in"><code>+-rep:in</code></h3>
### `+-rep:in`
Accumulate
@ -339,7 +339,7 @@ Accumulate the elements of `a` using a gate `c` and an accumulator `b`.
------------------------------------------------------------------------
<h3 id="+-tap:in"><code>+-tap:in</code></h3>
### `+-tap:in`
Set to list
@ -372,7 +372,7 @@ Flatten the set `a` into a list.
------------------------------------------------------------------------
<h3 id="+-uni:in"><code>+-uni:in</code></h3>
### `+-uni:in`
Union
@ -414,7 +414,7 @@ Produces a set of the union between two sets of the same type, `a` and
------------------------------------------------------------------------
<h3 id="+-wyt:in"><code>+-wyt:in</code></h3>
### `+-wyt:in`
Set size

View File

@ -1,7 +1,7 @@
section 2dB, maps
=================
<h3 id="++ept"><code>++ept</code></h3>
### `++ept`
Map invariant.
@ -29,7 +29,7 @@ Computes whether `a` is a [map](), producing a loobean.
------------------------------------------------------------------------
<h3 id="++ja"><code>++ja</code></h3>
### `++ja`
Jar engine
@ -46,7 +46,7 @@ A container arm for `++jar` operation arms. A `++jar` is a `++map` of
------------------------------------------------------------------------
<h3 id="+-get:ja"><code>+-get:ja</code></h3>
### `+-get:ja`
Grab value by key
@ -73,7 +73,7 @@ Produces a list retrieved from jar `a` using the key `b`.
------------------------------------------------------------------------
<h3 id="+-add:ja"><code>+-add:ja</code></h3>
### `+-add:ja`
Prepend to list
@ -106,7 +106,7 @@ Produces jar `a` with value `c` prepended to the list located at key
------------------------------------------------------------------------
<h3 id="++ju"><code>++ju</code></h3>
### `++ju`
Jug operations
@ -121,7 +121,7 @@ Container arm for jug operation arms. A `++jug` is a `++map` of
~zod/try=> ~(. ju (mo (limo a/(sa "ho") b/(sa "he") ~)))
<2.dgz [nlr([p={%a %b} q={nlr(^$1{@tD $1}) nlr(^$3{@tD $3})}]) <414.fvk 101.jzo 1.ypj %164>]>
<h3 id="+-del:ju"><code>+-del:ju</code></h3>
### `+-del:ju`
Remove
@ -152,7 +152,7 @@ removed.
------------------------------------------------------------------------
<h3 id="+-get:ju"><code>+-get:ju</code></h3>
### `+-get:ju`
Retrieve set
@ -178,7 +178,7 @@ Produces a set retrieved from jar `a` using key `b`.
------------------------------------------------------------------------
<h3 id="+-has:ju"><code>+-has:ju</code></h3>
### `+-has:ju`
Check contents
@ -213,7 +213,7 @@ with jar `a`. Produces a loobean.
------------------------------------------------------------------------
<h3 id="+-put:ju"><code>+-put:ju</code></h3>
### `+-put:ju`
Add key-set pair
@ -242,7 +242,7 @@ Produces jar `a` with `c` added to the set value located at key `b`.
------------------------------------------------------------------------
<h3 id="++by"><code>++by</code></h3>
### `++by`
Map operations
@ -260,7 +260,7 @@ pairs. The contained arms inherit it's [sample]() [map](), `a`.
------------------------------------------------------------------------
<h3 id="+-all:by"><code>+-all:by</code></h3>
### `+-all:by`
Logical AND
@ -290,7 +290,7 @@ Computes the logical AND on the results of slamming every element in map
------------------------------------------------------------------------
<h3 id="+-any:by"><code>+-any:by</code></h3>
### `+-any:by`
Logical OR
@ -318,7 +318,7 @@ gate `b`. Produces a loobean.
------------------------------------------------------------------------
<h3 id="+-del:by"><code>+-del:by</code></h3>
### `+-del:by`
Delete
@ -351,7 +351,7 @@ Produces map `a` with the element located at key `b` removed.
------------------------------------------------------------------------
<h3 id="+-dig:by"><code>+-dig:by</code></h3>
### `+-dig:by`
Axis of key
@ -377,7 +377,7 @@ Produce the axis of key `b` within map `a`.
------------------------------------------------------------------------
<h3 id="+-gas:by"><code>+-gas:by</code></h3>
### `+-gas:by`
Concatenate
@ -403,7 +403,7 @@ Insert a list of key-value pairs `b` into map `a`.
------------------------------------------------------------------------
<h3 id="+-get:by"><code>+-get:by</code></h3>
### `+-get:by`
Grab unit value
@ -431,7 +431,7 @@ Produce the unit value of the value located at key `b` within map `a`.
------------------------------------------------------------------------
<h3 id="+-got:by"><code>+-got:by</code></h3>
### `+-got:by`
Assert
@ -459,7 +459,7 @@ does not exist.
------------------------------------------------------------------------
<h3 id="+-has:by"><code>+-has:by</code></h3>
### `+-has:by`
Key existence check
@ -483,7 +483,7 @@ loobean.
------------------------------------------------------------------------
<h3 id="+-int:by"><code>+-int:by</code></h3>
### `+-int:by`
Intersection
@ -539,7 +539,7 @@ different values, the element from map `b` is used.
------------------------------------------------------------------------
<h3 id="+-mar:by"><code>+-mar:by</code></h3>
### `+-mar:by`
Assert and Add
@ -575,7 +575,7 @@ XX This arm is broken, asana task 15186618346453
------------------------------------------------------------------------
<h3 id="+-put:by"><code>+-put:by</code></h3>
### `+-put:by`
Add key-value pair
@ -621,7 +621,7 @@ Produces `a` with the addition of the key-value pair of `b` and `c`.
------------------------------------------------------------------------
<h3 id="+-rep:by"><code>+-rep:by</code></h3>
### `+-rep:by`
+- rep :: replace by product
|* [b=* c=_,*]
@ -635,7 +635,7 @@ XX interface changing.
------------------------------------------------------------------------
<h3 id="+-rib:by"><code>+-rib:by</code></h3>
### `+-rib:by`
+- rib :: transform + product
|* [b=* c=_,*]
@ -653,7 +653,7 @@ XX interface changing, possibly disappearing
------------------------------------------------------------------------
<h3 id="+-run:by"><code>+-run:by</code></h3>
### `+-run:by`
Transform values
@ -678,7 +678,7 @@ Iterates over every value in set `a` using gate `b`. Produces a map.
------------------------------------------------------------------------
<h3 id="+-tap:by"><code>+-tap:by</code></h3>
### `+-tap:by`
Listify pairs
@ -707,7 +707,7 @@ Produces the list of all elements in map `a` that is prepended to list
------------------------------------------------------------------------
<h3 id="+-uni:by"><code>+-uni:by</code></h3>
### `+-uni:by`
Union
@ -758,7 +758,7 @@ shares a key with `a`, the tuple from `a` is preserved.
------------------------------------------------------------------------
<h3 id="+-urn:by"><code>+-urn:by</code></h3>
### `+-urn:by`
Turn (with key)
@ -787,7 +787,7 @@ produces a noun (the new value).
------------------------------------------------------------------------
<h3 id="+-wyt:by"><code>+-wyt:by</code></h3>
### `+-wyt:by`
Depth

View File

@ -1,7 +1,7 @@
section 2dC, queues
===================
<h3 id="++to"><code>++to</code></h3>
### `++to`
Queue engine
@ -13,7 +13,7 @@ Container arm for queue operation arms. The contained arms inherit its
`a` is a queue, [++qeu]().
<h3 id="+-bal:to"><code>+-bal:to</code></h3>
### `+-bal:to`
Balance
@ -42,7 +42,7 @@ Vertically rebalances queue `a`.
------------------------------------------------------------------------
<h3 id="+-dep:to"><code>+-dep:to</code></h3>
### `+-dep:to`
Maximum Depth
@ -72,7 +72,7 @@ Produces the maximum depth of leaves (r.a and l.a) in queue `a`.
------------------------------------------------------------------------
<h3 id="+-gas"><code>+-gas</code></h3>
### `+-gas`
Push list
@ -97,7 +97,7 @@ Push all elements of list `b` into the queue.
------------------------------------------------------------------------
<h3 id="+-get:to"><code>+-get:to</code></h3>
### `+-get:to`
Pop
@ -126,7 +126,7 @@ Produces the head and tail queue of `a`.
------------------------------------------------------------------------
<h3 id="+-nap:to"><code>+-nap:to</code></h3>
### `+-nap:to`
Remove last in
@ -154,7 +154,7 @@ Removes the head of queue `a`, producing the resulting queue.
------------------------------------------------------------------------
<h3 id="+-put:to"><code>+-put:to</code></h3>
### `+-put:to`
Insert
@ -179,7 +179,7 @@ resulting queue.
------------------------------------------------------------------------
<h3 id="+-tap:to"><code>+-tap:to</code></h3>
### `+-tap:to`
Queue to list
@ -203,7 +203,7 @@ Produces queue `a` as a list from front to back.
------------------------------------------------------------------------
<h3 id="+-top:to"><code>+-top:to</code></h3>
### `+-top:to`
+- top :: produces head
|- ^- (unit ,_?>(?=(^ a) n.a))

View File

@ -1,7 +1,7 @@
section 2dD, casual containers
==============================
<h3 id="++mo"><code>++mo</code></h3>
### `++mo`
Map from list
@ -23,7 +23,7 @@ Produces a map of key-value pairs from the left-right cell pairs of list
------------------------------------------------------------------------
<h3 id="++sa"><code>++sa</code></h3>
### `++sa`
Set from list
@ -45,7 +45,7 @@ Produces a set of the elements in list `a`.
------------------------------------------------------------------------
<h3 id="++qu"><code>++qu</code></h3>
### `++qu`
Queue from list

View File

@ -1,7 +1,7 @@
section 2eA, packing
====================
<h3 id="++cue"><code>++cue</code></h3>
### `++cue`
Unpack atom to noun
@ -41,7 +41,7 @@ Produces a noun unpacked from atom `a`. The inverse of jam.
------------------------------------------------------------------------
<h3 id="++jam"><code>++jam</code></h3>
### `++jam`
++ jam :: pack
~/ %jam
@ -83,7 +83,7 @@ Produces an atom unpacked from noun `a`. The inverse of cue.
------------------------------------------------------------------------
<h3 id="++mat"><code>++mat</code></h3>
### `++mat`
Length-encode
@ -123,7 +123,7 @@ is the length of `q` in bits.
------------------------------------------------------------------------
<h3 id="++rub"><code>++rub</code></h3>
### `++rub`
Length-decode

View File

@ -1,7 +1,7 @@
section 2eB, parsing (tracing)
==============================
<h3 id="++last"><code>++last</code></h3>
### `++last`
Farther trace
@ -30,7 +30,7 @@ Compares two line-column pairs, `zyc` and `naz`, and produces whichever
------------------------------------------------------------------------
<h3 id="++lust"><code>++lust</code></h3>
### `++lust`
Detect newline

View File

@ -1,7 +1,7 @@
section 2eC, parsing (custom rules)
===================================
<h3 id="++cold"><code>++cold</code></h3>
### `++cold`
Replace with constant
@ -30,7 +30,7 @@ produces a constant `cus`, if `sef` is successful.
------------------------------------------------------------------------
<h3 id="++cook"><code>++cook</code></h3>
### `++cook`
Apply gate
@ -63,7 +63,7 @@ rule `sef` and slams it through `poq`.
------------------------------------------------------------------------
<h3 id="++easy"><code>++easy</code></h3>
### `++easy`
Always parse
@ -88,7 +88,7 @@ without consuming any text.
------------------------------------------------------------------------
<h3 id="++fail"><code>++fail</code></h3>
### `++fail`
Never parse
@ -106,7 +106,7 @@ result (`q=~`).
------------------------------------------------------------------------
<h3 id="++full"><code>++full</code></h3>
### `++full`
Parse to end
@ -131,7 +131,7 @@ when a `tub` success consumes the remainder of the [tape]().
------------------------------------------------------------------------
<h3 id="++funk"><code>++funk</code></h3>
### `++funk`
Add to tape
@ -154,7 +154,7 @@ Parser modifier: prepend text to tape before applying parser.
------------------------------------------------------------------------
<h3 id="++here"><code>++here</code></h3>
### `++here`
Place-based apply
@ -186,7 +186,7 @@ Parser modifier. Similar to [`++cook`](), produces a parser that takes a
------------------------------------------------------------------------
<h3 id="++inde"><code>++inde</code></h3>
### `++inde`
Indentation block
@ -231,7 +231,7 @@ the leading whitespace.
------------------------------------------------------------------------
<h3 id="++jest"><code>++jest</code></h3>
### `++jest`
Match a cord
@ -266,7 +266,7 @@ Match and consume a cord.
------------------------------------------------------------------------
<h3 id="++just"><code>++just</code></h3>
### `++just`
Match a char
@ -300,7 +300,7 @@ Match and consume a single character.
------------------------------------------------------------------------
<h3 id="++knee"><code>++knee</code></h3>
### `++knee`
Recursive parsers
@ -341,7 +341,7 @@ compiled.
------------------------------------------------------------------------
<h3 id="++mask"><code>++mask</code></h3>
### `++mask`
Match char
@ -374,7 +374,7 @@ characters.
------------------------------------------------------------------------
<h3 id="++next"><code>++next</code></h3>
### `++next`
Consume char
@ -398,7 +398,7 @@ Consume any character, producing it as a result.
------------------------------------------------------------------------
<h3 id="++sear"><code>++sear</code></h3>
### `++sear`
Conditional `++cook`
@ -426,7 +426,7 @@ a unit; if that unit is empty, fail.
------------------------------------------------------------------------
<h3 id="++shim"><code>++shim</code></h3>
### `++shim`
Char in range
@ -456,7 +456,7 @@ Match characters within a range.
------------------------------------------------------------------------
<h3 id="++stag"><code>++stag</code></h3>
### `++stag`
Add label
@ -486,7 +486,7 @@ Add a label to an edge parsed by a rule.
------------------------------------------------------------------------
<h3 id="++stet"><code>++stet</code></h3>
### `++stet`
Add faces
@ -523,7 +523,7 @@ Add `[p q]` faces to range-parser pairs in a list.
------------------------------------------------------------------------
<h3 id="++stew"><code>++stew</code></h3>
### `++stew`
Switch by first
@ -578,7 +578,7 @@ associated with a range the tape's first character falls in.
------------------------------------------------------------------------
<h3 id="++stir"><code>++stir</code></h3>
### `++stir`
Parse repeatedly
@ -612,7 +612,7 @@ binary gate.
------------------------------------------------------------------------
<h3 id="++stun"><code>++stun</code></h3>
### `++stun`
Parse several times

View File

@ -1,7 +1,7 @@
section 2eD
===========
<h3 id="++bend"><code>++bend</code></h3>
### `++bend`
Conditional composer
@ -50,7 +50,7 @@ group of rules to a specified output.
------------------------------------------------------------------------
<h3 id="++comp"><code>++comp</code></h3>
### `++comp`
Arbitrary compose
@ -87,7 +87,7 @@ produces a cell of two nouns.
------------------------------------------------------------------------
<h3 id="++glue"><code>++glue</code></h3>
### `++glue`
Skip delimiter
@ -120,7 +120,7 @@ result.
------------------------------------------------------------------------
<h3 id="++less"><code>++less</code></h3>
### `++less`
Parse unless
@ -150,7 +150,7 @@ connect `vex` with the following rule.
------------------------------------------------------------------------
<h3 id="++pfix"><code>++pfix</code></h3>
### `++pfix`
Discard first rule
@ -171,7 +171,7 @@ ignoring the result of the first and producing the result of the second.
------------------------------------------------------------------------
<h3 id="++plug"><code>++plug</code></h3>
### `++plug`
Parse to tuple
@ -204,7 +204,7 @@ more detailed explanation.
------------------------------------------------------------------------
<h3 id="++pose"><code>++pose</code></h3>
### `++pose`
Parse options
@ -235,7 +235,7 @@ following rule `sab`. See also: the monad applicator [;\~]()
------------------------------------------------------------------------
<h3 id="++simu"><code>++simu</code></h3>
### `++simu`
First and second
@ -266,7 +266,7 @@ connect `vex` with the following rule.
------------------------------------------------------------------------
<h3 id="++sfix"><code>++sfix</code></h3>
### `++sfix`
Discard second rule

View File

@ -1,7 +1,7 @@
section 2eE, parsing (composers)
================================
<h3 id="++bass"><code>++bass</code></h3>
### `++bass`
++ bass
|* [wuc=@ tyd=_rule]
@ -30,7 +30,7 @@ as atom of a base.
------------------------------------------------------------------------
<h3 id="++boss"><code>++boss</code></h3>
### `++boss`
++ boss
|* [wuc=@ tyd=_rule]
@ -59,7 +59,7 @@ as atom of a base.
------------------------------------------------------------------------
<h3 id="++ifix"><code>++ifix</code></h3>
### `++ifix`
++ ifix
|* [fel=[p=_rule q=_rule] hof=_rule]
@ -80,7 +80,7 @@ discarded.
------------------------------------------------------------------------
<h3 id="++more"><code>++more</code></h3>
### `++more`
++ more
|* [bus=_rule fel=_rule]
@ -102,7 +102,7 @@ Parser modifier: using a delimiter rule, parse a list of matches.
------------------------------------------------------------------------
<h3 id="++most"><code>++most</code></h3>
### `++most`
++ most
|* [bus=_rule fel=_rule]
@ -126,7 +126,7 @@ match.
------------------------------------------------------------------------
<h3 id="++plus"><code>++plus</code></h3>
### `++plus`
++ plus |*(fel=_rule ;~(plug fel (star fel)))
@ -145,7 +145,7 @@ Parser modifier: parse list of at least one match
------------------------------------------------------------------------
<h3 id="++slug"><code>++slug</code></h3>
### `++slug`
++ slug
|* raq=_|*([a=* b=*] [a b])
@ -167,7 +167,7 @@ matches.
------------------------------------------------------------------------
<h3 id="++star"><code>++star</code></h3>
### `++star`
++ star :: 0 or more times
|* fel=_rule

View File

@ -1,7 +1,7 @@
section 2eF, parsing (ascii)
============================
<h3 id="++ace"><code>++ace</code></h3>
### `++ace`
Parse space
@ -20,7 +20,7 @@ Parses ASCII character 32, space.
------------------------------------------------------------------------
<h3 id="++bar"><code>++bar</code></h3>
### `++bar`
Parse vertical bar
@ -39,7 +39,7 @@ Parses ASCII character 124, the vertical bar.
------------------------------------------------------------------------
<h3 id="++bas"><code>++bas</code></h3>
### `++bas`
Parse backslash
@ -61,7 +61,7 @@ of `bas` with [`++just`](/doc/hoon/library/2ec#++just) is to escape the escape c
------------------------------------------------------------------------
<h3 id="++buc"><code>++buc</code></h3>
### `++buc`
Parse dollar sign
@ -80,7 +80,7 @@ Parses ASCII character 36, the dollar sign.
------------------------------------------------------------------------
<h3 id="++cab"><code>++cab</code></h3>
### `++cab`
Parse underscore
@ -99,7 +99,7 @@ Parses ASCII character 95, the underscore.
------------------------------------------------------------------------
<h3 id="++cen"><code>++cen</code></h3>
### `++cen`
Parses percent sign
@ -118,7 +118,7 @@ Parses ASCII character 37, the percent sign.
------------------------------------------------------------------------
<h3 id="++col"><code>++col</code></h3>
### `++col`
Parse colon
@ -137,7 +137,7 @@ Parses ASCII character 58, the colon
------------------------------------------------------------------------
<h3 id="++com"><code>++com</code></h3>
### `++com`
Parse comma
@ -156,7 +156,7 @@ Parses ASCII character 44, the comma.
------------------------------------------------------------------------
<h3 id="++doq"><code>++doq</code></h3>
### `++doq`
Parse double quote
@ -179,7 +179,7 @@ Parses ASCII character 34, the double quote.
------------------------------------------------------------------------
<h3 id="++dot"><code>++dot</code></h3>
### `++dot`
Parse period
@ -198,7 +198,7 @@ Parses ASCII character 46, the period.
------------------------------------------------------------------------
<h3 id="++fas"><code>++fas</code></h3>
### `++fas`
Parse forward slash
@ -217,7 +217,7 @@ Parses ASCII character 47, the forward slash.
------------------------------------------------------------------------
<h3 id="++gal"><code>++gal</code></h3>
### `++gal`
Parse less-than sign
@ -238,7 +238,7 @@ Parses ASCII character 60, the less-than sign.
------------------------------------------------------------------------
<h3 id="++gar"><code>++gar</code></h3>
### `++gar`
Parse greater-than sign
@ -257,7 +257,7 @@ Parses ASCII character 62, the greater-than sign.
------------------------------------------------------------------------
<h3 id="++hax"><code>++hax</code></h3>
### `++hax`
Parse number sign
@ -276,7 +276,7 @@ Parses ASCII character 35, the number sign.
------------------------------------------------------------------------
<h3 id="++kel"><code>++kel</code></h3>
### `++kel`
Parse left curley bracket
@ -297,7 +297,7 @@ interpolation. To parse either of them, they must be escaped.
------------------------------------------------------------------------
<h3 id="++ker"><code>++ker</code></h3>
### `++ker`
Parse right curley bracket
@ -318,7 +318,7 @@ interpolation. To parse either of them, they must be escaped.
------------------------------------------------------------------------
<h3 id="++ket"><code>++ket</code></h3>
### `++ket`
Parse caret
@ -337,7 +337,7 @@ Parses ASCII character 94, the caret.
------------------------------------------------------------------------
<h3 id="++lus"><code>++lus</code></h3>
### `++lus`
Parse plus sign
@ -356,7 +356,7 @@ Parses ASCII character 43, the plus sign.
------------------------------------------------------------------------
<h3 id="++hep"><code>++hep</code></h3>
### `++hep`
Parse hyphen
@ -375,7 +375,7 @@ Parses ASCII character 45, the hyphen.
------------------------------------------------------------------------
<h3 id="++pel"><code>++pel</code></h3>
### `++pel`
Parse left parenthesis
@ -394,7 +394,7 @@ Parses ASCII character 40, the left parenthesis.
------------------------------------------------------------------------
<h3 id="++pam"><code>++pam</code></h3>
### `++pam`
Parse ampersand
@ -413,7 +413,7 @@ Parses ASCII character 38, the ampersand.
------------------------------------------------------------------------
<h3 id="++per"><code>++per</code></h3>
### `++per`
Parse right parenthesis
@ -432,7 +432,7 @@ Parses ASCII character 41, the right parenthesis.
------------------------------------------------------------------------
<h3 id="++pat"><code>++pat</code></h3>
### `++pat`
Parse "at" sign
@ -451,7 +451,7 @@ Parses ASCII character 64, the "at" sign.
------------------------------------------------------------------------
<h3 id="++sel"><code>++sel</code></h3>
### `++sel`
Parse left square bracket
@ -472,7 +472,7 @@ Parses ASCII character 91, the left square bracket.
------------------------------------------------------------------------
<h3 id="++sem"><code>++sem</code></h3>
### `++sem`
Parse semicolon
@ -480,7 +480,7 @@ Parse semicolon
Parses ASCII character 59, the semicolon.
<h3 id="Examples"><code>Examples</code></h3>
### `Examples`
~zod/try=> (scan ";" sem)
~~~3b.
@ -493,7 +493,7 @@ Parses ASCII character 59, the semicolon.
------------------------------------------------------------------------
<h3 id="++ser"><code>++ser</code></h3>
### `++ser`
Parse right square bracket
@ -512,7 +512,7 @@ Parses ASCII character 93, the right square bracket.
------------------------------------------------------------------------
<h3 id="++sig"><code>++sig</code></h3>
### `++sig`
Parse tilde
@ -531,7 +531,7 @@ Parses ASCII character 126, the tilde.
------------------------------------------------------------------------
<h3 id="++soq"><code>++soq</code></h3>
### `++soq`
Parse single quote
@ -551,7 +551,7 @@ Parses ASCII character 39, soq. Note the extra '' is to escape the first
------------------------------------------------------------------------
<h3 id="++tar"><code>++tar</code></h3>
### `++tar`
Parse asterisk
@ -570,7 +570,7 @@ Parses ASCII character 42, the asterisk.
------------------------------------------------------------------------
<h3 id="++tec"><code>++tec</code></h3>
### `++tec`
Parse backtick
@ -590,7 +590,7 @@ accent".
------------------------------------------------------------------------
<h3 id="++tis"><code>++tis</code></h3>
### `++tis`
Parse equals sign
@ -609,7 +609,7 @@ Parses ASCII character 61, the equals sign.
------------------------------------------------------------------------
<h3 id="++wut"><code>++wut</code></h3>
### `++wut`
Parses question mark
@ -628,7 +628,7 @@ Parses ASCII character 63, wut.
------------------------------------------------------------------------
<h3 id="++zap"><code>++zap</code></h3>
### `++zap`
Exclamation point

View File

@ -1,7 +1,7 @@
section 2eG, parsing (whitespace)
=================================
<h3 id="++dog"><code>++dog</code></h3>
### `++dog`
`.` optional gap
@ -17,7 +17,7 @@ Dot followed by an optional gap, used in numbers.
------------------------------------------------------------------------
<h3 id="++doh"><code>++doh</code></h3>
### `++doh`
`@p` separator
@ -37,7 +37,7 @@ Phonetic base phrase separator
------------------------------------------------------------------------
<h3 id="++dun"><code>++dun</code></h3>
### `++dun`
`--` to `~`
@ -52,7 +52,7 @@ Parse phep, `--`, to null, `~`.
------------------------------------------------------------------------
<h3 id="++duz"><code>++duz</code></h3>
### `++duz`
`==` to `~`
@ -67,7 +67,7 @@ Parse stet, `==`, to null `~`.
------------------------------------------------------------------------
<h3 id="++gah"><code>++gah</code></h3>
### `++gah`
Newline or ' '
@ -96,7 +96,7 @@ Whitespace component, either newline or space.
------------------------------------------------------------------------
<h3 id="++gap"><code>++gap</code></h3>
### `++gap`
Plural whitespace
@ -106,7 +106,7 @@ Separates tall runes
------------------------------------------------------------------------
<h3 id="++gaq"><code>++gaq</code></h3>
### `++gaq`
End of line
@ -120,7 +120,7 @@ Two spaces, a newline, or comment.
------------------------------------------------------------------------
<h3 id="++gaw"><code>++gaw</code></h3>
### `++gaw`
Classic whitespace
@ -130,7 +130,7 @@ Terran whitespace
------------------------------------------------------------------------
<h3 id="++gay"><code>++gay</code></h3>
### `++gay`
Optional gap.
@ -140,7 +140,7 @@ Optional gap.
------------------------------------------------------------------------
<h3 id="++vul"><code>++vul</code></h3>
### `++vul`
++ vul %- cold :- ~ :: comments
;~ plug col col

View File

@ -1,7 +1,7 @@
section 2eH, parsing (idioms)
=============================
<h3 id="++alf"><code>++alf</code></h3>
### `++alf`
Alphabetic characters
@ -18,7 +18,7 @@ Parse alphabetic characters, both upper and lowercase.
------------------------------------------------------------------------
<h3 id="++aln"><code>++aln</code></h3>
### `++aln`
Alphanumeric characters
@ -35,7 +35,7 @@ Parse alphanumeric characters - both alphabetic characters and numbers.
------------------------------------------------------------------------
<h3 id="++alp"><code>++alp</code></h3>
### `++alp`
Alphanumeric and `-`
@ -52,7 +52,7 @@ Parse alphanumeric strings and hep, "-".
------------------------------------------------------------------------
<h3 id="++bet"><code>++bet</code></h3>
### `++bet`
Axis syntax `-`, `+`
@ -67,7 +67,7 @@ Parse the hep and lus axis syntax.
------------------------------------------------------------------------
<h3 id="++bin"><code>++bin</code></h3>
### `++bin`
Binary to atom
@ -87,7 +87,7 @@ representation.
------------------------------------------------------------------------
<h3 id="++but"><code>++but</code></h3>
### `++but`
Binary digit
@ -108,7 +108,7 @@ Parse a single binary digit.
------------------------------------------------------------------------
<h3 id="++cit"><code>++cit</code></h3>
### `++cit`
Octal digit
@ -129,7 +129,7 @@ Parse a single octal digit.
------------------------------------------------------------------------
<h3 id="++dem"><code>++dem</code></h3>
### `++dem`
Decimal to atom
@ -148,7 +148,7 @@ Parse a decimal number to an atom.
------------------------------------------------------------------------
<h3 id="++dit"><code>++dit</code></h3>
### `++dit`
Decimal digit
@ -165,7 +165,7 @@ Parse a single decimal digit.
------------------------------------------------------------------------
<h3 id="++gul"><code>++gul</code></h3>
### `++gul`
Axis syntax `<` or `>`
@ -180,7 +180,7 @@ Parse the axis gal and gar axis syntax.
------------------------------------------------------------------------
<h3 id="++gon"><code>++gon</code></h3>
### `++gon`
Long numbers
@ -196,7 +196,7 @@ break characters bas and fas.
------------------------------------------------------------------------
<h3 id="++hex"><code>++hex</code></h3>
### `++hex`
Hex to atom
@ -221,7 +221,7 @@ Parse any hexadecimal number to an atom.
------------------------------------------------------------------------
<h3 id="++hig"><code>++hig</code></h3>
### `++hig`
Uppercase
@ -240,7 +240,7 @@ Parse a single uppercase letter.
------------------------------------------------------------------------
<h3 id="++hit"><code>++hit</code></h3>
### `++hit`
Hex digits
@ -263,7 +263,7 @@ Parse a single hexadecimal digit.
------------------------------------------------------------------------
<h3 id="++low"><code>++low</code></h3>
### `++low`
Lowercase
@ -282,7 +282,7 @@ Parse a single lowercase letter.
------------------------------------------------------------------------
<h3 id="++mes"><code>++mes</code></h3>
### `++mes`
Hexbyte
@ -301,7 +301,7 @@ Parse a hexbyte.
------------------------------------------------------------------------
<h3 id="++nix"><code>++nix</code></h3>
### `++nix`
Letters, `-`, and `_`
@ -316,7 +316,7 @@ Letters, `-`, and `_`
------------------------------------------------------------------------
<h3 id="++nud"><code>++nud</code></h3>
### `++nud`
Numeric
@ -335,7 +335,7 @@ Parse a numeric character - A number.
------------------------------------------------------------------------
<h3 id="++prn"><code>++prn</code></h3>
### `++prn`
Printable character
@ -353,7 +353,7 @@ Parse any printable character
------------------------------------------------------------------------
<h3 id="++qat"><code>++qat</code></h3>
### `++qat`
Chars in blockcord
@ -376,7 +376,7 @@ Parse character in cord block.
------------------------------------------------------------------------
<h3 id="++qit"><code>++qit</code></h3>
### `++qit`
Chars in cord
@ -406,7 +406,7 @@ Parse an individual character to its cord atom representation.
------------------------------------------------------------------------
<h3 id="++qut"><code>++qut</code></h3>
### `++qut`
Cord
@ -439,7 +439,7 @@ triple-soq cord which must be in an indented block.
------------------------------------------------------------------------
<h3 id="++soqs"><code>++soqs</code></h3>
### `++soqs`
Delimiting `'''`
@ -455,7 +455,7 @@ Triple single quote
------------------------------------------------------------------------
<h3 id="++sym"><code>++sym</code></h3>
### `++sym`
Term
@ -476,7 +476,7 @@ A term: a letter(lowercase), followed by letters, numbers, or `-`.
------------------------------------------------------------------------
<h3 id="++ven"><code>++ven</code></h3>
### `++ven`
`+>-` axis syntax
@ -506,7 +506,7 @@ Axis syntax parser
------------------------------------------------------------------------
<h3 id="++vit"><code>++vit</code></h3>
### `++vit`
Base64 digit

View File

@ -1,7 +1,7 @@
section 2eI, parsing (external)
===============================
<h3 id="++rash"><code>++rash</code></h3>
### `++rash`
Parse or crash
@ -29,7 +29,7 @@ parsed.
------------------------------------------------------------------------
<h3 id="++rush"><code>++rush</code></h3>
### `++rush`
Parse or null
@ -55,7 +55,7 @@ entirely parsed.
------------------------------------------------------------------------
<h3 id="++rust"><code>++rust</code></h3>
### `++rust`
Parse tape or null
@ -79,7 +79,7 @@ entirely parsed.
------------------------------------------------------------------------
<h3 id="++scan"><code>++scan</code></h3>
### `++scan`
Parse tape or crash

View File

@ -1,7 +1,7 @@
section 2eJ, formatting (basic text)
====================================
<h3 id="++cass"><code>++cass</code></h3>
### `++cass`
To lowercase
@ -26,7 +26,7 @@ Produce the case insensitive (all lowercase) cord of a tape.
------------------------------------------------------------------------
<h3 id="++cuss"><code>++cuss</code></h3>
### `++cuss`
To uppercase
@ -53,7 +53,7 @@ letters, as a cord.
------------------------------------------------------------------------
<h3 id="++crip"><code>++crip</code></h3>
### `++crip`
Tape to cord
@ -72,7 +72,7 @@ Produce cord from a tape.
------------------------------------------------------------------------
<h3 id="++mesc"><code>++mesc</code></h3>
### `++mesc`
Escape special chars
@ -101,7 +101,7 @@ Escape special characters, used in [`++show`](/doc/hoon/library/2ez#++show)
------------------------------------------------------------------------
<h3 id="++runt"><code>++runt</code></h3>
### `++runt`
Prepend `n` times
@ -126,7 +126,7 @@ Add `a` repetitions of character `b` to the head of `c`
------------------------------------------------------------------------
<h3 id="++sand"><code>++sand</code></h3>
### `++sand`
Soft-cast by odor
@ -149,7 +149,7 @@ Soft-cast validity by odor.
------------------------------------------------------------------------
<h3 id="++sane"><code>++sane</code></h3>
### `++sane`
Check odor validity
@ -204,7 +204,7 @@ Check validity by odor. Produces a gate.
------------------------------------------------------------------------
<h3 id="++trim"><code>++trim</code></h3>
### `++trim`
Tape split
@ -232,7 +232,7 @@ Split first `a` characters off tape.
------------------------------------------------------------------------
<h3 id="++trip"><code>++trip</code></h3>
### `++trip`
Cord to tape
@ -257,7 +257,7 @@ Produce tape from cord.
------------------------------------------------------------------------
<h3 id="++teff"><code>++teff</code></h3>
### `++teff`
UTF8 Length
@ -281,7 +281,7 @@ Number of utf8 bytes.
------------------------------------------------------------------------
<h3 id="++turf"><code>++turf</code></h3>
### `++turf`
UTF8 to UTF32 cord
@ -322,7 +322,7 @@ Convert utf8 ([cord]()) to utf32 codepoints.
------------------------------------------------------------------------
<h3 id="++tuba"><code>++tuba</code></h3>
### `++tuba`
UTF8 to UTF32 tape
@ -343,7 +343,7 @@ Convert tape to list of codepoints.
------------------------------------------------------------------------
<h3 id="++tufa"><code>++tufa</code></h3>
### `++tufa`
UTF32 to UTF8 tape
@ -365,7 +365,7 @@ Wrap list of utf32 codepoints to utf8 [tape]().
------------------------------------------------------------------------
<h3 id="++tuft"><code>++tuft</code></h3>
### `++tuft`
UTF32 to UTF8 text
@ -411,7 +411,7 @@ Convert utf32 glyph to
------------------------------------------------------------------------
<h3 id="++wack"><code>++wack</code></h3>
### `++wack`
Coin format encode
@ -443,7 +443,7 @@ Escape span `~` as `~~` and `_` as `~-`. Used for printing.
------------------------------------------------------------------------
<h3 id="++wick"><code>++wick</code></h3>
### `++wick`
Coin format decode
@ -472,7 +472,7 @@ Unescape span `~~` as `~` and `~-` as `_`.
------------------------------------------------------------------------
<h3 id="++woad"><code>++woad</code></h3>
### `++woad`
Unescape cord
@ -519,7 +519,7 @@ Unescape cord codepoints.
------------------------------------------------------------------------
<h3 id="++wood"><code>++wood</code></h3>
### `++wood`
Escape cord

View File

@ -1,7 +1,7 @@
section 2eK, formatting (layout)
================================
<h3 id="++re"><code>++re</code></h3>
### `++re`
Pretty-printing engine
@ -15,7 +15,7 @@ Pretty-printing engine.
/~zod/try=> ~(. re leaf/"ham")
<2.ghl [[%leaf ""] <414.gly 100.xkc 1.ypj %164>]>
<h3 id="++ram"><code>++ram</code></h3>
### `++ram`
Flatten to tape
@ -42,7 +42,7 @@ Flatten tank out into a tape.
/~zod/try=> ~(ram re rose/["." "(" ")"]^~[leaf/"bar" leaf/"baz" leaf/"bam"])
"(bar.baz.bam)"
<h3 id="++win"><code>++win</code></h3>
### `++win`
Render at indent
@ -99,13 +99,13 @@ Render at indent level `tab` and width `edg`.
/~zod/try=> (~(win re rose/["--" "[" "]"]^~[leaf/"1423" leaf/"2316"]) 0 10)
<<"[ 1423" " 2316" "]">>
<h3 id="++din"><code>++din</code></h3>
### `++din`
++ din (mod (add 2 tab) (mul 2 (div edg 3)))
XX document
<h3 id="++fit"><code>++fit</code></h3>
### `++fit`
Fit on one line test
@ -113,7 +113,7 @@ Fit on one line test
Determine whether `tac` fits on one line. Internal to `++win`
<h3 id="++rig"><code>++rig</code></h3>
### `++rig`
Wrap in `\/`
@ -139,7 +139,7 @@ Wrap in `\/`
Wrap tape in `\/` if it doesn't fit at current indentation. Internal to
`++win`
<h3 id="++wig"><code>++wig</code></h3>
### `++wig`
`++win` render tape

View File

@ -1,7 +1,7 @@
section 2eL, formatting (path)
==============================
<h3 id="++ab"><code>++ab</code></h3>
### `++ab`
Primitive parser engine
@ -15,7 +15,7 @@ A core containing numeric parser primitives.
------------------------------------------------------------------------
<h3 id="++bix"><code>++bix</code></h3>
### `++bix`
Parse hex pair
@ -32,7 +32,7 @@ Parsing rule. Parses a pair of base-16 digits. Used in escapes.
------------------------------------------------------------------------
<h3 id="++hif"><code>++hif</code></h3>
### `++hif`
Parse phonetic pair
@ -48,7 +48,7 @@ encoded phonetically.
------------------------------------------------------------------------
<h3 id="++huf"><code>++huf</code></h3>
### `++huf`
Parse two phonetic pairs
@ -68,7 +68,7 @@ of two two-byte pairs that are encoded (and scrambled) phonetically.
------------------------------------------------------------------------
<h3 id="++hyf"><code>++hyf</code></h3>
### `++hyf`
Parse 8 phonetic bytes
@ -84,7 +84,7 @@ phonetic bytes.
------------------------------------------------------------------------
<h3 id="++pev"><code>++pev</code></h3>
### `++pev`
Parse \<= 5 base-32
@ -104,7 +104,7 @@ Parsing rule. Parses up to five base-32 digits without a leading zero.
------------------------------------------------------------------------
<h3 id="++pew"><code>++pew</code></h3>
### `++pew`
Parse \<= 5 base-64
@ -127,7 +127,7 @@ Parsing rule. Parses up to five base-64 digits without a leading zero.
------------------------------------------------------------------------
<h3 id="++piv"><code>++piv</code></h3>
### `++piv`
Parse 5 base-32
@ -143,7 +143,7 @@ Parsing rule. Parses exactly five base-32 digits.
------------------------------------------------------------------------
<h3 id="++piw"><code>++piw</code></h3>
### `++piw`
Parse 5 base-64
@ -159,7 +159,7 @@ Parsing rule. Parses exactly five base-64 digits.
------------------------------------------------------------------------
<h3 id="++qeb"><code>++qeb</code></h3>
### `++qeb`
Parse \<= 4 binary
@ -183,7 +183,7 @@ a leading zero.
------------------------------------------------------------------------
<h3 id="++qex"><code>++qex</code></h3>
### `++qex`
Parse \<= 4 hex
@ -205,7 +205,7 @@ without a leading zero.
------------------------------------------------------------------------
<h3 id="++qib"><code>++qib</code></h3>
### `++qib`
Parse 4 binary
@ -223,7 +223,7 @@ Parsing rule. Parses exactly four binary digits.
------------------------------------------------------------------------
<h3 id="++qix"><code>++qix</code></h3>
### `++qix`
Parse 4 hex
@ -241,7 +241,7 @@ Parsing rule. Parses exactly four hexadecimal digits.
------------------------------------------------------------------------
<h3 id="++seb"><code>++seb</code></h3>
### `++seb`
Parse 1
@ -260,7 +260,7 @@ Parsing rule. Parses the number 1.
------------------------------------------------------------------------
<h3 id="++sed"><code>++sed</code></h3>
### `++sed`
Parse decimal
@ -276,7 +276,7 @@ Parsing rule. Parses a nonzero decimal digit.
------------------------------------------------------------------------
<h3 id="++sev"><code>++sev</code></h3>
### `++sev`
Parse base-32
@ -292,7 +292,7 @@ Parsing rule. Parses a nonzero base-32 digit
------------------------------------------------------------------------
<h3 id="++sew"><code>++sew</code></h3>
### `++sew`
Parse base-64
@ -308,7 +308,7 @@ Parsing rule. Parses a nonzero base-64 digit
------------------------------------------------------------------------
<h3 id="++sex"><code>++sex</code></h3>
### `++sex`
Parse hex
@ -324,7 +324,7 @@ Parsing rule. Parses a nonzero hexadecimal digit.
------------------------------------------------------------------------
<h3 id="++sib"><code>++sib</code></h3>
### `++sib`
Parse binary
@ -339,7 +339,7 @@ Parsing rule. Parses a binary digit.
------------------------------------------------------------------------
<h3 id="++sid"><code>++sid</code></h3>
### `++sid`
Parse decimal
@ -352,7 +352,7 @@ Parsing rule. Parses a decimal digit.
------------------------------------------------------------------------
<h3 id="++siv"><code>++siv</code></h3>
### `++siv`
Parse base-32
@ -365,7 +365,7 @@ Parsing rule. Parses a base-32 digit.
------------------------------------------------------------------------
<h3 id="++siw"><code>++siw</code></h3>
### `++siw`
Parse base-64
@ -378,7 +378,7 @@ Parsing rule. Parses a base-64 digit.
------------------------------------------------------------------------
<h3 id="++six"><code>++six</code></h3>
### `++six`
Parse hex
@ -391,7 +391,7 @@ Parsing rule. Parses a hexadecimal digit.
------------------------------------------------------------------------
<h3 id="++sov"><code>++sov</code></h3>
### `++sov`
Parse base-32
@ -404,7 +404,7 @@ Parsing rule. Parses a base-32 letter.
------------------------------------------------------------------------
<h3 id="++sow"><code>++sow</code></h3>
### `++sow`
Parse base-64
@ -422,7 +422,7 @@ Parsing rule. Parses a base-64 letter/symbol.
------------------------------------------------------------------------
<h3 id="++sox"><code>++sox</code></h3>
### `++sox`
Parse hex letter
@ -435,7 +435,7 @@ Parsing rule. Parses a hexadecimal letter.
------------------------------------------------------------------------
<h3 id="++ted"><code>++ted</code></h3>
### `++ted`
Parse \<= 3 decimal
@ -456,7 +456,7 @@ leading zero.
------------------------------------------------------------------------
<h3 id="++tip"><code>++tip</code></h3>
### `++tip`
Leading phonetic byte
@ -472,7 +472,7 @@ syllable.
------------------------------------------------------------------------
<h3 id="++tiq"><code>++tiq</code></h3>
### `++tiq`
Trailing phonetic syllable
@ -488,7 +488,7 @@ syllable.
------------------------------------------------------------------------
<h3 id="++tid"><code>++tid</code></h3>
### `++tid`
Parse 3 decimal digits
@ -504,7 +504,7 @@ Parsing rule. Parses exactly three decimal digits.
------------------------------------------------------------------------
<h3 id="++til"><code>++til</code></h3>
### `++til`
Parse 3 lowercase
@ -522,7 +522,7 @@ Parsing rule. Parses exactly three lowercase letters.
------------------------------------------------------------------------
<h3 id="++urs"><code>++urs</code></h3>
### `++urs`
Parse span characters
@ -539,7 +539,7 @@ Parsing rule. Parses characters from an atom of the span odor [`@ta`]().
------------------------------------------------------------------------
<h3 id="++urt"><code>++urt</code></h3>
### `++urt`
Parse non-`_` span
@ -555,7 +555,7 @@ for cab, `_`.
------------------------------------------------------------------------
<h3 id="++voy"><code>++voy</code></h3>
### `++voy`
Parse bas, soq, or bix
@ -571,7 +571,7 @@ byte.
------------------------------------------------------------------------
<h3 id="++ag"><code>++ag</code></h3>
### `++ag`
Top-level atom parser engine
@ -585,7 +585,7 @@ A core containing top-level atom parsers.
------------------------------------------------------------------------
<h3 id="++ape"><code>++ape</code></h3>
### `++ape`
Parse 0 or rule
@ -600,7 +600,7 @@ Parser modifier. Parses 0 or the sample rule `fel`.
------------------------------------------------------------------------
<h3 id="++bay"><code>++bay</code></h3>
### `++bay`
Parses binary number
@ -613,7 +613,7 @@ Parsing rule. Parses a binary number without a leading zero.
------------------------------------------------------------------------
<h3 id="++bip"><code>++bip</code></h3>
### `++bip`
Parse IPv6
@ -629,7 +629,7 @@ Parsing rule. Parses a [`@is`](), an IPv6 address.
------------------------------------------------------------------------
<h3 id="++dem"><code>++dem</code></h3>
### `++dem`
Parse decimal with dots
@ -644,7 +644,7 @@ Parsing rule. Parses a decimal number that includes dot separators.
------------------------------------------------------------------------
<h3 id="++dim"><code>++dim</code></h3>
### `++dim`
Parse decimal number
@ -660,7 +660,7 @@ Parsing rule. Parses a decimal number without a leading zero.
------------------------------------------------------------------------
<h3 id="++dum"><code>++dum</code></h3>
### `++dum`
Parse decimal with leading `0`
@ -677,7 +677,7 @@ Parsing rule. Parses a decmial number with leading zeroes.
------------------------------------------------------------------------
<h3 id="++fed"><code>++fed</code></h3>
### `++fed`
Parse phonetic base
@ -707,7 +707,7 @@ Parsing rule. Parses an atom of odor [`@p`](), the phonetic base.
------------------------------------------------------------------------
<h3 id="++hex"><code>++hex</code></h3>
### `++hex`
Parse hex
@ -726,7 +726,7 @@ Parsing rule. Parses a hexadecimal number
------------------------------------------------------------------------
<h3 id="++lip"><code>++lip</code></h3>
### `++lip`
Parse IPv4 address
@ -744,7 +744,7 @@ Parsing rule. Parses an IPv4 address.
------------------------------------------------------------------------
<h3 id="++viz"><code>++viz</code></h3>
### `++viz`
Parse Base-32 with dots
@ -757,7 +757,7 @@ Parsing rule. Parses a Base-32 number with dot separators.
------------------------------------------------------------------------
<h3 id="++vum"><code>++vum</code></h3>
### `++vum`
Parse base-32 string
@ -770,7 +770,7 @@ Parsing rule. Parses a raw base-32 string.
------------------------------------------------------------------------
<h3 id="++wiz"><code>++wiz</code></h3>
### `++wiz`
Parse base-64
@ -785,7 +785,7 @@ Parsing rule. Parses a base-64 number.
------------------------------------------------------------------------
<h3 id="++co"><code>++co</code></h3>
### `++co`
Literal rendering engine
@ -809,7 +809,7 @@ A [door]() that contains arms that operate on the sample coin `lot`.
------------------------------------------------------------------------
<h3 id="++rear"><code>++rear</code></h3>
### `++rear`
Prepend & render as tape
@ -826,7 +826,7 @@ Renders a coin `lot` as a [tape]() prepended to the sample tape `rom`.
------------------------------------------------------------------------
<h3 id="++rent"><code>++rent</code></h3>
### `++rent`
Render as span
@ -843,7 +843,7 @@ Renders a coin `lot` as a span.
------------------------------------------------------------------------
<h3 id="++rend"><code>++rend</code></h3>
### `++rend`
Render as tape
@ -1073,7 +1073,7 @@ Renders a coin `lot` as a tape.
------------------------------------------------------------------------
<h3 id="++ne"><code>++ne</code></h3>
### `++ne`
Digit rendering engine
@ -1090,7 +1090,7 @@ A [door]() containing arms that render digits at bases 10, 16, 32, and
------------------------------------------------------------------------
<h3 id="++d"><code>++d</code></h3>
### `++d`
Render decimal
@ -1105,7 +1105,7 @@ Renders a decimal digit as an atom of an ACII byte value.
------------------------------------------------------------------------
<h3 id="++x"><code>++x</code></h3>
### `++x`
Render hex
@ -1122,7 +1122,7 @@ Renders a hexadecimal digit as an atom of an ASCII byte value.
------------------------------------------------------------------------
<h3 id="++v"><code>++v</code></h3>
### `++v`
Render base-32
@ -1139,7 +1139,7 @@ Renders a base-32 digit as an atom of an ASCII byte value.
------------------------------------------------------------------------
<h3 id="++w"><code>++w</code></h3>
### `++w`
Render base-64
@ -1168,7 +1168,7 @@ Renders a base-64 digit as an atom of an ASCII byte value.
------------------------------------------------------------------------
<h3 id="++mu"><code>++mu</code></h3>
### `++mu`
Core used to scramble 16-bit atoms
@ -1188,7 +1188,7 @@ relationship between a destroyer and its cruiser.
------------------------------------------------------------------------
<h3 id="++zag"><code>++zag</code></h3>
### `++zag`
Add bottom into top
@ -1207,7 +1207,7 @@ destroyer.
------------------------------------------------------------------------
<h3 id="++zig"><code>++zig</code></h3>
### `++zig`
Subtract bottom from top
@ -1227,7 +1227,7 @@ destroyer.
------------------------------------------------------------------------
<h3 id="++zug"><code>++zug</code></h3>
### `++zug`
Concatenate into atom
@ -1245,7 +1245,7 @@ destroyer name.
------------------------------------------------------------------------
<h3 id="++so"><code>++so</code></h3>
### `++so`
Coin parser engine
@ -1259,7 +1259,7 @@ Core containing arms that parse [`++coin`]s.
------------------------------------------------------------------------
<h3 id="++bisk"><code>++bisk</code></h3>
### `++bisk`
Parse odor-atom pair
@ -1287,7 +1287,7 @@ producing a [`++dime`]().
------------------------------------------------------------------------
<h3 id="++crub"><code>++crub</code></h3>
### `++crub`
Parse `@da`, `@dr`, `@p`, `@t`
@ -1364,7 +1364,7 @@ and [`@t`](), producing a [`++dime`]().
------------------------------------------------------------------------
<h3 id="++nuck"><code>++nuck</code></h3>
### `++nuck`
Top-level coin parser
@ -1406,7 +1406,7 @@ corresponding [`++coin`]() parser.
------------------------------------------------------------------------
<h3 id="++nusk"><code>++nusk</code></h3>
### `++nusk`
Parse coin literal with escapes
@ -1427,7 +1427,7 @@ formatting).
------------------------------------------------------------------------
<h3 id="++perd"><code>++perd</code></h3>
### `++perd`
Parsing rule.
@ -1451,7 +1451,7 @@ prefixes.
------------------------------------------------------------------------
<h3 id="++royl"><code>++royl</code></h3>
### `++royl`
Parse dime float
@ -1487,7 +1487,7 @@ Parsing rule. Parses a number into a [`++dime`]() float.
------------------------------------------------------------------------
<h3 id="++royl-cell"><code>++royl-cell</code></h3>
### `++royl-cell`
XX still not fully functional
@ -1504,7 +1504,7 @@ Intermediate parsed float convereter
------------------------------------------------------------------------
<h3 id="++tash"><code>++tash</code></h3>
### `++tash`
Parse signed dime
@ -1533,7 +1533,7 @@ Parsing rule. Parses a signed number into a [`++dime`]().
------------------------------------------------------------------------
<h3 id="++twid"><code>++twid</code></h3>
### `++twid`
Parse coins without `~` prefix
@ -1559,7 +1559,7 @@ Parsing rule. Parses coins after a leading sig, `~`.
------------------------------------------------------------------------
<h3 id="++zust"><code>++zust</code></h3>
### `++zust`
Parse prefixed dimes from `@if`, `@f`, `@rd`
@ -1590,7 +1590,7 @@ Parsing rule. Parses an atom of either [`@if`]() (IP address), [`@f`]()
------------------------------------------------------------------------
<h3 id="++scot"><code>++scot</code></h3>
### `++scot`
Render dime as cord
@ -1619,7 +1619,7 @@ Renders a dime `mol` as a cord.
------------------------------------------------------------------------
<h3 id="++scow"><code>++scow</code></h3>
### `++scow`
Render dime as tape
@ -1640,7 +1640,7 @@ Renders `mol` as a tape.
------------------------------------------------------------------------
<h3 id="++slat"><code>++slat</code></h3>
### `++slat`
Curried slaw
@ -1664,7 +1664,7 @@ odor specified by `mod`.
------------------------------------------------------------------------
<h3 id="++slav"><code>++slav</code></h3>
### `++slav`
Demand: parse span with input odor
@ -1696,7 +1696,7 @@ if it failes to parse.
------------------------------------------------------------------------
<h3 id="++slaw"><code>++slaw</code></h3>
### `++slaw`
Parse span to input odor
@ -1732,7 +1732,7 @@ Parses a span `txt` to an atom of the odor specified by `mod`.
------------------------------------------------------------------------
<h3 id="++slay"><code>++slay</code></h3>
### `++slay`
Parse span to coin
@ -1777,7 +1777,7 @@ Parses a span `txt` to the unit of a [`++coin`]().
------------------------------------------------------------------------
<h3 id="++smyt"><code>++smyt</code></h3>
### `++smyt`
Render path as tank
@ -1809,7 +1809,7 @@ pretty-printing.
------------------------------------------------------------------------
<h3 id="++spat"><code>++spat</code></h3>
### `++spat`
Render path as cord
@ -1828,7 +1828,7 @@ Renders a path `pax` as cord.
------------------------------------------------------------------------
<h3 id="++spud"><code>++spud</code></h3>
### `++spud`
Render path as tape
@ -1847,7 +1847,7 @@ Renders a path `pax` as [tape]().
------------------------------------------------------------------------
<h3 id="++stab"><code>++stab</code></h3>
### `++stab`
Parse span to path

View File

@ -1,7 +1,7 @@
section 2eM, regular-expressions
================================
<h3 id="++pars"><code>++pars</code></h3>
### `++pars`
++ pars
|= [a=tape] :: parse tape to rege
@ -66,44 +66,44 @@ Parse regular expression
~zod/try=> (pars "a\{1,20}")
[~ [%betw p=[%lite p=~~a] q=1 r=20]]
<h3 id="++rags"><code>++rags</code></h3>
### `++rags`
++ rags :: rege parsers
=> |%
Regex parser arms
<h3 id="++nor"><code>++nor</code></h3>
### `++nor`
++ nor ;~(less (mask "^$()|*?+.[\\") (shim 1 127)) :: non-control char
XX document
<h3 id="++les"><code>++les</code></h3>
### `++les`
++ les ;~(less bas asp) :: not backslash
XX document
<h3 id="++lep"><code>++lep</code></h3>
### `++lep`
++ lep ;~(less (mask "^[]\\") asp) :: charset non-control
XX document
<h3 id="++asp"><code>++asp</code></h3>
### `++asp`
++ asp (shim 32 126) :: printable ascii
XX document
<h3 id="++alb"><code>++alb</code></h3>
### `++alb`
++ alb ;~(less ser asp) :: charset literal char
XX document
<h3 id="++mis"><code>++mis</code></h3>
### `++mis`
++ mis ;~(less aln asp) :: non alphanumeric
--
@ -111,7 +111,7 @@ XX document
XX document
<h3 id="++apex"><code>++apex</code></h3>
### `++apex`
++ apex :: top level
%+ knee *rege |. ~+
@ -124,7 +124,7 @@ XX document
XX document
<h3 id="++mall"><code>++mall</code></h3>
### `++mall`
++ mall
%+ knee *rege |. ~+
@ -133,7 +133,7 @@ XX document
XX document
<h3 id="++bets"><code>++bets</code></h3>
### `++bets`
++ bets
%+ knee *rege |. ~+
@ -162,7 +162,7 @@ XX document
XX document
<h3 id="++ranc"><code>++ranc</code></h3>
### `++ranc`
++ ranc
|= [a=@ b=@]
@ -172,14 +172,14 @@ XX document
XX document
<h3 id="++flap"><code>++flap</code></h3>
### `++flap`
++ flap |=(a=@ (mix a (dec (bex 256))))
::
XX document
<h3 id="++rang"><code>++rang</code></h3>
### `++rang`
++ rang
%+ sear |=([a=@ b=@] ?:((lte a b) (some [a b]) ~))
@ -188,7 +188,7 @@ XX document
XX document
<h3 id="++chun"><code>++chun</code></h3>
### `++chun`
++ chun
%+ knee *rege |. ~+
@ -212,7 +212,7 @@ XX document
XX document
<h3 id="++seac"><code>++seac</code></h3>
### `++seac`
++ seac
|= tub=nail
@ -225,7 +225,7 @@ XX document
XX document
<h3 id="++sead"><code>++sead</code></h3>
### `++sead`
++ sead
%+ knee *@ |. ~+
@ -264,7 +264,7 @@ XX document
XX document
<h3 id="++sade"><code>++sade</code></h3>
### `++sade`
++ sade
%+ knee *@ |. ~+
@ -277,7 +277,7 @@ XX document
XX document
<h3 id="++seap"><code>++seap</code></h3>
### `++seap`
++ seap
%+ knee *@ |. ~+
@ -305,7 +305,7 @@ XX document
XX document
<h3 id="++cape"><code>++cape</code></h3>
### `++cape`
++ cape
%+ knee *tape |. ~+
@ -318,7 +318,7 @@ XX document
XX document
<h3 id="++chas"><code>++chas</code></h3>
### `++chas`
++ chas :: ascii character set
=- (sear ~(get by -) sym)
@ -350,37 +350,37 @@ XX document
XX document
<h3 id="++cntrl"><code>++cntrl</code></h3>
### `++cntrl`
++ cntrl :(con (ranc 0 31) (bex 127))
XX document
<h3 id="++digit"><code>++digit</code></h3>
### `++digit`
++ digit (ranc '0' '9')
XX document
<h3 id="++graph"><code>++graph</code></h3>
### `++graph`
++ graph (ranc 33 126)
XX document
<h3 id="++lower"><code>++lower</code></h3>
### `++lower`
++ lower (ranc 'a' 'z')
XX document
<h3 id="++print"><code>++print</code></h3>
### `++print`
++ print (ranc 32 126)
XX document
<h3 id="++punct"><code>++punct</code></h3>
### `++punct`
++ punct ;: con
(ranc '!' '/')
@ -391,38 +391,38 @@ XX document
XX document
<h3 id="++space"><code>++space</code></h3>
### `++space`
++ space :(con (ranc 9 13) (bex ' '))
XX document
<h3 id="++upper"><code>++upper</code></h3>
### `++upper`
++ upper (ranc 'A' 'Z')
XX document
<h3 id="++white"><code>++white</code></h3>
### `++white`
++ white :(con (bex ' ') (ranc 9 10) (ranc 12 13))
XX document
<h3 id="++wordc"><code>++wordc</code></h3>
### `++wordc`
++ wordc :(con digit lower upper (bex '_'))
XX document
<h3 id="++xdigit"><code>++xdigit</code></h3>
### `++xdigit`
++ xdigit :(con (ranc 'a' 'f') (ranc 'A' 'F') digit)
::
XX document
<h3 id="++chad"><code>++chad</code></h3>
### `++chad`
++ chad
%+ knee *rege |. ~+
@ -431,7 +431,7 @@ XX document
XX document
<h3 id="++escd"><code>++escd</code></h3>
### `++escd`
++ escd
%+ knee *@ |. ~+
@ -452,7 +452,7 @@ XX document
XX document
<h3 id="++escp"><code>++escp</code></h3>
### `++escp`
++ escp
%+ knee *rege |. ~+
@ -481,7 +481,7 @@ XX document
XX document
<h3 id="++unid"><code>++unid</code></h3>
### `++unid`
++ unid
%+ knee *@ |. ~+
@ -498,14 +498,14 @@ XX document
XX document
<h3 id="++ra"><code>++ra</code></h3>
### `++ra`
++ ra :: regex engine
|_ a=rege
XX document
<h3 id="++proc"><code>++proc</code></h3>
### `++proc`
++ proc :: capture numbering
|= b=@
@ -544,7 +544,7 @@ XX document
XX document
<h3 id="++cont"><code>++cont</code></h3>
### `++cont`
++ cont
|= [a=(map ,@u tape) b=(map ,@u tape)]
@ -553,7 +553,7 @@ XX document
XX document
<h3 id="++abor"><code>++abor</code></h3>
### `++abor`
++ abor
|= [a=char b=(unit ,[tape (map ,@u tape)])]
@ -565,7 +565,7 @@ XX document
XX document
<h3 id="++matc"><code>++matc</code></h3>
### `++matc`
++ matc
|= [b=tape c=tape]
@ -576,7 +576,7 @@ XX document
XX document
<h3 id="++chet"><code>++chet</code></h3>
### `++chet`
++ chet
|= [b=(unit ,[tape (map ,@u tape)]) c=tape d=tape]
@ -592,19 +592,19 @@ XX document
XX document
<h3 id="++blak"><code>++blak</code></h3>
### `++blak`
++ blak (some ["" _(map ,@u tape)])
XX document
<h3 id="++word"><code>++word</code></h3>
### `++word`
++ word |=(a=char =((dis wordc:rags (bex a)) 0))
XX document
<h3 id="++deep"><code>++deep</code></h3>
### `++deep`
++ deep
|= [b=tape c=rege d=tape]
@ -704,7 +704,7 @@ XX document
XX document
<h3 id="++rexp"><code>++rexp</code></h3>
### `++rexp`
++ rexp :: Regex match
~/ %rexp
@ -733,7 +733,7 @@ XX document
XX document
<h3 id="++repg"><code>++repg</code></h3>
### `++repg`
++ repg :: Global regex replace
~/ %repg

View File

@ -1,7 +1,7 @@
section 2eN, pseudo-cryptography
================================
<h3 id="++un"><code>++un</code></h3>
### `++un`
Reversible scrambling core
@ -13,7 +13,7 @@ Used in the `@p` phonetic base.
------------------------------------------------------------------------
<h3 id="++wren"><code>++wren</code></h3>
### `++wren`
Conceal structure
@ -50,7 +50,7 @@ on the result, pushing it forward. Produces an atom.
------------------------------------------------------------------------
<h3 id="++wred"><code>++wred</code></h3>
### `++wred`
Restore structure
@ -87,7 +87,7 @@ on the result, pushing it forward. Produces an atom.
------------------------------------------------------------------------
<h3 id="++xafo"><code>++xafo</code></h3>
### `++xafo`
Add modulo 255
@ -102,7 +102,7 @@ Produces the sum of two atoms modulo 255, encoded as a nonzero byte.
------------------------------------------------------------------------
<h3 id="++xaro"><code>++xaro</code></h3>
### `++xaro`
Subtract modulo 255
@ -118,7 +118,7 @@ nonzero byte.
------------------------------------------------------------------------
<h3 id="++zaft"><code>++zaft</code></h3>
### `++zaft`
Look up in 255 sub box
@ -154,7 +154,7 @@ box with 255 values, producing a unique nonzero byte.
------------------------------------------------------------------------
<h3 id="++zart"><code>++zart</code></h3>
### `++zart`
Reverse look up in 255 sub box
@ -187,7 +187,7 @@ the substitution box with 255 values, producing a unique nonzero byte.
------------------------------------------------------------------------
<h3 id="++zyft"><code>++zyft</code></h3>
### `++zyft`
Lookup byte in 256 sub box
@ -223,7 +223,7 @@ with 256 values, producing a byte.
------------------------------------------------------------------------
<h3 id="++zyrt"><code>++zyrt</code></h3>
### `++zyrt`
Reverse lookup byte in 256 sub box
@ -256,7 +256,7 @@ with 256 values, producing a byte.
~zod/try=> `@ux`(zyrt:un 187)
0xff
<h3 id="++ob"><code>++ob</code></h3>
### `++ob`
Reversible scrambling core, v2
@ -267,7 +267,7 @@ A core for performing reversible scrambling operations for the `@p` phonetic bas
------------------------------------------------------------------------
<h3 id="++feen"><code>++feen</code></h3>
### `++feen`
Conceal structure, v2
@ -286,7 +286,7 @@ Randomly permutes atoms that fit into 17 to 32 bits into one another. If the ato
------------------------------------------------------------------------
<h3 id="++fend"><code>++fend</code></h3>
### `++fend`
++ fend :: restore structure v2
|= cry=@ ^- @
@ -303,7 +303,7 @@ Randomly permutes atoms that fit into 17 to 32 bits into one another, and random
------------------------------------------------------------------------
<h3 id="++fice"><code>++fice</code></h3>
### `++fice`
++ fice :: adapted from
|= nor=@ :: black and rogaway
@ -319,7 +319,7 @@ Applies a 3-round Feistel-like cipher to randomly permute atoms in the range `0`
------------------------------------------------------------------------
<h3 id="++teil"><code>++teil</code></h3>
### `++teil`
++ teil :: reverse ++fice
|= vip=@
@ -335,7 +335,7 @@ Applies the reverse of the Feistel-like cipher applied by [`++fice`](). Unlike a
------------------------------------------------------------------------
<h3 id="++rynd"><code>++rynd</code></h3>
### `++rynd`
++ rynd :: feistel round
|= [n=@ l=@ r=@]
@ -349,7 +349,7 @@ A single round of the Feistel-like cipher [`++fice`](). AES ([`++aesc`]()) is us
------------------------------------------------------------------------
<h3 id="++rund"><code>++rund</code></h3>
### `++rund`
++ rund :: reverse round
|= [n=@ l=@ r=@]
@ -363,7 +363,7 @@ A single round of the Feistel-like reverse cipher [`++teil`]().
------------------------------------------------------------------------
<h3 id="++raku"><code>++raku</code></h3>
### `++raku`
++ raku
^- (list ,@ux)

View File

@ -1,7 +1,7 @@
section 2eO, virtualization
===========================
<h3 id="++mack"><code>++mack</code></h3>
### `++mack`
Nock subject to unit
@ -33,7 +33,7 @@ producing a `~`.
------------------------------------------------------------------------
<h3 id="++mink"><code>++mink</code></h3>
### `++mink`
Mock interpreter
@ -143,7 +143,7 @@ result becomes a `%1` `++tone`, indicating a block.
------------------------------------------------------------------------
<h3 id="++mock"><code>++mock</code></h3>
### `++mock`
Compute formula on subject with hint
@ -180,7 +180,7 @@ indicating a block.
------------------------------------------------------------------------
<h3 id="++mook"><code>++mook</code></h3>
### `++mook`
Intelligently render crash annotation
@ -250,7 +250,7 @@ Each may be a tank, cord, [`++spot`](), or trapped tank. Produces a
------------------------------------------------------------------------
<h3 id="++mang"><code>++mang</code></h3>
### `++mang`
Unit: Slam gate with sample
@ -292,7 +292,7 @@ Similar to [`++mong`]().
------------------------------------------------------------------------
<h3 id="++mong"><code>++mong</code></h3>
### `++mong`
Slam gate with sample
@ -334,7 +334,7 @@ Produces a [`++toon`]() computation result from slamming `gat` with
------------------------------------------------------------------------
<h3 id="++mung"><code>++mung</code></h3>
### `++mung`
Virtualize slamming gate
@ -376,7 +376,7 @@ Produces a [`++tone`]() computation result from slamming `gat` with
------------------------------------------------------------------------
<h3 id="++mule"><code>++mule</code></h3>
### `++mule`
Typed virtual
@ -415,7 +415,7 @@ the way. Used to lazily compute stack traces.
------------------------------------------------------------------------
<h3 id="++mute"><code>++mute</code></h3>
### `++mute`
Untyped virtual

View File

@ -8,7 +8,7 @@ anyway.
------------------------------------------------------------------------
<h3 id="++berk"><code>++berk</code></h3>
### `++berk`
Invert diff patches
@ -39,7 +39,7 @@ swapped. Produces a `bur`.
------------------------------------------------------------------------
<h3 id="++diff"><code>++diff</code></h3>
### `++diff`
Generate patch
@ -84,7 +84,7 @@ Produces a patch between two nouns, by change type
------------------------------------------------------------------------
<h3 id="++loss"><code>++loss</code></h3>
### `++loss`
Longest subsequence
@ -173,7 +173,7 @@ several internal helper arms. Produces a [`++tape`]().
------------------------------------------------------------------------
<h3 id="++locz"><code>++locz</code></h3>
### `++locz`
Find common
@ -204,7 +204,7 @@ producing a [\`++tape]().
------------------------------------------------------------------------
<h3 id="++lore"><code>++lore</code></h3>
### `++lore`
Split on `\n`
@ -240,7 +240,7 @@ Split on newlines, ascii `10`
------------------------------------------------------------------------
<h3 id="++role"><code>++role</code></h3>
### `++role`
Join with `\n`
@ -262,7 +262,7 @@ Join line list with newlines.
------------------------------------------------------------------------
<h3 id="++lump"><code>++lump</code></h3>
### `++lump`
Change with `++udon`
@ -309,7 +309,7 @@ Use udon to change noun
------------------------------------------------------------------------
<h3 id="++lure"><code>++lure</code></h3>
### `++lure`
Patch `a`
@ -332,7 +332,7 @@ Patch a by references to axis and literal.
------------------------------------------------------------------------
<h3 id="++limp"><code>++limp</code></h3>
### `++limp`
Reverse patch
@ -357,7 +357,7 @@ Reverse a patch (preprocessor unchanged)
------------------------------------------------------------------------
<h3 id="++hump"><code>++hump</code></h3>
### `++hump`
Prep for diff
@ -387,7 +387,7 @@ Prep atom for diff: leave alone, cue, or split by newlines.
------------------------------------------------------------------------
<h3 id="++husk"><code>++husk</code></h3>
### `++husk`
Atomize post diff
@ -434,7 +434,7 @@ Re-atomize after diff: leave alone, jam, or join with newlines.
------------------------------------------------------------------------
<h3 id="++lurk"><code>++lurk</code></h3>
### `++lurk`
Apply list patch
@ -474,7 +474,7 @@ Amend list using an urge: list of `[%& {number skipped}]` and
------------------------------------------------------------------------
<h3 id="++lusk"><code>++lusk</code></h3>
### `++lusk`
`lcs` to list patch
@ -535,7 +535,7 @@ Using a common sequence, generate urge from two lists
------------------------------------------------------------------------
<h3 id="++nude"><code>++nude</code></h3>
### `++nude`
Tree change

View File

@ -1,7 +1,7 @@
section 2eW, lite number theory
===============================
<h3 id="++egcd"><code>++egcd</code></h3>
### `++egcd`
GCD
@ -41,7 +41,7 @@ Greatest common denominator
------------------------------------------------------------------------
<h3 id="++pram"><code>++pram</code></h3>
### `++pram`
Probable prime
@ -97,7 +97,7 @@ Probable prime test
------------------------------------------------------------------------
<h3 id="++ramp"><code>++ramp</code></h3>
### `++ramp`
`r-m` prime
@ -132,7 +132,7 @@ using salt `c`.
------------------------------------------------------------------------
<h3 id="++fo"><code>++fo</code></h3>
### `++fo`
Prime engine
@ -148,7 +148,7 @@ Core for performing arithmetic modulo a prime number
------------------------------------------------------------------------
<h3 id="++dif"><code>++dif</code></h3>
### `++dif`
Difference
@ -166,7 +166,7 @@ Subtract
------------------------------------------------------------------------
<h3 id="++exp"><code>++exp</code></h3>
### `++exp`
Exponent
@ -186,7 +186,7 @@ Exponent
------------------------------------------------------------------------
<h3 id="++fra"><code>++fra</code></h3>
### `++fra`
Divide
@ -204,7 +204,7 @@ Divide
------------------------------------------------------------------------
<h3 id="++inv"><code>++inv</code></h3>
### `++inv`
Inverse
@ -225,7 +225,7 @@ Multiplicative inverse
------------------------------------------------------------------------
<h3 id="++pro"><code>++pro</code></h3>
### `++pro`
Product
@ -243,7 +243,7 @@ Product
------------------------------------------------------------------------
<h3 id="++sit"><code>++sit</code></h3>
### `++sit`
Bounds
@ -261,7 +261,7 @@ Bounds check
------------------------------------------------------------------------
<h3 id="++sum"><code>++sum</code></h3>
### `++sum`
Sum
@ -279,7 +279,7 @@ Add
------------------------------------------------------------------------
<h3 id="++ga"><code>++ga</code></h3>
### `++ga`
++ ga :: GF (bex p.a)
|= a=[p=@ q=@ r=@] :: dim poly gen
@ -293,7 +293,7 @@ XX document
------------------------------------------------------------------------
<h3 id="++dif"><code>++dif</code></h3>
### `++dif`
++ dif :: add and sub
|= [b=@ c=@]
@ -306,7 +306,7 @@ XX document
------------------------------------------------------------------------
<h3 id="++dub"><code>++dub</code></h3>
### `++dub`
++ dub :: mul by x
|= b=@
@ -321,7 +321,7 @@ XX document
------------------------------------------------------------------------
<h3 id="++pro"><code>++pro</code></h3>
### `++pro`
++ pro :: slow multiply
|= [b=@ c=@]
@ -336,7 +336,7 @@ XX document
------------------------------------------------------------------------
<h3 id="++toe"><code>++toe</code></h3>
### `++toe`
++ toe :: exp/log tables
=+ ^= nu
@ -367,7 +367,7 @@ XX document
------------------------------------------------------------------------
<h3 id="++sit"><code>++sit</code></h3>
### `++sit`
++ sit :: reduce
|= b=@
@ -378,7 +378,7 @@ XX document
------------------------------------------------------------------------
<h3 id="++fra"><code>++fra</code></h3>
### `++fra`
++ fra :: divide
|= [b=@ c=@]
@ -389,7 +389,7 @@ XX document
------------------------------------------------------------------------
<h3 id="++inv"><code>++inv</code></h3>
### `++inv`
++ inv :: invert
|= b=@
@ -404,7 +404,7 @@ XX document
------------------------------------------------------------------------
<h3 id="++pow"><code>++pow</code></h3>
### `++pow`
++ pow :: exponent
|= [b=@ c=@]
@ -421,7 +421,7 @@ XX document
------------------------------------------------------------------------
<h3 id="++pro"><code>++pro</code></h3>
### `++pro`
++ pro :: multiply
|= [b=@ c=@]

View File

@ -3,7 +3,7 @@ section 2eX, jetted crypto
------------------------------------------------------------------------
<h3 id="++aesc"><code>++aesc</code></h3>
### `++aesc`
++ aesc :: AES-256
~% %aesc + ~
@ -11,7 +11,7 @@ section 2eX, jetted crypto
XX document
<h3 id="++en"><code>++en</code></h3>
### `++en`
++ en :: ECB enc
~/ %en
@ -21,7 +21,7 @@ XX document
XX document
<h3 id="++de"><code>++de</code></h3>
### `++de`
++ de :: ECB dec
~/ %de
@ -32,7 +32,7 @@ XX document
XX document
<h3 id="++ahem"><code>++ahem</code></h3>
### `++ahem`
++ ahem :: AES helpers
:: XX should be in aesc, isn't for performance reasons
@ -44,20 +44,20 @@ XX document
XX document
<h3 id="++cipa"><code>++cipa</code></h3>
### `++cipa`
++ cipa :: AES params
$_ ^? |%
XX document
<h3 id="++co"><code>++co</code></h3>
### `++co`
++ co [0xe 0xb 0xd 0x9]
XX document
<h3 id="++ix"><code>++ix</code></h3>
### `++ix`
++ ix :: key expand, inv
|= a=@ ^- @
@ -82,13 +82,13 @@ XX document
XX document
<h3 id="++ro"><code>++ro</code></h3>
### `++ro`
++ ro [0 3 2 1]
XX document
<h3 id="++su"><code>++su</code></h3>
### `++su`
++ su 0x7d0c.2155.6314.69e1.26d6.77ba.7e04.2b17.
6199.5383.3cbb.ebc8.b0f5.2aae.4d3b.e0a0.
@ -111,7 +111,7 @@ XX document
XX document
<h3 id="++pen"><code>++pen</code></h3>
### `++pen`
++ pen :: encrypt
^- cipa
@ -119,13 +119,13 @@ XX document
XX document
<h3 id="++co"><code>++co</code></h3>
### `++co`
++ co [0xe 0xb 0xd 0x9]
XX document
<h3 id="++ix"><code>++ix</code></h3>
### `++ix`
++ ix :: key expand, inv
|= a=@ ^- @
@ -150,13 +150,13 @@ XX document
XX document
<h3 id="++ro"><code>++ro</code></h3>
### `++ro`
++ ro [0 3 2 1]
XX document
<h3 id="++su"><code>++su</code></h3>
### `++su`
++ su 0x7d0c.2155.6314.69e1.26d6.77ba.7e04.2b17.
6199.5383.3cbb.ebc8.b0f5.2aae.4d3b.e0a0.
@ -179,7 +179,7 @@ XX document
XX document
<h3 id="++pin"><code>++pin</code></h3>
### `++pin`
++ pin :: decrypt
^- cipa
@ -187,13 +187,13 @@ XX document
XX document
<h3 id="++co"><code>++co</code></h3>
### `++co`
++ co [0xe 0xb 0xd 0x9]
XX document
<h3 id="++ix"><code>++ix</code></h3>
### `++ix`
++ ix :: key expand, inv
|= a=@ ^- @
@ -218,13 +218,13 @@ XX document
XX document
<h3 id="++ro"><code>++ro</code></h3>
### `++ro`
++ ro [0 3 2 1]
XX document
<h3 id="++su"><code>++su</code></h3>
### `++su`
++ su 0x7d0c.2155.6314.69e1.26d6.77ba.7e04.2b17.
6199.5383.3cbb.ebc8.b0f5.2aae.4d3b.e0a0.
@ -247,7 +247,7 @@ XX document
XX document
<h3 id="++mcol"><code>++mcol</code></h3>
### `++mcol`
++ mcol
|= [a=(list ,@) b=[p=@ q=@ r=@ s=@]] ^- (list ,@)
@ -273,7 +273,7 @@ XX document
XX document
<h3 id="++pode"><code>++pode</code></h3>
### `++pode`
++ pode :: explode to block
|= [a=bloq b=@ c=@] ^- (list ,@)
@ -286,7 +286,7 @@ XX document
XX document
<h3 id="++sube"><code>++sube</code></h3>
### `++sube`
++ sube :: s-box word
|= [a=@ b=@] ^- @
@ -296,7 +296,7 @@ XX document
XX document
<h3 id="++be"><code>++be</code></h3>
### `++be`
++ be :: block cipher
|= [a=? b=@ c=@H] ^- @uxH
@ -308,7 +308,7 @@ XX document
XX document
<h3 id="++ankh"><code>++ankh</code></h3>
### `++ankh`
++ ankh
|= [a=cipa b=@ c=@]
@ -316,7 +316,7 @@ XX document
XX document
<h3 id="++sark"><code>++sark</code></h3>
### `++sark`
++ sark
|= [c=(list ,@) d=(list ,@)] ^- (list ,@)
@ -326,7 +326,7 @@ XX document
XX document
<h3 id="++srow"><code>++srow</code></h3>
### `++srow`
++ srow
|= [a=cipa b=(list ,@)] ^- (list ,@)
@ -343,7 +343,7 @@ XX document
XX document
<h3 id="++subs"><code>++subs</code></h3>
### `++subs`
++ subs
|= [a=cipa b=(list ,@)] ^- (list ,@)
@ -367,7 +367,7 @@ XX document
XX document
<h3 id="++ex"><code>++ex</code></h3>
### `++ex`
++ ex :: key expand
|= a=@I ^- @
@ -389,7 +389,7 @@ XX document
XX document
<h3 id="++ix"><code>++ix</code></h3>
### `++ix`
++ ix :: key expand, inv
|= a=@ ^- @
@ -414,7 +414,7 @@ XX document
XX document
<h3 id="++curt"><code>++curt</code></h3>
### `++curt`
++ curt :: curve25519
|= [a=@ b=@]
@ -428,7 +428,7 @@ XX document
XX document
<h3 id="++cla"><code>++cla</code></h3>
### `++cla`
++ cla
|= raw=@
@ -439,19 +439,19 @@ XX document
XX document
<h3 id="++sqr"><code>++sqr</code></h3>
### `++sqr`
++ sqr |=(a=@ (mul a a))
XX document
<h3 id="++inv"><code>++inv</code></h3>
### `++inv`
++ inv |=(a=@ (~(exp fo q) (sub q 2) a))
XX document
<h3 id="++cad"><code>++cad</code></h3>
### `++cad`
++ cad
|= [n=[x=@ z=@] m=[x=@ z=@] d=[x=@ z=@]]
@ -473,7 +473,7 @@ XX document
XX document
<h3 id="++cub"><code>++cub</code></h3>
### `++cub`
++ cub
|= [x=@ z=@]
@ -505,7 +505,7 @@ XX document
XX document
<h3 id="++ed"><code>++ed</code></h3>
### `++ed`
++ ed :: ed25519
=>
@ -521,14 +521,14 @@ XX document
~% %coed +> ~
|%
<h3 id="++norm"><code>++norm</code></h3>
### `++norm`
++ norm |=(x=@ ?:(=(0 (mod x 2)) x (sub q x)))
::
XX document
<h3 id="++xrec"><code>++xrec</code></h3>
### `++xrec`
++ xrec :: recover x-coord
|= y=@ ^- @
@ -543,7 +543,7 @@ XX document
XX document
<h3 id="++ward"><code>++ward</code></h3>
### `++ward`
++ ward :: edwards multiply
|= [pp=[@ @] qq=[@ @]] ^- [@ @]
@ -565,7 +565,7 @@ XX document
XX document
<h3 id="++scam"><code>++scam</code></h3>
### `++scam`
++ scam :: scalar multiply
|= [pp=[@ @] e=@] ^- [@ @]
@ -580,7 +580,7 @@ XX document
XX document
<h3 id="++etch"><code>++etch</code></h3>
### `++etch`
++ etch :: encode point
|= pp=[@ @] ^- @
@ -589,7 +589,7 @@ XX document
XX document
<h3 id="++curv"><code>++curv</code></h3>
### `++curv`
++ curv :: point on curve?
|= [x=@ y=@] ^- ?
@ -603,7 +603,7 @@ XX document
XX document
<h3 id="++deco"><code>++deco</code></h3>
### `++deco`
++ deco :: decode point
|= s=@ ^- (unit ,[@ @])
@ -619,7 +619,7 @@ XX document
XX document
<h3 id="++bb"><code>++bb</code></h3>
### `++bb`
++ bb
=+ bby=(pro.fq 4 (inv.fq 5))
@ -631,7 +631,7 @@ XX document
XX document
<h3 id="++puck"><code>++puck</code></h3>
### `++puck`
++ puck :: public key
~/ %puck
@ -647,7 +647,7 @@ XX document
XX document
<h3 id="++suck"><code>++suck</code></h3>
### `++suck`
++ suck :: keypair from seed
|= se=@I ^- @uJ
@ -657,7 +657,7 @@ XX document
XX document
<h3 id="++sign"><code>++sign</code></h3>
### `++sign`
++ sign :: certify
~/ %sign
@ -692,7 +692,7 @@ XX document
XX document
<h3 id="++veri"><code>++veri</code></h3>
### `++veri`
++ veri :: validate
~/ %veri

View File

@ -1,13 +1,13 @@
section 2eY, SHA-256
====================
<h3 id="++shad"><code>++shad</code></h3>
### `++shad`
++ shad |=(ruz=@ (shax (shax ruz))) :: double sha-256
XX document
<h3 id="++shaf"><code>++shaf</code></h3>
### `++shaf`
++ shaf :: half sha-256
|= [sal=@ ruz=@]
@ -17,7 +17,7 @@ XX document
XX document
<h3 id="++shak"><code>++shak</code></h3>
### `++shak`
++ shak :: XX shd be PBKDF
|= [who=@p wud=@]
@ -26,7 +26,7 @@ XX document
XX document
<h3 id="++sham"><code>++sham</code></h3>
### `++sham`
++ sham :: noun hash
|= yux=* ^- @uvH ^- @
@ -37,7 +37,7 @@ XX document
XX document
<h3 id="++shas"><code>++shas</code></h3>
### `++shas`
++ shas :: salted hash
|= [sal=@ ruz=@]
@ -46,7 +46,7 @@ XX document
XX document
<h3 id="++shax"><code>++shax</code></h3>
### `++shax`
++ shax :: sha-256
~/ %shax
@ -137,7 +137,7 @@ XX document
XX document
<h3 id="++shaw"><code>++shaw</code></h3>
### `++shaw`
++ shaw :: hash to nbits
|= [sal=@ len=@ ruz=@]
@ -146,7 +146,7 @@ XX document
XX document
<h3 id="++og"><code>++og</code></h3>
### `++og`
++ og :: shax-powered rng
~/ %og
@ -154,7 +154,7 @@ XX document
XX document
<h3 id="++rad"><code>++rad</code></h3>
### `++rad`
++ rad :: random in range
|= b=@ ^- @
@ -164,7 +164,7 @@ XX document
XX document
<h3 id="++rads"><code>++rads</code></h3>
### `++rads`
++ rads :: random continuation
|= b=@
@ -173,7 +173,7 @@ XX document
XX document
<h3 id="++raw"><code>++raw</code></h3>
### `++raw`
++ raw :: random bits
~/ %raw
@ -191,7 +191,7 @@ XX document
XX document
<h3 id="++raws"><code>++raws</code></h3>
### `++raws`
++ raws :: random bits continuation
|= b=@
@ -201,7 +201,7 @@ XX document
XX document
<h3 id="++shaz"><code>++shaz</code></h3>
### `++shaz`
++ shaz :: sha-512
|= ruz=@ ^- @
@ -209,7 +209,7 @@ XX document
XX document
<h3 id="++shal"><code>++shal</code></h3>
### `++shal`
++ shal :: sha-512 with length
~/ %shal
@ -326,7 +326,7 @@ XX document
XX document
<h3 id="++shan"><code>++shan</code></h3>
### `++shan`
++ shan :: sha-1 (deprecated)
|= ruz=@

View File

@ -1,7 +1,7 @@
section 2eZ, OLD rendering
==========================
<h3 id="++show"><code>++show</code></h3>
### `++show`
++ show :: XX deprecated, use type
|= vem=*
@ -63,7 +63,7 @@ section 2eZ, OLD rendering
XX document
<h3 id="++shep"><code>++shep</code></h3>
### `++shep`
++ shep
|= [fom=@ gar=*]
@ -85,7 +85,7 @@ XX document
XX document
<h3 id="++shop"><code>++shop</code></h3>
### `++shop`
++ shop
|= [aug=* vel=$+(a=@ tape)]
@ -103,14 +103,14 @@ XX document
XX document
<h3 id="++at"><code>++at</code></h3>
### `++at`
++ at
|_ a=@
XX document
<h3 id="++r"><code>++r</code></h3>
### `++r`
++ r
?: ?& (gte (met 3 a) 2)
@ -130,49 +130,49 @@ XX document
XX document
<h3 id="++rf"><code>++rf</code></h3>
### `++rf`
++ rf `tape`[?-(a & '&', | '|', * !!) ~]
XX document
<h3 id="++rn"><code>++rn</code></h3>
### `++rn`
++ rn `tape`[?>(=(0 a) '~') ~]
XX document
<h3 id="++rt"><code>++rt</code></h3>
### `++rt`
++ rt `tape`['\'' (weld (mesc (trip a)) `tape`['\'' ~])]
XX document
<h3 id="++rta"><code>++rta</code></h3>
### `++rta`
++ rta rt
XX document
<h3 id="++rtam"><code>++rtam</code></h3>
### `++rtam`
++ rtam `tape`['%' (trip a)]
XX document
<h3 id="++rub"><code>++rub</code></h3>
### `++rub`
++ rub `tape`['0' 'b' (rum 2 ~ |=(b=@ (add '0' b)))]
XX document
<h3 id="++rud"><code>++rud</code></h3>
### `++rud`
++ rud (rum 10 ~ |=(b=@ (add '0' b)))
XX document
<h3 id="++rum"><code>++rum</code></h3>
### `++rum`
++ rum
|= [b=@ c=tape d=$+(@ @)]
@ -193,7 +193,7 @@ XX document
XX document
<h3 id="++rup"><code>++rup</code></h3>
### `++rup`
++ rup
=+ b=(met 3 a)
@ -220,7 +220,7 @@ XX document
XX document
<h3 id="++ruv"><code>++ruv</code></h3>
### `++ruv`
++ ruv
^- tape
@ -239,7 +239,7 @@ XX document
XX document
<h3 id="++rux"><code>++rux</code></h3>
### `++rux`
++ rux `tape`['0' 'x' (rum 16 ~ |=(b=@ (add b ?:((lth b 10) 48 87))))]
--

View File

@ -1,7 +1,7 @@
section 3bA, lite number theory
===============================
<h3 id="++fu"><code>++fu</code></h3>
### `++fu`
++ fu :: modulo (mul p q)
|= a=[p=@ q=@]
@ -10,7 +10,7 @@ section 3bA, lite number theory
XX document
<h3 id="++dif"><code>++dif</code></h3>
### `++dif`
++ dif
|= [c=[@ @] d=[@ @]]
@ -19,7 +19,7 @@ XX document
XX document
<h3 id="++exp"><code>++exp</code></h3>
### `++exp`
++ exp
|= [c=@ d=[@ @]]
@ -29,7 +29,7 @@ XX document
XX document
<h3 id="++out"><code>++out</code></h3>
### `++out`
++ out :: garner's formula
|= c=[@ @]
@ -40,7 +40,7 @@ XX document
XX document
<h3 id="++pro"><code>++pro</code></h3>
### `++pro`
++ pro
|= [c=[@ @] d=[@ @]]
@ -49,7 +49,7 @@ XX document
XX document
<h3 id="++sum"><code>++sum</code></h3>
### `++sum`
++ sum
|= [c=[@ @] d=[@ @]]
@ -58,7 +58,7 @@ XX document
XX document
<h3 id="++sit"><code>++sit</code></h3>
### `++sit`
++ sit
|= c=@

View File

@ -1,7 +1,7 @@
section 3bB, cryptosuites
=========================
<h3 id="++crua"><code>++crua</code></h3>
### `++crua`
++ crua !: :: cryptosuite A (RSA)
^- acru
@ -10,13 +10,13 @@ section 3bB, cryptosuites
XX document
<h3 id="++mx"><code>++mx</code></h3>
### `++mx`
++ mx (dec (met 0 mos)) :: bit length
XX document
<h3 id="++dap"><code>++dap</code></h3>
### `++dap`
++ dap :: OEAP decode
|= [wid=@ xar=@ dog=@] ^- [p=@ q=@]
@ -28,7 +28,7 @@ XX document
XX document
<h3 id="++pad"><code>++pad</code></h3>
### `++pad`
++ pad :: OEAP encode
|= [wid=@ rax=[p=@ q=@] meg=@] ^- @
@ -42,19 +42,19 @@ XX document
XX document
<h3 id="++pull"><code>++pull</code></h3>
### `++pull`
++ pull |=(a=@ (~(exp fo mos) 3 a))
XX document
<h3 id="++push"><code>++push</code></h3>
### `++push`
++ push |=(a=@ (~(exp fo mos) 5 a))
XX document
<h3 id="++pump"><code>++pump</code></h3>
### `++pump`
++ pump
|= a=@ ^- @
@ -64,7 +64,7 @@ XX document
XX document
<h3 id="++punt"><code>++punt</code></h3>
### `++punt`
++ punt
|= a=@ ^- @
@ -74,14 +74,14 @@ XX document
XX document
<h3 id="++as"><code>++as</code></h3>
### `++as`
++ as
=> |%
XX document
<h3 id="++haul"><code>++haul</code></h3>
### `++haul`
++ haul :: revealing haul
|= a=pass
@ -94,7 +94,7 @@ XX document
XX document
<h3 id="++seal"><code>++seal</code></h3>
### `++seal`
XX document
@ -177,26 +177,26 @@ XX document
XX document
<h3 id="++pac"><code>++pac</code></h3>
### `++pac`
++ pac ^- @uvG (end 6 1 (shaf %acod sec))
XX document
<h3 id="++pub"><code>++pub</code></h3>
### `++pub`
++ pub ^- pass (cat 3 'b' puc)
XX document
<h3 id="++sec"><code>++sec</code></h3>
### `++sec`
++ sec ^- ring sed
::
XX document
<h3 id="++nu"><code>++nu</code></h3>
### `++nu`
++ nu
^?
@ -208,7 +208,7 @@ XX document
XX document
<h3 id="++elcm"><code>++elcm</code></h3>
### `++elcm`
++ elcm
|= [a=@ b=@]
@ -217,7 +217,7 @@ XX document
XX document
<h3 id="++eldm"><code>++eldm</code></h3>
### `++eldm`
++ eldm
|= [a=@ b=@ c=@]
@ -226,7 +226,7 @@ XX document
XX document
<h3 id="++ersa"><code>++ersa</code></h3>
### `++ersa`
++ ersa
|= [a=@ b=@]
@ -240,7 +240,7 @@ XX document
XX document
<h3 id="++com"><code>++com</code></h3>
### `++com`
XX document
@ -401,7 +401,7 @@ XX document
XX document
<h3 id="++sign"><code>++sign</code></h3>
### `++sign`
++ sign
|= [a=@ b=@] ^- @
@ -409,7 +409,7 @@ XX document
XX document
<h3 id="++sure"><code>++sure</code></h3>
### `++sure`
++ sure
|= [a=@ b=@]
@ -418,7 +418,7 @@ XX document
XX document
<h3 id="++tear"><code>++tear</code></h3>
### `++tear`
++ tear
|= [a=pass b=@]
@ -428,7 +428,7 @@ XX document
XX document
<h3 id="++de"><code>++de</code></h3>
### `++de`
++ de
|+ [key=@ cep=@] ^- (unit ,@)
@ -437,7 +437,7 @@ XX document
XX document
<h3 id="++dy"><code>++dy</code></h3>
### `++dy`
++ dy
|+ [a=@ b=@] ^- @
@ -445,7 +445,7 @@ XX document
XX document
<h3 id="++en"><code>++en</code></h3>
### `++en`
++ en
|+ [key=@ msg=@] ^- @ux
@ -454,14 +454,14 @@ XX document
XX document
<h3 id="++ex"><code>++ex</code></h3>
### `++ex`
++ ex ^?
|% ++ fig ^- @uvH (shaf %bfig puc)
XX document
<h3 id="++fig"><code>++fig</code></h3>
### `++fig`
XX document
@ -509,7 +509,7 @@ XX document
XX document
<h3 id="++pit"><code>++pit</code></h3>
### `++pit`
++ pit
|= [a=@ b=@]
@ -519,7 +519,7 @@ XX document
XX document
<h3 id="++nol"><code>++nol</code></h3>
### `++nol`
++ nol
|= a=@
@ -528,7 +528,7 @@ XX document
XX document
<h3 id="++brew"><code>++brew</code></h3>
### `++brew`
++ brew :: create keypair
|= [a=@ b=@] :: width seed
@ -538,7 +538,7 @@ XX document
XX document
<h3 id="++hail"><code>++hail</code></h3>
### `++hail`
++ hail :: activate public key
|= a=pass
@ -550,7 +550,7 @@ XX document
XX document
<h3 id="++wear"><code>++wear</code></h3>
### `++wear`
++ wear :: activate secret key
|= a=ring
@ -562,7 +562,7 @@ XX document
XX document
<h3 id="++trub"><code>++trub</code></h3>
### `++trub`
++ trub :: test ed
|= msg=@tas
@ -583,7 +583,7 @@ XX document
XX document
<h3 id="++hmac"><code>++hmac</code></h3>
### `++hmac`
++ hmac :: HMAC-SHA1
|= [key=@ mes=@]

View File

@ -1,7 +1,7 @@
section 3bC, Gregorian UTC
==========================
<h3 id="++dawn"><code>++dawn</code></h3>
### `++dawn`
Weekday of Jan 1
@ -27,7 +27,7 @@ producing an atom. Weeks are zero-indexed beginning on Sunday.
------------------------------------------------------------------------
<h3 id="++daws"><code>++daws</code></h3>
### `++daws`
Weekday of date
@ -51,7 +51,7 @@ zero-indexed beginning on Sunday.
------------------------------------------------------------------------
<h3 id="++deal"><code>++deal</code></h3>
### `++deal`
Add leap seconds
@ -82,7 +82,7 @@ Produces a [`date`]() with the 25 leap seconds added.
------------------------------------------------------------------------
<h3 id="++lead"><code>++lead</code></h3>
### `++lead`
Subtract leap seconds
@ -117,7 +117,7 @@ subtracted.
------------------------------------------------------------------------
<h3 id="++dust"><code>++dust</code></h3>
### `++dust`
Print UTC format
@ -146,7 +146,7 @@ Produces a [tape]() of the date in UTC format.
------------------------------------------------------------------------
<h3 id="++stud"><code>++stud</code></h3>
### `++stud`
Parse UTC format
@ -189,7 +189,7 @@ Accepts a [tape]() containing a date in UTC format and produces the
------------------------------------------------------------------------
<h3 id="++unt"><code>++unt</code></h3>
### `++unt`
UGT to UTC time
@ -211,7 +211,7 @@ Transforms Urbit Galactic Time to UTC time, producing an atom.
------------------------------------------------------------------------
<h3 id="++yu"><code>++yu</code></h3>
### `++yu`
UTC format constants
@ -223,7 +223,7 @@ UTC format constants
------------------------------------------------------------------------
<h3 id="++mon"><code>++mon</code></h3>
### `++mon`
Months
@ -255,7 +255,7 @@ Produces a list of [tapes]() containing the 12 months of the year.
------------------------------------------------------------------------
<h3 id="++wik"><code>++wik</code></h3>
### `++wik`
Weeks
@ -277,7 +277,7 @@ beginning with Sunday.
------------------------------------------------------------------------
<h3 id="++les"><code>++les</code></h3>
### `++les`
Leap second dates
@ -325,7 +325,7 @@ Produces a list of the (absolute) dates ([`@da`]) of the 25 leap seconds
------------------------------------------------------------------------
<h3 id="++lef"><code>++lef</code></h3>
### `++lef`
Back-shifted leap second dates

View File

@ -1,7 +1,7 @@
section 3bD, JSON and XML
=========================
<h3 id="++moon"><code>++moon</code></h3>
### `++moon`
Mime type to `++cord`
@ -27,7 +27,7 @@ Renders a [mime](http://en.wikipedia.org/wiki/MIME) type path with infix
~zod/try=> `@t`(moon /application/x-pnacl)
'application/x-pnacl'
<h3 id="++perk"><code>++perk</code></h3>
### `++perk`
Parse cube with fork
@ -61,7 +61,7 @@ needlessly unwieldy.
! {1 1}
! exit
<h3 id="++poja"><code>++poja</code></h3>
### `++poja`
JSON parser core
@ -81,7 +81,7 @@ a [`++json`]().
~zod/try=> (poja 'invalid{json')
~
<h3 id="++apex"><code>++apex</code></h3>
### `++apex`
Parse object
@ -103,7 +103,7 @@ with current test:urbit.git
! {1 1}
! exit
<h3 id="++valu"><code>++valu</code></h3>
### `++valu`
Parse value
@ -135,7 +135,7 @@ Parsing rule. Parses JSON values to [`++json`]().
~zod/try=> (rash 'true' valu:poja)
[%b p=%.y]
<h3 id="++abox"><code>++abox</code></h3>
### `++abox`
Parse array
@ -150,7 +150,7 @@ delimited by a `,`.
JSON Objects
------------
<h3 id="++pair"><code>++pair</code></h3>
### `++pair`
Parse key value pair
@ -162,7 +162,7 @@ string and value delimited by `:`.
~zod/try=> (rash '"ham": 2' pair:poja)
['ham' [%n p=~.2]]
<h3 id="++obje"><code>++obje</code></h3>
### `++obje`
Parse array of objects
@ -174,7 +174,7 @@ key-value pairs that are enclosed within `{}` and separated by `,`.
~zod/try=> (rash '{"ham": 2, "lam":true}' obje:poja)
[['ham' [%n p=~.2]] ~[['lam' [%b p=%.y]]]]
<h3 id="++obox"><code>++obox</code></h3>
### `++obox`
Parse boxed object
@ -189,7 +189,7 @@ a tag of `%o`. See also: [`++json`]().
JSON Booleans
-------------
<h3 id="++bool"><code>++bool</code></h3>
### `++bool`
Parse boolean
@ -209,7 +209,7 @@ Parsing rule. Parses a string of either `true` or `false` to a
JSON strings
------------
<h3 id="++stri"><code>++stri</code></h3>
### `++stri`
Parse string
@ -228,7 +228,7 @@ of characters enclosed in double quotes along with escaping `\`s, to a
~zod/try=> (rash '"This be \\"quoted\\""' stri:poja)
'This be "quoted"'
<h3 id="++jcha"><code>++jcha</code></h3>
### `++jcha`
Parse char from string
@ -249,7 +249,7 @@ string to a [`++cord`]().
'
'
<h3 id="++esca"><code>++esca</code></h3>
### `++esca`
Parse escaped char
@ -286,7 +286,7 @@ A- JSON numbers are stored as cords internally in lieu of full float
support, so ++numb and subarms are really more *validators* than parsers
per se.
<h3 id="++numb"><code>++numb</code></h3>
### `++numb`
Parse number
@ -318,7 +318,7 @@ part, or exponent part, to a [`++cord`]().
! {1 2}
! exit
<h3 id="++digs"><code>++digs</code></h3>
### `++digs`
Parse 1-9
@ -335,7 +335,7 @@ Parsing rule. Parses digits `0` through `9` to a [`++tape`]().
~zod/try=> (rash '7' digs:poja)
"7"
<h3 id="++expo"><code>++expo</code></h3>
### `++expo`
Parse exponent part
@ -356,7 +356,7 @@ Parsing rule. Parses an exponent to a [`++cord`](). An exponent is an
~zod/try=> `tape`(rash 'E-4' expo:poja)
"E-4"
<h3 id="++frac"><code>++frac</code></h3>
### `++frac`
Fractional part
@ -374,7 +374,7 @@ Parsing rule. Parses a dot followed by digits to a [`++cord`]().
whitespace
----------
<h3 id="++spac"><code>++spac</code></h3>
### `++spac`
Parse whitespace
@ -392,7 +392,7 @@ Parsing rule. Parses a whitespace to a [`++tape`]().
! {1 4}
! exit
<h3 id="++ws"><code>++ws</code></h3>
### `++ws`
Allow prefix whitespace
@ -417,7 +417,7 @@ applying `sef`.
Plumbing
--------
<h3 id="++mayb"><code>++mayb</code></h3>
### `++mayb`
Maybe parse
@ -430,7 +430,7 @@ Parser modifier. Need to document, an example showing failure.
~zod/try=> ((mayb abox):poja 1^1 "not-an-array")
[p=[p=1 q=1] q=[~ [p="" q=[p=[p=1 q=1] q="not-an-array"]]]]
<h3 id="++twel"><code>++twel</code></h3>
### `++twel`
Weld two tapes
@ -447,7 +447,7 @@ Concatenates two tapes, `a` and `b`, producing a `++tape`.
~zod/try=> (twel "kre" ""):poja
~[~~k ~~r ~~e]
<h3 id="++piec"><code>++piec</code></h3>
### `++piec`
Parse char to list
@ -464,7 +464,7 @@ Parser modifer. Parses an atom with `bus` and then wraps it in a
~zod/try=> (scan "4" (piec:poja dem:ag))
[4 ~]
<h3 id="++pojo"><code>++pojo</code></h3>
### `++pojo`
Print JSON
@ -527,7 +527,7 @@ Renders a `++json` `val` as a [`++tape`]().
~zod/try=> (crip (pojo %o (mo sale/(jone 12) same/b/| ~)))
'{"same":false,"sale":12}'
<h3 id="++poxo"><code>++poxo</code></h3>
### `++poxo`
Print XML
@ -546,7 +546,7 @@ Renders a `++manx` `a` as a [`++tape`]().
~zod/try=> (poxo ;div:(p:"tree > text" a))
"<div><p>tree &gt; text</p><a></a></div>"
<h3 id="++apex"><code>++apex</code></h3>
### `++apex`
Inner XML printer
@ -581,7 +581,7 @@ Renders a `++manx` as a [`++tape`](), appending a suffix `rez\`.
~zod/try=> (~(apex poxo &) ;div:(p:"tree > text" a) "")
"<div><p>tree > text</p><a></a></div>"
<h3 id="++attr"><code>++attr</code></h3>
### `++attr`
Print attributes
@ -609,7 +609,7 @@ Render XML attributes as a [`++tape`]().
~zod/try=> (crip (attr:poxo ~[sam/"hem" [%tok %ns]^"reptor"] "|appen"))
'sam="hem" tok:ns="reptor"|appen'
<h3 id="++escp"><code>++escp</code></h3>
### `++escp`
Escape XML
@ -648,7 +648,7 @@ Escapes the XML special characters `"`, `&`, `'`, `<`, `>`.
~zod/try=> `tape`(~(escp poxo &) "x > y" ~)
"x > y"
<h3 id="++name"><code>++name</code></h3>
### `++name`
Print name
@ -669,7 +669,7 @@ Renders a `++mane` as a `++tape`.
~zod/try=> (name:poxo %ham^%tor)
"ham:tor"
<h3 id="++many"><code>++many</code></h3>
### `++many`
Print node list
@ -697,7 +697,7 @@ Renders multiple XML nodes as a [`++tape`]()
------------------------------------------------------------------------
<h3 id="++poxa"><code>++poxa</code></h3>
### `++poxa`
Parse XML
@ -718,7 +718,7 @@ Parses an XML node from a [`++cord`](), producing a unit [`++manx`]().
~zod/try=> (poxa '<<<<')
~
<h3 id="++apex"><code>++apex</code></h3>
### `++apex`
Top level parser
@ -745,7 +745,7 @@ Parses a node of XML, type [`++manx`]().
! {1 2}
! exit
<h3 id="++attr"><code>++attr</code></h3>
### `++attr`
Parse XML attributes
@ -781,7 +781,7 @@ or more space-prefixed name to string values. Result type [`++mart`]()
! {1 23}
! exit
<h3 id="++chrd"><code>++chrd</code></h3>
### `++chrd`
Parse character data
@ -800,7 +800,7 @@ Parsing rule. Parses XML character data. Result type [`++mars`]()
! {1 6}
! exit
<h3 id="++comt"><code>++comt</code></h3>
### `++comt`
Parses comments
@ -823,7 +823,7 @@ Parsing rule. Parses XML comment blocks.
! {1 18}
! exit
<h3 id="++escp"><code>++escp</code></h3>
### `++escp`
Parse (possibly) escaped char
@ -857,7 +857,7 @@ Parsing rule. Parses a nonspecial or escaped character. Result type
~zod/try=> (rash '&quot;' escp:xmlp)
'"'
<h3 id="++empt"><code>++empt</code></h3>
### `++empt`
Parse self-closing tag
@ -876,7 +876,7 @@ Parsing rule. Parses self-closing XML tags that end in `/>`.
! {1 21}
! exit
<h3 id="++head"><code>++head</code></h3>
### `++head`
Parse opening tag
@ -895,7 +895,7 @@ Parsing rule. Parses the opening tag of an XML node. Result type
! {1 16}
! exit
<h3 id="++name"><code>++name</code></h3>
### `++name`
Parse tag name
@ -922,7 +922,7 @@ Parsing rule. Parses the name of an XML tag. Result type [`++mane`]()
! {1 4}
! exit
<h3 id="++tail"><code>++tail</code></h3>
### `++tail`
Parse closing tag
@ -938,7 +938,7 @@ Parsing rule. Parses an XML closing tag.
! {1 3}
! exit
<h3 id="++whit"><code>++whit</code></h3>
### `++whit`
Parse whitespace, etc.
@ -960,7 +960,7 @@ Parsing rule. Parses newlines, tabs, and spaces.
! {1 1}
! exit
<h3 id="++jo"><code>++jo</code></h3>
### `++jo`
JSON reparsing core
@ -975,7 +975,7 @@ A `fist` is a gate that produces a `grub`.
A `grub` is a unit of some JSON value.
<h3 id="++ar"><code>++ar</code></h3>
### `++ar`
Parse array to list
@ -998,7 +998,7 @@ Reparser modifier. Reparses an array to the [`++unit`]() of a homogenous
[~ u=~[1 2]]
{[%~ u=it(@)] %~}
<h3 id="++at"><code>++at</code></h3>
### `++at`
Reparse array as tuple
@ -1023,7 +1023,7 @@ Reparser generator. Reparses an array as a fixed-length tuple of
~zod/try=> ((at ni so ni ~):jo a/~[n/'3' s/'to' n/''])
~
<h3 id="++at-raw"><code>++at-raw</code></h3>
### `++at-raw`
Reparse array to tuple
@ -1043,7 +1043,7 @@ Reparser generator. Reparses a list of [`++json`]() to a tuple of
~zod/try=> ((at-raw ni ni bo ~):jo ~[s/'hi' n/'1' b/&])
[~ [~ 1] [~ u=%.y] ~]
<h3 id="++bo"><code>++bo</code></h3>
### `++bo`
Reparse boolean
@ -1061,7 +1061,7 @@ Reparser modifier. Reparses a boolean to the [`++unit`]() of a
~zod/try=> (bo:jo [%s 'hi'])
~
<h3 id="++bu"><code>++bu</code></h3>
### `++bu`
Reparse boolean not
@ -1079,7 +1079,7 @@ of a loobean.
~zod/try=> (bu:jo [%s 'hi'])
~
<h3 id="++cu"><code>++cu</code></h3>
### `++cu`
Reparse and transform
@ -1101,7 +1101,7 @@ producing a [`++unit`]().
~zod/try=> ((cu dec ni):jo [%b &])
~
<h3 id="++da"><code>++da</code></h3>
### `++da`
Reparse UTC date
@ -1120,7 +1120,7 @@ Reparser modifier. Reparses a UTC date string to a [`++unit`]().
~zod/try=> (da:jo [%n '20'])
~
<h3 id="++di"><code>++di</code></h3>
### `++di`
Reparse millisecond date
@ -1143,7 +1143,7 @@ Reparser modifier. Reparses the javascript millisecond date integer to a
~zod/try=> (di:jo [%n '25000'])
[~ ~1970.1.1..00.00.25]
<h3 id="++mu"><code>++mu</code></h3>
### `++mu`
Reparse unit
@ -1169,7 +1169,7 @@ value, and are reparsed to results of \~ or (some {value}) respectively
~zod/try=> ((mu ni):jo [%s 'ma'])
~
<h3 id="++ne"><code>++ne</code></h3>
### `++ne`
Reparse number as real
@ -1184,7 +1184,7 @@ XX Currently unimplemented
A- yup, this will eventually reparse a floating point atom, but
interfaces for the latter are not currently stable.
<h3 id="++ni"><code>++ni</code></h3>
### `++ni`
Reparse number as integer
@ -1211,7 +1211,7 @@ Reparser modifier. Reparses an integer representation to a [\`++unit]().
~zod/try=> (ni:jo [%a ~[b/& b/& b/& b/&]])
~
<h3 id="++no"><code>++no</code></h3>
### `++no`
Reparse number as text
@ -1238,7 +1238,7 @@ Reparser modifier. Reparses a numeric representation to a [++cord]().
~zod/try=> (no:jo [%a ~[b/& b/& b/& b/&]])
~
<h3 id="++of"><code>++of</code></h3>
### `++of`
Reparse object to frond
@ -1278,7 +1278,7 @@ one of the key-value pairs in `wer`.
~zod/try=> ((of sem/sa som/ni ~):jo %o [%sem s/'hey'] ~ [%sam s/'other value'] ~ ~)
~
<h3 id="++ot"><code>++ot</code></h3>
### `++ot`
Reparse object as tuple
@ -1301,7 +1301,7 @@ the [`++edge`](), the results of which are produced in a tuple.
~zod/try=> ((ot sem/sa som/ni sem/sa ~):jo (jobe [%sem s/'ha'] [%som n/'20'] ~))
[~ u=["ha" q=20 "ha"]]
<h3 id="++ot-raw"><code>++ot-raw</code></h3>
### `++ot-raw`
++ ot-raw :: object as tuple
|* wer=(pole ,[cord fist])
@ -1321,7 +1321,7 @@ in a tuple.
~zod/try=> ((ot-raw sem/sa som/ni sem/sa ~):jo (mo [%sem s/'ha'] [%som b/|] ~))
[[~ u="ha"] ~ [~ u="ha"] ~]
<h3 id="++om"><code>++om</code></h3>
### `++om`
Parse object to map
@ -1342,7 +1342,7 @@ using `wit`.
~zod/try=> ((om ni):jo (jobe [%sap n/'20'] [%sup n/'0x5'] [%sop n/'177'] ~))
~
<h3 id="++pe"><code>++pe</code></h3>
### `++pe`
Add prefix
@ -1365,7 +1365,7 @@ Reparser modifier. Adds a static prefix `pre` to the parse result of
~zod/try=> ((pe %hi ni):jo b/|)
~
<h3 id="++sa"><code>++sa</code></h3>
### `++sa`
Reparse string to tape
@ -1383,7 +1383,7 @@ Reparser modifier. Reparses a [`++json`]() string to a [`++tape`]().
~zod/try=> (sa:jo a/~[s/'val 2'])
~
<h3 id="++so"><code>++so</code></h3>
### `++so`
Reparse string to cord
@ -1401,7 +1401,7 @@ Reparser modifier. Reparses a string to a [`++cord`]().
~zod/try=> (so:jo a/~[s/'val 2'])
~
<h3 id="++su"><code>++su</code></h3>
### `++su`
Reparse string
@ -1425,7 +1425,7 @@ Reparser generator. Produces a reparser that applies `sab` to a string.
~zod/try=> ((su:jo fed:ag) n/'20')
~
<h3 id="++ul"><code>++ul</code></h3>
### `++ul`
Reparse null
@ -1442,7 +1442,7 @@ Reparser modifier. Reparses a null value.
~zod/try=> (ul:jo b/&)
~
<h3 id="++za"><code>++za</code></h3>
### `++za`
Pole of nonempty units
@ -1463,7 +1463,7 @@ internally.
~zod/try=> (za:jo ~[`1 ~ `3])
%.n
<h3 id="++zl"><code>++zl</code></h3>
### `++zl`
Collapse unit list
@ -1491,7 +1491,7 @@ empty, produces null.
~zod/try=> (zl:jo `(list (unit))`~[`1 ~ `3])
~
<h3 id="++zp"><code>++zp</code></h3>
### `++zp`
Parses a
@ -1514,7 +1514,7 @@ Collapses a `++pole` of `++unit`s `but`, producing a tuple.
~zod/try=> (zp:jo `(pole (unit))`~[`1 ~ `3])
! exit
<h3 id="++zm"><code>++zm</code></h3>
### `++zm`
Collapse unit map
@ -1545,7 +1545,7 @@ See also: [`++zp`](), [`++zl`]().
~zod/try=> (~(run by `(map ,@t ,@u)`(mo a/1 b/7 c/3 ~)) (flit |=(a=@ (lth a 5))))
{[p='a' q=[~ u=1]] [p='c' q=[~ u=3]] [p='b' q=~]}
<h3 id="++joba"><code>++joba</code></h3>
### `++joba`
`++json` from key-value pair
@ -1570,7 +1570,7 @@ Produces a ++json object with one key.
~zod/try=> (crip (pojo (joba %hi (jone 2.130))))
'{"hi":2130}'
<h3 id="++jobe"><code>++jobe</code></h3>
### `++jobe`
Object from key-value list
@ -1589,7 +1589,7 @@ Produces a `++json` object from a list `a` of key to `++json` values.
~zod/try=> (crip (pojo (jobe a/n/'20' b/~ c/a/~[s/'mol'] ~)))
'{"b":null,"c":["mol"],"a":20}'
<h3 id="++jape"><code>++jape</code></h3>
### `++jape`
`++json` string from tape
@ -1610,7 +1610,7 @@ Produces a [`++json`]() string from a [`++tape`]().
~zod/try=> (crip (pojo (jape "semtek som? zeplo!")))
'"semtek som? zeplo!"'
<h3 id="++jone"><code>++jone</code></h3>
### `++jone`
`++json` number from unigned
@ -1635,7 +1635,7 @@ Produces a `++json` number from an unsigned atom.
~zod/try=> (pojo (jone 1.203.196))
"1203196"
<h3 id="++jesc"><code>++jesc</code></h3>
### `++jesc`
Escape JSON character
@ -1661,7 +1661,7 @@ Produces a `++tape` of an escaped [`++json`](/doc/hoon/library/3bi#++json) chara
~zod/try=> (jesc '"')
"\""
<h3 id="++scanf"><code>++scanf</code></h3>
### `++scanf`
Formatted scan
@ -1693,7 +1693,7 @@ collapses the result list to a tuple, such that (scanf "foo 1 2 bar"
~zod/try=> `@da`(year `date`dat(- [%& -.dat], |6 ~[(div (mul |6.dat (bex 16)) 1.000)]))
~2014.8.12..23.10.58..ee56
<h3 id="++parsf"><code>++parsf</code></h3>
### `++parsf`
++ parsf :: make parser from:
|^ |* a=(pole ,_:/(*$&(_rule tape))) :: ;"chars{rule}chars"
@ -1745,7 +1745,7 @@ more convenient list of discriminated tapes and rules.
`bill` builds a parser out of rules and tapes, ignoring the literal
sections and producing a list of the rules' results.
<h3 id="++taco"><code>++taco</code></h3>
### `++taco`
++ taco :: atom to octstream
|= tam=@ ^- octs
@ -1759,7 +1759,7 @@ An [octs] contains a length, to encode trailing zeroes.
~zod/try=> `@t`6.513.249
'abc'
<h3 id="++tact"><code>++tact</code></h3>
### `++tact`
++ tact :: tape to octstream
|= tep=tape ^- octs
@ -1773,7 +1773,7 @@ octs from tape
~zod/try=> `@t`6.513.249
'abc'
<h3 id="++tell"><code>++tell</code></h3>
### `++tell`
++ tell :: wall to octstream
|= wol=wall ^- octs
@ -1792,7 +1792,7 @@ octs from wall
3
'''
<h3 id="++txml"><code>++txml</code></h3>
### `++txml`
++ txml :: string to xml
|= tep=tape ^- manx

View File

@ -1,7 +1,7 @@
section 3bE, tree sync
======================
<h3 id="++invert-miso"><code>++invert-miso</code></h3>
### `++invert-miso`
++ invert-miso :: invert miso
|= mis=miso
@ -14,7 +14,7 @@ section 3bE, tree sync
XX document
<h3 id="++cosh"><code>++cosh</code></h3>
### `++cosh`
++ cosh :: locally rehash
|= ank=ankh :: NB v/unix.c
@ -23,7 +23,7 @@ XX document
XX document
<h3 id="++cost"><code>++cost</code></h3>
### `++cost`
++ cost :: new external patch
|= [bus=ankh ank=ankh] :: NB v/unix.c
@ -35,7 +35,7 @@ XX document
XX document
<h3 id="++loth"><code>++loth</code></h3>
### `++loth`
++ loth
|= pat=(map path ,*)
@ -47,7 +47,7 @@ XX document
XX document
<h3 id="++luth"><code>++luth</code></h3>
### `++luth`
++ luth
|= [p=(map path ,*) q=(map path ,*)] :: merge keysets
@ -57,7 +57,7 @@ XX document
XX document
<h3 id="++blob-to-lobe"><code>++blob-to-lobe</code></h3>
### `++blob-to-lobe`
++ blob-to-lobe :: p.blob
|= p=blob
@ -71,20 +71,20 @@ XX document
XX document
<h3 id="++ze"><code>++ze</code></h3>
### `++ze`
++ ze
|_ [lim=@da dome rang]
XX document
<h3 id="++aeon-to-tako"><code>++aeon-to-tako</code></h3>
### `++aeon-to-tako`
++ aeon-to-tako ~(got by hit)
XX document
<h3 id="++make-yaki"><code>++make-yaki</code></h3>
### `++make-yaki`
++ make-yaki :: make yaki
|= [p=(list tako) q=(map path lobe) t=@da]
@ -97,19 +97,19 @@ XX document
XX document
<h3 id="++tako-to-yaki"><code>++tako-to-yaki</code></h3>
### `++tako-to-yaki`
++ tako-to-yaki ~(got by hut) :: grab yaki
XX document
<h3 id="++lobe-to-blob"><code>++lobe-to-blob</code></h3>
### `++lobe-to-blob`
++ lobe-to-blob ~(got by lat) :: grab blob
XX document
<h3 id="++lobe-to-noun"><code>++lobe-to-noun</code></h3>
### `++lobe-to-noun`
++ lobe-to-noun :: grab blob
|= p=lobe :: ^- *
@ -119,7 +119,7 @@ XX document
XX document
<h3 id="++make-direct"><code>++make-direct</code></h3>
### `++make-direct`
++ make-direct :: make blob
|= [p=* q=umph]
@ -129,7 +129,7 @@ XX document
XX document
<h3 id="++make-delta"><code>++make-delta</code></h3>
### `++make-delta`
++ make-delta :: make blob delta
|= [p=lobe q=udon]
@ -144,7 +144,7 @@ XX document
XX document
<h3 id="++blob-to-umph"><code>++blob-to-umph</code></h3>
### `++blob-to-umph`
++ blob-to-umph :: blob umph [prep]
|= p=blob :: used in merge
@ -158,7 +158,7 @@ XX document
XX document
<h3 id="++blob-to-noun"><code>++blob-to-noun</code></h3>
### `++blob-to-noun`
++ blob-to-noun :: grab blob
|= p=blob
@ -173,7 +173,7 @@ XX document
XX document
<h3 id="++diff-yakis"><code>++diff-yakis</code></h3>
### `++diff-yakis`
++ diff-yakis :: fundamental diff
|= [p=yaki q=yaki]
@ -198,7 +198,7 @@ XX document
XX document
<h3 id="++lobes-at-path"><code>++lobes-at-path</code></h3>
### `++lobes-at-path`
++ lobes-at-path :: lobes-at-path:ze
|= [oan=aeon pax=path] :: data at path
@ -222,7 +222,7 @@ XX document
XX document
<h3 id="++case-to-aeon"><code>++case-to-aeon</code></h3>
### `++case-to-aeon`
++ case-to-aeon :: case-to-aeon:ze
|= lok=case :: act count through
@ -247,7 +247,7 @@ XX document
XX document
<h3 id="++as-arch"><code>++as-arch</code></h3>
### `++as-arch`
++ as-arch :: as-arch:ze
^- arch :: arch report
@ -260,7 +260,7 @@ XX document
XX document
<h3 id="++reachable-takos"><code>++reachable-takos</code></h3>
### `++reachable-takos`
++ reachable-takos :: reachable
|= p=tako :: XX slow
@ -276,7 +276,7 @@ XX document
XX document
<h3 id="++new-lobes"><code>++new-lobes</code></h3>
### `++new-lobes`
++ new-lobes :: object hash set
|= [b=(set lobe) a=(set tako)] :: that aren't in b
@ -300,7 +300,7 @@ XX document
XX document
<h3 id="++new-lobes-takos"><code>++new-lobes-takos</code></h3>
### `++new-lobes-takos`
++ new-lobes-takos :: garg & repack
|= [b=(set lobe) a=(set tako)]
@ -310,7 +310,7 @@ XX document
XX document
<h3 id="++reachable-between-takos"><code>++reachable-between-takos</code></h3>
### `++reachable-between-takos`
++ reachable-between-takos
|= [a=(unit tako) b=tako] :: pack a through b
@ -337,7 +337,7 @@ XX document
XX document
<h3 id="++takos-to-yakis"><code>++takos-to-yakis</code></h3>
### `++takos-to-yakis`
++ takos-to-yakis :: trivial
|= a=(set tako)
@ -347,7 +347,7 @@ XX document
XX document
<h3 id="++lobes-to-blobs"><code>++lobes-to-blobs</code></h3>
### `++lobes-to-blobs`
++ lobes-to-blobs :: trivial
|= a=(set lobe)
@ -357,7 +357,7 @@ XX document
XX document
<h3 id="++make-nako"><code>++make-nako</code></h3>
### `++make-nako`
++ make-nako :: gack a through b
|= [a=aeon b=aeon]
@ -376,7 +376,7 @@ XX document
XX document
<h3 id="++query"><code>++query</code></h3>
### `++query`
++ query :: query:ze
|= ren=?(%u %v %x %y %z) :: endpoint query
@ -392,7 +392,7 @@ XX document
XX document
<h3 id="++rewind"><code>++rewind</code></h3>
### `++rewind`
++ rewind :: rewind:ze
|= oan=aeon :: rewind to aeon
@ -405,7 +405,7 @@ XX document
XX document
<h3 id="++update-lat"><code>++update-lat</code></h3>
### `++update-lat`
++ update-lat :: update-lat:ze
|= [lag=(map path blob) sta=(map lobe blob)] :: fix lat
@ -420,7 +420,7 @@ XX document
XX document
<h3 id="++apply-changes"><code>++apply-changes</code></h3>
### `++apply-changes`
++ apply-changes :: apply-changes:ze
|= lar=(list ,[p=path q=miso]) :: store changes
@ -463,7 +463,7 @@ XX document
XX document
<h3 id="++checkout-ankh"><code>++checkout-ankh</code></h3>
### `++checkout-ankh`
++ checkout-ankh :: checkout-ankh:ze
|= hat=(map path lobe) :: checkout commit
@ -485,7 +485,7 @@ XX document
XX document
<h3 id="++forge-yaki"><code>++forge-yaki</code></h3>
### `++forge-yaki`
++ forge-yaki :: forge-yaki:ze
|= [wen=@da par=(unit tako) lem=soba] :: forge yaki
@ -499,7 +499,7 @@ XX document
XX document
<h3 id="++forge-nori"><code>++forge-nori</code></h3>
### `++forge-nori`
++ forge-nori :: forge-nori:ze
|= yak=yaki :: forge nori (ugly op)
@ -513,7 +513,7 @@ XX document
XX document
<h3 id="++reduce-merge-points"><code>++reduce-merge-points</code></h3>
### `++reduce-merge-points`
++ reduce-merge-points :: reduce merge points
|= unk=(set yaki) :: maybe need jet
@ -539,7 +539,7 @@ XX document
XX document
<h3 id="++future-find-merge-points"><code>++future-find-merge-points</code></h3>
### `++future-find-merge-points`
++ future-find-merge-points :: merge points fast
|= [p=yaki q=yaki] :: (future zeal)
@ -566,7 +566,7 @@ XX document
XX document
<h3 id="++add-parents"><code>++add-parents</code></h3>
### `++add-parents`
++ add-parents :: expand set
|= qez=(set tako)
@ -579,7 +579,7 @@ XX document
XX document
<h3 id="++find-merge-points"><code>++find-merge-points</code></h3>
### `++find-merge-points`
++ find-merge-points :: merge points
|= [p=yaki q=yaki] :: maybe need jet
@ -599,7 +599,7 @@ XX document
XX document
<h3 id="++clean"><code>++clean</code></h3>
### `++clean`
++ clean :: clean
|= wig=(urge)
@ -617,7 +617,7 @@ XX document
XX document
<h3 id="++match-conflict"><code>++match-conflict</code></h3>
### `++match-conflict`
++ match-conflict :: match conflict
|= [us=[ship desk] th=[ship desk] p=(urge) q=(urge) r=(list)]
@ -634,7 +634,7 @@ XX document
XX document
<h3 id="++annotate"><code>++annotate</code></h3>
### `++annotate`
++ annotate :: annotate conflict
|= [us=[ship desk] th=[ship desk] p=(list ,@t) q=(list ,@t) r=(list ,@t)]
@ -665,7 +665,7 @@ XX document
XX document
<h3 id="++match-merge"><code>++match-merge</code></h3>
### `++match-merge`
++ match-merge :: match merge
|= [p=(urge ,@t) q=(urge ,@t) r=(list ,@t)] :: resolve conflict
@ -734,7 +734,7 @@ XX document
XX document
<h3 id="++qeal"><code>++qeal</code></h3>
### `++qeal`
++ qeal :: merge p,q
|* [us=[ship desk] th=[ship desk] pat=path p=miso q=miso r=(list) con=?]
@ -798,7 +798,7 @@ XX document
XX document
<h3 id="++quil"><code>++quil</code></h3>
### `++quil`
++ quil :: merge p,q
|= $: us=[ship desk]
@ -836,7 +836,7 @@ XX document
XX document
<h3 id="++meld"><code>++meld</code></h3>
### `++meld`
++ meld :: merge p,q from r
|= [p=yaki q=yaki r=yaki con=? us=[ship desk] th=[ship desk]]
@ -887,7 +887,7 @@ XX document
XX document
<h3 id="++mate"><code>++mate</code></h3>
### `++mate`
++ mate :: merge p,q
|= con=? :: %mate, %meld
@ -903,7 +903,7 @@ XX document
XX document
<h3 id="++keep"><code>++keep</code></h3>
### `++keep`
++ keep :: %this
|= [p=yaki q=yaki [ship desk] [ship desk]]
@ -916,7 +916,7 @@ XX document
XX document
<h3 id="++drop"><code>++drop</code></h3>
### `++drop`
++ drop :: %that
|= [p=yaki q=yaki r=[ship desk] s=[ship desk]]
@ -926,7 +926,7 @@ XX document
XX document
<h3 id="++forge"><code>++forge</code></h3>
### `++forge`
++ forge :: %forge
|= [p=yaki q=yaki s=[ship desk] t=[ship desk]]
@ -960,7 +960,7 @@ XX document
XX document
<h3 id="++merge"><code>++merge</code></h3>
### `++merge`
++ merge
|= [us=[ship desk] th=[ship desk]]
@ -978,7 +978,7 @@ XX document
XX document
<h3 id="++strategy"><code>++strategy</code></h3>
### `++strategy`
++ strategy :: merge strategy
|= gem=?(%meld %mate %that %this)
@ -992,7 +992,7 @@ XX document
XX document
<h3 id="++construct-merge"><code>++construct-merge</code></h3>
### `++construct-merge`
++ construct-merge :: construct-merge:ze
|= [gem=germ who=ship des=desk sab=saba now=@da] :: construct merge
@ -1040,7 +1040,7 @@ XX document
XX document
<h3 id="++read"><code>++read</code></h3>
### `++read`
++ read :: read:ze
|= mun=mood :: read at point
@ -1061,7 +1061,7 @@ XX document
XX document
<h3 id="++read-at-aeon"><code>++read-at-aeon</code></h3>
### `++read-at-aeon`
++ read-at-aeon :: read-at-aeon:ze
|= [oan=aeon mun=mood] :: seek and read
@ -1073,7 +1073,7 @@ XX document
XX document
<h3 id="++equiv"><code>++equiv</code></h3>
### `++equiv`
++ equiv :: test paths
|= [p=(map path lobe) q=(map path lobe)]
@ -1096,7 +1096,7 @@ XX document
XX document
<h3 id="++edit"><code>++edit</code></h3>
### `++edit`
++ edit :: edit:ze
|= [wen=@da lem=nori] :: edit
@ -1126,7 +1126,7 @@ XX document
XX document
<h3 id="++zu"><code>++zu</code></h3>
### `++zu`
++ zu :: filesystem
|= ank=ankh :: filesystem state
@ -1136,7 +1136,7 @@ XX document
XX document
<h3 id="++rehash"><code>++rehash</code></h3>
### `++rehash`
++ rehash :: local rehash
^- cash
@ -1153,13 +1153,13 @@ XX document
XX document
<h3 id="++update-hash"><code>++update-hash</code></h3>
### `++update-hash`
++ update-hash %_(. p.ank rehash) :: rehash and save
XX document
<h3 id="++ascend"><code>++ascend</code></h3>
### `++ascend`
++ ascend :: ascend
|= [lol=@ta kan=ankh]
@ -1177,7 +1177,7 @@ XX document
XX document
<h3 id="++push-change"><code>++push-change</code></h3>
### `++push-change`
++ push-change :: add change
|= mis=miso
@ -1187,7 +1187,7 @@ XX document
XX document
<h3 id="++descend"><code>++descend</code></h3>
### `++descend`
++ descend :: descend
|= lol=@ta
@ -1198,7 +1198,7 @@ XX document
XX document
<h3 id="++descend-path"><code>++descend-path</code></h3>
### `++descend-path`
++ descend-path :: descend recursively
|= way=path
@ -1208,7 +1208,7 @@ XX document
XX document
<h3 id="++overwrite"><code>++overwrite</code></h3>
### `++overwrite`
++ overwrite :: write over
|= [pum=umph val=(unit ,[p=cash q=*])]
@ -1224,7 +1224,7 @@ XX document
XX document
<h3 id="++change-tree"><code>++change-tree</code></h3>
### `++change-tree`
++ change-tree :: modify tree
|= [pum=umph bus=ankh]
@ -1243,7 +1243,7 @@ XX document
XX document
<h3 id="++rm-r"><code>++rm-r</code></h3>
### `++rm-r`
++ rm-r :: rm -r
|- ^+ +
@ -1257,7 +1257,7 @@ XX document
XX document
<h3 id="++drum"><code>++drum</code></h3>
### `++drum`
++ drum :: apply effect
|= [pax=path mis=miso] :: XX unused (++dune)
@ -1285,7 +1285,7 @@ XX document
XX document
<h3 id="++dune"><code>++dune</code></h3>
### `++dune`
++ dune :: apply
|- ^+ + :: XX unused (++durn)
@ -1296,7 +1296,7 @@ XX document
XX document
<h3 id="++durn"><code>++durn</code></h3>
### `++durn`
++ durn :: apply forward
|= nyp=soba :: XX unused

View File

@ -1,7 +1,7 @@
section 3bF, filesystem interface
=================================
<h3 id="++feel"><code>++feel</code></h3>
### `++feel`
Generate file diff
@ -33,7 +33,7 @@ Generates a diff between a file located at `pax` and an input value
~zod/try=> `@t`272.335.332.724
'tesh?'
<h3 id="++file"><code>++file</code></h3>
### `++file`
Simple file load
@ -62,7 +62,7 @@ Reads the value of a file located at `pax` and renders it as a
~zod/try=/zak> (file /==2%/mop)
~
<h3 id="++foal"><code>++foal</code></h3>
### `++foal`
Write high-level change
@ -90,7 +90,7 @@ at `pax`. Handled by `%clay`.
~zod/try=> (feel %/mek 'b')
[%mut p=[p=%a q=[%a p=97 q=98]]]
<h3 id="++fray"><code>++fray</code></h3>
### `++fray`
High-level delete
@ -113,7 +113,7 @@ Handled by `%clay`.
~zod/try=> `@t`97
'a'
<h3 id="++furl"><code>++furl</code></h3>
### `++furl`
Unify changes
@ -148,7 +148,7 @@ and pointed at the same [`++path`]().
]
]
<h3 id="++meat"><code>++meat</code></h3>
### `++meat`
Kite to .\^ path
@ -181,7 +181,7 @@ Converts a type request name to a [`++path`]().
'''
<h3 id="++tame"><code>++tame</code></h3>
### `++tame`
Parse kite path
@ -220,7 +220,7 @@ Parses a clay [.\^]()
~zod/try=/zop> (tame /~zod/main/0x12/sur/down/gate/hook)
~
<h3 id="++tome"><code>++tome</code></h3>
### `++tome`
Parse path to beam
@ -249,7 +249,7 @@ Parses a [`++path`]() `pax` to a [\`++beam](), a well-typed location.
~zod/try=/zop> (tome /~zod/main/0x12)
~
<h3 id="++tope :: beam to path"><code>++tope :: beam to path</code></h3>
### `++tope :: beam to path`
Parse beam to path

View File

@ -1,7 +1,7 @@
section 3bG, URL handling
=========================
<h3 id="++deft"><code>++deft</code></h3>
### `++deft`
Import URL path
@ -34,7 +34,7 @@ either by a `.` or a `/`.
~zod/try=> (deft /foo/bar/baz)
[p=~ q=<|foo bar baz|>]
<h3 id="++fain"><code>++fain</code></h3>
### `++fain`
Restructure path
@ -73,7 +73,7 @@ Splits a concrete
q=/._req_1234__
]
<h3 id="++fuel"><code>++fuel</code></h3>
### `++fuel`
Parse fcgi
@ -135,7 +135,7 @@ Retrieieves the %eyre FCGI, producing a [`++epic`](). Used primarily in
nyp=/gen
]
<h3 id="++sifo"><code>++sifo</code></h3>
### `++sifo`
64-bit encode
@ -164,7 +164,7 @@ Encodes an atom to MIME base64, producing a [`++tape`]().
~zod/main=> (sifo (shax %hi))
"j0NDRmSPa5bfid2pAcUXaxCm2Dlh3TwayItZstwyeqQ="
<h3 id="++urle"><code>++urle</code></h3>
### `++urle`
Encode URL
@ -198,7 +198,7 @@ escape sequences.
~zod/main=> (urle "hello-my?=me !")
"hello-my%3F%3Dme%20%20%21"
<h3 id="++urld"><code>++urld</code></h3>
### `++urld`
Decode URL
@ -231,7 +231,7 @@ The inverse of [`++urle`](). Parses a URL escaped tape to the
~zod/main=> (urld "hello-my%3F%3Dme%20%2%21")
~
<h3 id="++earl"><code>++earl</code></h3>
### `++earl`
Localize purl
@ -256,7 +256,7 @@ Prepends a ship name to the spur of a [`++purl`]().
~zod/main=> (earn (earl ~pittyp (need (epur 'http://123.1.1.1/me.ham'))))
"http://123.1.1.1/pittyp/me"
<h3 id="++earn"><code>++earn</code></h3>
### `++earn`
Purl to tape
@ -287,7 +287,7 @@ Parses a `++purl` `pul` to a [`++tape`]().
~zod/main=> (earn [& ~ `/com/google/www] [~ /search] [%q 'urbit escaping?'] ~)
"https://www.google.com/search?q=urbit%20escaping%3F"
<h3 id="++body"><code>++body</code></h3>
### `++body`
Render URL path
@ -311,7 +311,7 @@ Renders URL path `pok` as a [`++tape`]().
~zod/main=> (body:earn `%htm /)
""
<h3 id="++head"><code>++head</code></h3>
### `++head`
Render URL beginning
@ -344,7 +344,7 @@ of a traditional URL.
~zod/main=> (head:earn & [~ 8.080] %& /com/google/www)
"https://www.google.com:8080"
<h3 id="++tail"><code>++tail</code></h3>
### `++tail`
Render query string
@ -376,7 +376,7 @@ traditional query string.
~zod/main=> (tail:earn [%ask 'bid'] [%make 'well'] ~)
"?ask=bid&make=well"
<h3 id="++epur"><code>++epur</code></h3>
### `++epur`
Top-level URL parser
@ -428,7 +428,7 @@ Toplevel URL parser.
]
]
<h3 id="++apat"><code>++apat</code></h3>
### `++apat`
++ apat :: 2396 abs_path
%+ cook deft
@ -441,7 +441,7 @@ URL path as ++pork
~zod/try=> (scan "/foo/mol/lok.htm" apat:epur)
[p=[~ ~.htm] q=<|foo mol lok|>]
<h3 id="++auri"><code>++auri</code></h3>
### `++auri`
++ auri
%+ cook
@ -546,7 +546,7 @@ URL parsing rule
]
]
<h3 id="++cock"><code>++cock</code></h3>
### `++cock`
++ cock :: cookie
(most ;~(plug sem ace) ;~(plug toke ;~(pfix tis tosk)))
@ -561,7 +561,7 @@ HTTP cookies, results in associative list of cord to cord.
! {1 34}
! exit
<h3 id="++dlab"><code>++dlab</code></h3>
### `++dlab`
++ dlab :: 2396 domainlabel
%+ sear
@ -583,7 +583,7 @@ Domain label: alphanumeric, with `-` allowed in middle.
! {1 8}
! exit
<h3 id="++fque"><code>++fque</code></h3>
### `++fque`
++ fque (cook crip (plus pquo)) :: normal query field
@ -601,7 +601,7 @@ One or more query string characters
! {1 1}
! exit
<h3 id="++fquu"><code>++fquu</code></h3>
### `++fquu`
++ fquu (cook crip (star pquo)) :: optional field
@ -618,7 +618,7 @@ Zero or more query string characters
~zod/try=> (scan "" fquu:epur)
''
<h3 id="++pcar"><code>++pcar</code></h3>
### `++pcar`
++ pcar ;~(pose pure pesc psub col pat) :: 2396 path char
@ -639,7 +639,7 @@ or `@`
~zod/try=> (scan "!" pcar:epur)
~~~21.
<h3 id="++pcok"><code>++pcok</code></h3>
### `++pcok`
++ pcok ;~(less bas sem com doq prn) :: cookie char
@ -656,7 +656,7 @@ Cookie character
! {1 2}
! exit
<h3 id="++pesc"><code>++pesc</code></h3>
### `++pesc`
++ pesc ;~(pfix cen mes) :: 2396 escaped
@ -667,7 +667,7 @@ URL `%` escape, by two hex characters.
~zod/try=> `@t`(scan "%20" pesc:epur)
' '
<h3 id="++pold"><code>++pold</code></h3>
### `++pold`
++ pold (cold ' ' (just '+')) :: old space code
@ -679,7 +679,7 @@ Old URL `' '` escape
! {1 1}
! exit
<h3 id="++pque"><code>++pque</code></h3>
### `++pque`
++ pque ;~(pose pcar fas wut) :: 3986 query char
@ -694,7 +694,7 @@ Irregular query string character.
~zod/try=> `@t`(scan "+" pque:epur)
'+'
<h3 id="++pquo"><code>++pquo</code></h3>
### `++pquo`
++ pquo ;~(pose pure pesc pold) :: normal query char
@ -712,7 +712,7 @@ Character in query string key/value
~zod/try=> (scan "+" pquo:epur)
' '
<h3 id="++pure"><code>++pure</code></h3>
### `++pure`
++ pure ;~(pose aln hep dot cab sig) :: 2396 unreserved
@ -728,7 +728,7 @@ URL-safe character
~zod/try=> (scan "-" pure:epur)
~~-
<h3 id="++psub"><code>++psub</code></h3>
### `++psub`
++ psub ;~ pose :: 3986 sub-delims
zap buc pam soq pel per
@ -747,7 +747,7 @@ URL path subdelimeter
! {1 1}
! exit
<h3 id="++ptok"><code>++ptok</code></h3>
### `++ptok`
++ ptok ;~ pose :: 2616 token
aln zap hax buc cen pam soq tar lus
@ -761,7 +761,7 @@ Character valid in HTTP token
~zod/try=> `tape`(skim =+(a=' ' |-(`tape`?:(=(0x7f a) ~ [a $(a +(a))]))) |=(a=char ?=(~ (rush a ptok:epur))))
" "(),/:;<=>?@[\]{}"
<h3 id="++scem"><code>++scem</code></h3>
### `++scem`
++ scem :: 2396 scheme
%+ cook cass
@ -778,7 +778,7 @@ alphanumeric, `+` `-` or `.`
~zod/try=> `@t`(scan "chrome-extension" scem:epur)
'chrome-extension'
<h3 id="++smeg"><code>++smeg</code></h3>
### `++smeg`
++ smeg (cook crip (plus pcar)) :: 2396 segment
@ -789,7 +789,7 @@ URL path segment
~zod/try=> (scan "bar%20baz-bam" smeg:epur)
'bar baz-bam'
<h3 id="++tock"><code>++tock</code></h3>
### `++tock`
++ tock (cook crip (plus pcok)) :: 6265 cookie-value
@ -804,7 +804,7 @@ HTTP cookie value
~zod/try=> (rush '"zemug"' tock:epur)
~
<h3 id="++tosk"><code>++tosk</code></h3>
### `++tosk`
++ tosk ;~(pose tock (ifix [doq doq] tock)) :: 6265 cookie-value
@ -819,7 +819,7 @@ Possibly quoted HTTP cookie value
~zod/try=> (rush '"zemug"' tosk:epur)
[~ 'zemug']
<h3 id="++toke"><code>++toke</code></h3>
### `++toke`
++ toke (cook crip (plus ptok)) :: 2616 token
@ -834,7 +834,7 @@ HTTP cookie name
~zod/try=> (rush '"zemug"' toke:epur)
~
<h3 id="++thor"><code>++thor</code></h3>
### `++thor`
++ thor :: 2396 host/port
%+ cook |*(a=[* *] [+.a -.a])
@ -854,7 +854,7 @@ Parse ++host and unit `@ui` port.
~zod/try=> (scan "www.google.com" thor:epur)
[~ [%.y i='com' t=~['google' 'www']]]
<h3 id="++thos"><code>++thos</code></h3>
### `++thos`
++ thos :: 2396 host, no local
;~ plug
@ -887,7 +887,7 @@ URI host: dot-separated segments, or IP address.
~zod/try=> (scan "www.google.com" thos:epur)
[%.y i='com' t=~['google' 'www']]
<h3 id="++yque"><code>++yque</code></h3>
### `++yque`
++ yque :: query ending
;~ pose
@ -904,7 +904,7 @@ Parses query string, or lack thereof. Result type ++quay
~zod/try=> (scan "" yque:epur)
~
<h3 id="++yquy"><code>++yquy</code></h3>
### `++yquy`
++ yquy :: query
;~ pose :: proper query
@ -926,7 +926,7 @@ Parse query string after `?`
~zod/try=> (scan "" yquy:epur)
~
<h3 id="++zest"><code>++zest</code></h3>
### `++zest`
++ zest :: 2616 request-uri
;~ pose

View File

@ -1,7 +1,7 @@
section 3bH, names etc
======================
<h3 id="++clan"><code>++clan</code></h3>
### `++clan`
++ clan :: ship to rank
|= who=ship ^- rank
@ -24,7 +24,7 @@ Ship class
~zod/main=> (clan ~tasfyn-partyv)
%duke
<h3 id="++glam"><code>++glam</code></h3>
### `++glam`
++ glam
|= zar=@pD ^- tape
@ -94,7 +94,7 @@ Retrieve carrier name.
~zod/main=> (glam ~fyr)
"Bolivar"
<h3 id="++glon"><code>++glon</code></h3>
### `++glon`
++ glon
|= lag=lang
@ -296,7 +296,7 @@ ISO language code
~zod/main=> (glon %mz)
~
<h3 id="++gnom"><code>++gnom</code></h3>
### `++gnom`
++ gnom :: ship display name
|= [[our=@p now=@da] him=@p] ^- @t
@ -316,7 +316,7 @@ Fetch display name from %ames
~zod/main=> (gnom [->-< -<-] ~tug)
'~tug |Go-Daigo|'
<h3 id="++gnow"><code>++gnow</code></h3>
### `++gnow`
++ gnow
|= [who=@p gos=gcos] ^- @t
@ -348,7 +348,7 @@ Fetch display name from %ames
XX Document
<h3 id="++hunt"><code>++hunt</code></h3>
### `++hunt`
++ hunt :: first of unit dates
|= [one=(unit ,@da) two=(unit ,@da)]
@ -360,7 +360,7 @@ XX Document
XX Document
<h3 id="++mojo"><code>++mojo</code></h3>
### `++mojo`
++ mojo :: compiling load
|= [pax=path src=*]
@ -381,7 +381,7 @@ XX Document
XX Document
<h3 id="++mole"><code>++mole</code></h3>
### `++mole`
++ mole :: new to old sky
|= ska=$+(* (unit (unit)))
@ -395,7 +395,7 @@ XX Document
XX Document
<h3 id="++much"><code>++much</code></h3>
### `++much`
++ much :: constructing load
|= [pax=path src=*]
@ -407,7 +407,7 @@ XX Document
XX Document
<h3 id="++musk"><code>++musk</code></h3>
### `++musk`
++ musk :: compiling apply
|= [pax=path src=* sam=vase]
@ -419,7 +419,7 @@ XX Document
XX Document
<h3 id="++saxo"><code>++saxo</code></h3>
### `++saxo`
++ saxo :: autocanon
|= who=ship
@ -437,7 +437,7 @@ Compute list of ancestors
~zod/main=> (saxo ~ractul-fodsug-sibryg-modsyl--difrun-mirfun-filrec-patmet)
~[~ractul-fodsug-sibryg-modsyl--difrun-mirfun-filrec-patmet ~zod]
<h3 id="++sein"><code>++sein</code></h3>
### `++sein`
++ sein :: autoboss
|= who=ship ^- ship

File diff suppressed because it is too large Load Diff