| description | Functions for formatting and rendering dimes, atoms, and other data types as text. | |||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| layout |
|
Parse $path to $pith.
Parses each segment of a $path into a typed $iota. A segment that does not parse as any recognised aura is kept as [%ta segment].
.path is a $path.
A $pith.
++ pave
|= =path
^- pith
%+ turn path
|= i=@ta
(fall (rush i spot:stip) [%ta i])> (pave /foo/123/0xdead)
~[%foo [%ud 123] [%ux 0xdead]]
Note that a cast does not do this — `pith`/foo/123 produces ~[%foo %123], leaving the segments as bare @tas.
Render $pith to $path.
The inverse of +pave: renders each $iota back to a @ta segment with +scot.
.pith is a $pith.
A $path.
++ pout
|= =pith
^- path
%+ turn pith
|= i=iota
?@(i i (scot i))> (pout (pave /foo/123/0xdead))
/foo/123/0xdead
Render $dime as $cord.
Renders a $dime .mol as a $cord.
.mol is a $dime.
A $cord.
++ scot
~/ %scot
|=(mol=dime ~(rent co %$ mol))> (scot %p ~pillyt)
~.~pillyt
> `@t`(scot %p ~pillyt)
'~pillyt'
> `@t`(scot %ux 0x12)
'0x12'
> `@t`(scot %if .127.0.0.1)
'.127.0.0.1'
> `@t`(scot %ta ~.asd_a)
'~.asd_a'
Render $dime as $tape.
Renders a $dime .mol as a $tape.
.mol is a $dime.
A $tape.
++ scow
~/ %scow
|=(mol=dime ~(rend co %$ mol))> (scow %p ~pillyt)
"~pillyt"
> (scow %ux 0x12)
"0x12"
> (scow %if .127.0.0.1)
".127.0.0.1"
> (scow %ta ~.asd_a)
"~.asd_a"
Curried slaw.
Produces a $gate that parses a $knot .txt to a +unit containing the $atom of the aura specified by .mod. The +unit will be null if parsing failed.
.mod is a $knot.
.txt is a $cord.
A (unit @).
++ slat |=(mod=@tas |=(txt=@ta (slaw mod txt)))> `(unit @p)`((slat %p) '~pillyt')
[~ ~pillyt]
> `(unit @ux)`((slat %ux) '0x12')
[~ 0x12]
> `(unit @if)`((slat %if) '.127.0.0.1')
[~ .127.0.0.1]
> `(unit @ta)`((slat %ta) '~.asd_a')
[~ ~.asd_a]
Demand: parse $cord with input aura.
Parses a $cord .txt to an $atom of the aura specificed by .mod. Crashes if it fails to parse.
.mod is a $term
.txt is a $knot.
an $atom.
++ slav |=([mod=@tas txt=@ta] (need (slaw mod txt)))> `@p`(slav %p '~pillyt')
~pillyt
> `@p`(slav %p '~pillam')
! exit
> `@ux`(slav %ux '0x12')
0x12
> `@ux`(slav %ux '0b10')
! exit
> `@if`(slav %if '.127.0.0.1')
.127.0.0.1
> `@if`(slav %if '.fe80.0.0.202')
! exit
> `@ta`(slav %ta '~.asd_a')
~.asd_a
> `@ta`(slav %ta '~~asd-a')
! exit
Parse $cord to input aura.
Parses a $cord .txt to a +unit containing the $atom of the aura specified by .mod. The +unit is null if parsing failed.
.mod is a $term.
.txt is a $knot.
A (unit @).
++ slaw
~/ %slaw
|= [mod=@tas txt=@ta]
^- (unit @)
?+ mod
:: slow fallback case to the full slay
::
=+ con=(slay txt)
?.(&(?=([~ %$ @ @] con) =(p.p.u.con mod)) ~ [~ q.p.u.con])
::
%da
(rush txt ;~(pfix sig (cook year when:so)))
::
%p
(rush txt ;~(pfix sig fed:ag))
::
%ud
(rush txt dem:ag)
::
%ux
(rush txt ;~(pfix (jest '0x') hex:ag))
::
%uv
(rush txt ;~(pfix (jest '0v') viz:ag))
::
%ta
(rush txt ;~(pfix ;~(plug sig dot) urs:ab))
::
%tas
(rush txt sym)
==> `(unit @p)`(slaw %p '~pillyt')
[~ ~pillyt]
> `(unit @p)`(slaw %p '~pillam')
~
> `(unit @ux)`(slaw %ux '0x12')
[~ 0x12]
> `(unit @ux)`(slaw %ux '0b10')
~
> `(unit @if)`(slaw %if '.127.0.0.1')
[~ .127.0.0.1]
> `(unit @if)`(slaw %if '.fe80.0.0.202')
~
> `(unit @ta)`(slaw %ta '~.asd_a')
[~ ~.asd_a]
> `(unit @ta)`(slaw %ta '~~asd-a')
~
Parse $cord to $coin.
Parses a $cord .txt to the unit of a $coin.
.txt is a @ta.
A (unit coin).
++ slay
|= txt=@ta ^- (unit coin)
=+ ^= vex
?: (gth 0x7fff.ffff txt) :: XX petty cache
~+ ((full nuck:so) [[1 1] (trip txt)])
((full nuck:so) [[1 1] (trip txt)])
?~ q.vex
~
[~ p.u.q.vex]> (slay '~pillyt')
[~ [%$ p=[p=~.p q=13.184]]]
> (slay '0x12')
[~ [%$ p=[p=~.ux q=18]]]
> (slay '.127.0.0.1')
[~ [%$ p=[p=~.if q=2.130.706.433]]]
> (slay '!')
~
Render $path as $tank.
Renders the $path .bon as a $tank, which is used for pretty-printing.
.bon is a $path.
A $tank.
++ smyt
|= bon=path ^- tank
:+ %rose [['/' ~] ['/' ~] ~]
(turn bon |=(a=@ [%leaf (trip a)]))> (smyt %)
[ %rose
p=[p="/" q="/" r=""]
q
~[
[%leaf p="~zod"]
[%leaf p="base"]
[%leaf p="~2022.1.6..14.22.14..40bf"]
]
]
> (smyt /as/les/top)
[ %rose
p=[p="/" q="/" r=""]
q=~[[%leaf p="as"] [%leaf p="les"] [%leaf p="top"]]
]
Render $path as $cord.
Renders a $path .pax as $cord.
.pax is a $path.
A $cord.
++ spat |=(pax=path (crip (spud pax)))> (spat %)
'/~zod/base/~2022.1.6..14.23.31..e367'
> (spat %/lib)
'/~zod/base/~2022.1.6..14.23.43..829e/lib'
> (spat /as/les/top)
'/as/les/top'
Render $path as $tape.
Renders a $path .pax as $tape.
.pax is a $path.
A $tape.
++ spud |=(pax=path ~(ram re (smyt pax)))> (spud %)
"/~zod/base/~2022.1.6..14.24.35..cddf"
> (spud %/lib)
"/~zod/base/~2022.1.6..14.24.43..3efb/lib"
> (spud /as/les/top)
"/as/les/top"
Parse $cord to $path.
Parses a $cord .zep to a static $path. Crashes if it fails to parse.
.zep is a @t.
A $path, or crash.
++ stab |=(zep=@t `path`(rash zep stap))> (stab '/as/lek/tor')
/as/lek/tor
Typed path parser.
A parser core for $piths. Used by +pave.
++ stip
=< swot
|%
++ swot |=(n=nail (;~(pfix fas (more fas spot)) n))
::
++ spot
%+ sear (soft iota)The core reduces to +swot, so +stip used directly parses a whole path.
Parses a single path segment into an $iota.
> (rash '123' spot:stip)
[%ud 123]
> (rash '0xdead' spot:stip)
[%ux 0xdead]
Parses a whole /-separated path into a $pith.
> (rash '/foo/123' swot:stip)
[%foo [i=[%ud 123] t=~]]
Path parser.
Parsing $rule. Parses a $path, used internally by +stab.
++ stap
%+ sear
|= p=path
^- (unit path)
?: ?=([~ ~] p) `~
?. =(~ (rear p)) `p
~
;~(pfix fas (most fas urs:ab))> (scan "/foo/bar/baz" stap)
/foo/bar/baz