Skip to content

5c.md

Latest commit

 

History

History
1006 lines (658 loc) · 13.1 KB

5c.md

File metadata and controls

1006 lines (658 loc) · 13.1 KB
Raw
description Hoon compiler backend and pretty-printing functions for code formatting and output.
layout
title description tableOfContents outline pagination
visible
true
visible
visible
true
visible
true
visible
true

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 $flag.

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 .x as a $tape.

Accepts

.x 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

.y 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

.x 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 .x to a $tank using +deal:us.

Accepts

.x 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 .p to a $tank using +duck:ut.

Accepts

.p 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

.t is a gate in a $vase.

.m 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 .g in type .p using access method .way.

Accepts

.y is a ?(%read %rite %both) (A $vial without %free). This represents the access method (read, write, or both read and write).

.g is a @tas, the name of a wing.

.p is a $type.

Produces

A $flag.

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 .n with subject .x using .*, producing a $vase of the result.

Accepts

.x is a $noun in a $vase, and is the subject.

.n 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']

+slub {#slub}

Memoized +slap.

Compiles hoon .gen with subject .vax, producing a $vase of the result, and caches the compilation.

Accepts

.vax is a $noun in a $vase, and is the subject.

.gen is some $hoon.

Produces

A $vase.

Source

++  slub
  |=  [vax=vase gen=hoon]  ^-  vase
  =/  gun
    =>  [vax=p=p.vax gen=gen ut=ut]
    ~>  %memo./hoon/mint
    (~(mint ut p.vax) %noun gen)
  [p.gun .*(q.vax q.gun)]

Examples

> (slub !>(b='foo') (ream '|=(a=@t [a b])'))
[#t/<1.jtd [a=@t b=@t]> q=[[[0 6] 0 7] 0 7.303.014]]

Discussion

+slub produces the same result as +slap, but wraps the +mint call in a ~> %memo./hoon/mint hint. The runtime therefore caches the compilation keyed on /hoon/mint, so repeating the same compile is cheap.

Note that this cache is a side effect with process lifetime: it is held by the runtime, not by the caller, and is not reflected in the product. +slub is worth preferring over +slap where the same expression is compiled repeatedly in a hot path. The cache can be dropped with the %drop runtime hint or by a |meld with =ford &.

+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 .e in vase .vax, producing the resulting $vase in a +unit which is null if the axis cannot be retrieved.

Accepts

.e is an $atom.

.x is a $vase.

Produces

A (unit vase).

Source

++  slew
  |=  [axe=@ vax=vase]
  =/  typ  |.  (~(peek ut p.vax) %free axe)
  |-  ^-  (unit vase)
  ?:  =(1 axe)  `[$:typ q.vax]
  ?@  q.vax     ~
  $(axe (mas axe), q.vax ?-((cap axe) %2 -.q.vax, %3 +.q.vax))

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

.d 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 .t were slammed with a sample of type .sam.

Accepts

.t is a $type.

.m 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.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

.p 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 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 .d and .tal.

Accepts

.d is a $vase.

.l 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 .e in vase .vax, returning it in a $vase. Crashes if the axis cannot be retrieved.

Accepts

.e is an $atom.

.x 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 .m is ignored and the type of the resulting vase is determined by the gate alone.

Accepts

.t is a $vase.

.m 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 .p is the subject $vase encapsulated in a +trap, and a (trap vase) is produced.

Accepts

.p is a (trap vase).

.n 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