5c: Compiler Backend & Prettyprinter
+ut
+ut
Hoon compiler backend
Source
This core is too large to include here, refer to hoon.hoon
for the source.
+us
+us
Pretty-printer backend
Source
This core is too large to include here, refer to hoon.hoon
for the source.
+cain
+cain
Tank pretty-print
Pretty-print a $vase
as a $tank
using +deal
. This is the same as +sell
.
Accepts
A $vase
.
Produces
A $tank
.
Source
++ cain sell
Examples
> (cain !>(['foo' 'bar']))
[%rose p=[p=" " q="[" r="]"] q=~[[%leaf p="'foo'"] [%leaf p="'bar'"]]]
+noah
+noah
Tape pretty-print
Pretty-print a $vase
as a $tape
. This is the same as +text
.
Accepts
A $vase
.
Produces
A $tape
.
Source
++ noah text
Examples
> (noah !>(['foo' 'bar']))
"['foo' 'bar']"
+onan
+onan
Vise to vase
Convert a $vise
(old $vase
) to the new $vase
. This is the same as +seer
.
Accepts
A $vise
.
Produces
A $vase
.
Source
++ onan seer
Examples
> (onan `vise`!>(['foo' 'bar']))
[#t/[@t @t] q=[7.303.014 7.496.034]]
+levi
+levi
Type nests or crash
Check if type .b
nests under type .a
. Produces %.y
if it nests and crashes if it does not.
Accepts
.a
is a $type
.
.b
is a $type
.
Produces
A ?
.
Source
++ levi
|= [a=type b=type]
(~(nest ut a) & b)
Examples
> (levi -:!>('foo') -:!>(%foo))
%.y
> (levi -:!>(%foo) -:!>('foo'))
-need.%foo
-have.@t
nest-fail
+text
+text
Tape pretty-print
Pretty print vase vax
as a $tape
.
Accepts
vax
is a $vase
.
Produces
A $tape
.
Source
++ text
|= vax=vase ^- tape
~(ram re (sell vax))
Examples
> (text !>(['foo' 'bar']))
"['foo' 'bar']"
+seem
+seem
Promote typo
Convert $typo
(old type) to the new $type
.
Accepts
toy
is a $typo
.
Produces
A $type
.
Source
++ seem |=(toy=typo `type`toy)
Examples
> (seem -:!>('foo'))
#t/@t
+seer
+seer
Promote vise
Convert a $vise
(old $vase
) to the new $vase
.
Accepts
vix
is a $vise
.
Produces
A $vase
.
Source
++ seer |=(vix=vise `vase`vix)
Examples
> (seer !>('foo'))
[#t/@t q=7.303.014]
+sell
+sell
Pretty-print vase to a tank
Pretty-print vase vax
to a $tank
using +deal:us
.
Accepts
vax
is a $vase
.
Produces
A $tank
.
Source
++ sell
~/ %sell
|= vax=vase
^- tank
~| %sell
(~(deal us p.vax) q.vax)
Examples
> (sell !>(['foo' 'bar']))
[%rose p=[p=" " q="[" r="]"] q=~[[%leaf p="'foo'"] [%leaf p="'bar'"]]]
+skol
+skol
Pretty-print type to tank
Pretty-print type typ
to a $tank
using +duck:ut
.
Accepts
typ
is a $type
.
Produces
A $tank
.
Source
++ skol
|= typ=type
^- tank
~(duck ut typ)
Examples
> (skol -:!>(['foo' 'bar']))
[%rose p=[p=" " q="[" r="]"] q=~[[%leaf p="@t"] [%leaf p="@t"]]]
+slam
+slam
Slam a gate
Slam gat
, a gate in a $vase
, with sam
, a sample in a $vase
. Produces a $vase
containing the result.
Accepts
gat
is a gate in a $vase
.
sam
is a noun in a $vase
.
Produces
A $vase
.
Source
++ slam
|= [gat=vase sam=vase] ^- vase
=+ :- ^= typ ^- type
[%cell p.gat p.sam]
^= gen ^- hoon
[%cnsg [%$ ~] [%$ 2] [%$ 3] ~]
=+ gun=(~(mint ut typ) %noun gen)
[p.gun (slum q.gat q.sam)]
Examples
> (slam !>(|=([a=@ud b=@ud] [b a])) !>([1 2]))
[#t/[@ud @ud] q=[2 1]]
+slab
+slab
Test if contains
States whether you can access named wing cog
in type typ
using access method way
.
Accepts
way
is a ?(%read %rite %both)
(A $vial
without %free
). This represents the access method (read, write, or both read and write).
cog
is a @tas
, the name of a wing.
typ
is a $type
.
Produces
A ?
.
Source
++ slab
|= [way=?(%read %rite %both) cog=@tas typ=type]
?= [%& *]
(~(fond ut typ) way ~[cog])
> =au |=(a=@ +(a))
> (slab %read %a -:!>(au))
%.y
> (slab %rite %a -:!>(au))
%.y
> (slab %both %a -:!>(au))
%.y
> (slab %both %blah -:!>(au))
%.n
> =fe ^|(|=(a=@ +(a)))
> (slab %read %a -:!>(fe))
%.n
> (slab %rite %a -:!>(fe))
%.y
> (slab %both %a -:!>(fe))
%.n
+slap
+slap
Untyped vase .*
Compile hoon gen
with subject vax
using .*
, producing a $vase
of the result.
Accepts
vax
is a noun in a $vase
, and is the subject.
gen
is some $hoon
.
Produces
A $vase
.
Source
++ slap
|= [vax=vase gen=hoon] ^- vase
=+ gun=(~(mint ut p.vax) %noun gen)
[p.gun .*(q.vax q.gun)]
Examples
> (slap !>(b='foo') (ream '|=(a=@t [a b])'))
[#t/<1.qgm [a=@t b=@t]> q=[[[0 6] 0 7] 0 7.303.014]]
> !<($-(@t [@t @t]) (slap !>(b='foo') (ream '|=(a=@t [a b])')))
<1|xpg [@t @t @t @t]>
> (!<($-(@t [@t @t]) (slap !>(b='foo') (ream '|=(a=@t [a b])'))) 'bar')
['bar' 'foo']
+slog
+slog
Deify printf
Prints stack trace .a
if the stack trace isn't null, then produces the other input. +slog
first takes .a
, producing a gate. The gate then takes some hoon.
Accepts
.a
is a $tang
, and is the sample of +slog
.
(slog a)
takes some $hoon
.
Produces
The result of the hoon given to (slog a)
, with .a
printed to the terminal.
Source
++ slog
=| pri=@
|= a=tang ^+ same
?~(a same ~>(%slog.[pri i.a] $(a t.a)))
Examples
foo
> ((slog leaf+"foo" ~) (add 1 1))
2
Discussion
+slog
is intended to be put in the middle of a bunch of chained function calls that string a piece of data through them, so that an error message will be printed if there's one to print.
+mean
+mean
Crash and printf
Ends the program and prints .a
, a tracing error message.
Accepts
.a
is a $tang
.
Produces
A crash, with .a
printed to the terminal.
Source
++ mean
|= a=tang
^+ !!
?~ a !!
~_(i.a $(a t.a))
Examples
> (mean leaf+"foo" ~)
foo
dojo: hoon expression failed
+road
+road
Evaluate trap
Evaluate a +trap
, producing the result if successful or else crashing with a trace.
Accepts
A +trap
.
Produces
A noun.
Source
++ road
|* =(trap *)
^+ $:trap
=/ res (mule trap)
?- -.res
%& p.res
%| (mean p.res)
==
Examples
> (road |.("foo"))
"foo"
> (road |.(~|('crash!' !!)))
'crash!'
dojo: hoon expression failed
+slew
+slew
Get axis in vase
Get axis axe
in vase vax
, producing the resulting $vase
in a +unit
which is null if the axis cannot be retrieved.
Accepts
axe
is an atom.
vax
is a $vase
.
Produces
A (unit vase)
.
Source
++ slew
|= [axe=@ vax=vase] ^- (unit vase)
?. |- ^- ?
?: =(1 axe) &
?. ?=(^ q.vax) |
$(axe (mas axe), q.vax .*(q.vax [0 (cap axe)]))
~
`[(~(peek ut p.vax) %free axe) .*(q.vax [0 axe])]
Examples
> (slew 3 !>(['foo' 'bar']))
[~ [#t/@t q=7.496.034]]
> !<(@t (need (slew 3 !>(['foo' 'bar']))))
'bar'
> (slew 7 !>(['foo' 'bar']))
~
+slim
+slim
Identical to +seer
Convert a $vise
(old $vase
) to a $vase
. Identical to +seer
.
Accepts
old
is a $vise
.
Produces
A $vase
.
Source
++ slim
|= old=vise ^- vase
old
Examples
> (slim !>('foo'))
[#t/@t q=7.303.014]
+slit
+slit
Type of slam
The $type
produced if a gate of type gat
were slammed with a sample of type sam
.
Accepts
gat
is a $type
.
sam
is a $type
.
Produces
A $type
.
Source
++ slit
|= [gat=type sam=type]
?> (~(nest ut (~(peek ut gat) %free 6)) & sam)
(~(play ut [%cell gat sam]) [%cnsg [%$ ~] [%$ 2] [%$ 3] ~])
Examples
> (slit -:!>(|*(a=@ [a a])) -:!>(42))
#t/[@ud @ud]
> (slit -:!>(|*(a=@ [a a])) -:!>('foo'))
#t/[@t @t]
+slob
+slob
Superficial arm
Source
++ slob
|= [cog=@tas typ=type]
^- ?
?+ typ |
[%hold *] $(typ ~(repo ut typ))
[%hint *] $(typ ~(repo ut typ))
[%core *]
|- ^- ?
?~ q.r.q.typ |
?| (~(has by q.q.n.q.r.q.typ) cog)
$(q.r.q.typ l.q.r.q.typ)
$(q.r.q.typ r.q.r.q.typ)
==
==
+sloe
+sloe
Get arms in core
Produces a list of the arms in a core of type typ
.
Accepts
typ
is a type.
Produces
A (list term)
.
Source
++ sloe
|= typ=type
^- (list term)
?+ typ ~
[%hold *] $(typ ~(repo ut typ))
[%hint *] $(typ ~(repo ut typ))
[%core *]
%- zing
%+ turn ~(tap by q.r.q.typ)
|= [* b=tome]
%+ turn ~(tap by q.b)
|= [a=term *]
a
==
Examples
> (sloe -:!>(|=(@ 1)))
~[%$]
> =cr |%
++ foo 1
++ bar 2
++ baz 3
--
> (sloe -:!>(cr))
~[%foo %baz %bar]
> (sloe -:!>(42))
~
+slop
+slop
Cons two vases
Produce the vase of a cell of vases hed
and tal
.
Accepts
hed
is a $vase
.
tal
is a $vase
.
Produces
A $vase
.
Source
++ slop
|= [hed=vase tal=vase]
^- vase
[[%cell p.hed p.tal] [q.hed q.tal]]
Examples
> (slop !>('foo') !>(42))
[#t/[@t @ud] q=[7.303.014 42]]
> !<([@t @ud] (slop !>('foo') !>(42)))
['foo' 42]
+slot
+slot
Got axis in vase
Get axis axe
in vase vax
, returning it in a $vase
. Crashes if the axis cannot be retrieved.
Accepts
axe
is an atom.
vax
is a $vase
.
Produces
A $vase
.
Source
++ slot
|= [axe=@ vax=vase] ^- vase
[(~(peek ut p.vax) %free axe) .*(q.vax [0 axe])]
Examples
> (slot 3 !>(['foo' 'bar']))
[#t/@t q=7.496.034]
> !<(@t (slot 3 !>(['foo' 'bar'])))
'bar'
> (slot 7 !>(['foo' 'bar']))
dojo: hoon expression failed
+slym
+slym
Slam without sample-type
Slam gat
, a gate in a $vase
, with sam
, a $noun
. The type of sam
is ignored and the type of the resulting vase is determined by the gate alone.
Accepts
gat
is a $vase
.
sam
is a noun.
Produces
A $vase
.
Source
++ slym
|= [gat=vase sam=*] ^- vase
(slap gat(+<.q sam) [%limb %$])
Examples
> (slym !>(|*(a=@ux [a a])) 'foo')
[#t/[@ux @ux] q=[7.303.014 7.303.014]]
> (slym !>(|*(a=@ux [a a])) "foobar")
[#t/[@ux @ux] q=[[102 111 111 98 97 114 0] 102 111 111 98 97 114 0]]
+sped
+sped
Reconstruct type
Source
++ sped
|= vax=vase
^- vase
:_ q.vax
?@ q.vax (~(fuse ut p.vax) [%atom %$ ~])
?@ -.q.vax
^= typ
%- ~(play ut p.vax)
[%wtgr [%wtts [%leaf %tas -.q.vax] [%& 2]~] [%$ 1]]
(~(fuse ut p.vax) [%cell %noun %noun])
+swat
+swat
Deferred +slap
This is the same as +slap
except tap
is the subject $vase
encapsulated in a trap
, and a (trap vase)
is produced.
Accepts
tap
is a (trap vase)
.
gen
is $hoon
.
Produces
A (trap vase)
.
Source
++ swat
|= [tap=(trap vase) gen=hoon]
^- (trap vase)
=/ gun (~(mint ut p:$:tap) %noun gen)
|. ~+
[p.gun .*(q:$:tap q.gun)]
Examples
> %. 10
!< $-(@ @)
%- road
%+ swat
|.(!>(add-42=(cury add 42)))
(ream '|=(a=@ (add-42 a))')
52
Last updated