++mack
Nock subject to unit
Accepts a nock subject-formula cell and wraps it into a unit. fol is pure nock, meaning that nock 11 operations result in a block, producing a ~.
Accepts
sub is a subject noun.
fol is a formula noun, which is generally a nock.
Produces
The unit of a noun.
Source
++ mack|= [sub=* fol=*]^- (unit)=/ ton (mink [sub fol] |~(^ ~))?.(?=(%0 -.ton) ~ `product.ton)
Examples
> (mack [[1 2 3] [0 1]])[~ [1 2 3]]> (mack [41 4 0 1])[~ 42]> (mack [4 0 4])~> (mack [[[0 2] [1 3]] 4 4 4 4 0 5])[~ 6]> ;;((unit @tas) (mack [[1 %yes %no] 6 [0 2] [0 6] 0 7]))[~ %no]
++mink
Mock interpreter
Bottom-level mock (virtual nock) interpreter. Produces a tone, a nock computation result. If nock 12 is invoked, scry computes on the subject and produces a (unit (unit)) result. An empty result becomes a %1 tone, indicating a block.
Accepts
subject is the subject as a noun.
formula is the formula as a noun.
scry is an %iron gate invoked with nock operator 12.
Produces
A tone.
Source
++ mink !.~/ %mink|= $: [subject=* formula=*]scry=$-(^ (unit (unit)))===| trace=(list [@ta *])|^ ^- tone?+ formula [%2 trace][^ *]=/ head $(formula -.formula)?. ?=(%0 -.head) head=/ tail $(formula +.formula)?. ?=(%0 -.tail) tail[%0 product.head product.tail]::[%0 axis=@]=/ part (frag axis.formula subject)?~ part [%2 trace][%0 u.part]::[%1 constant=*][%0 constant.formula]::[%2 subject=* formula=*]=/ subject $(formula subject.formula)?. ?=(%0 -.subject) subject=/ formula $(formula formula.formula)?. ?=(%0 -.formula) formula%= $subject product.subjectformula product.formula==::[%3 argument=*]=/ argument $(formula argument.formula)?. ?=(%0 -.argument) argument[%0 .?(product.argument)]::[%4 argument=*]=/ argument $(formula argument.formula)?. ?=(%0 -.argument) argument?^ product.argument [%2 trace][%0 .+(product.argument)]::[%5 a=* b=*]=/ a $(formula a.formula)?. ?=(%0 -.a) a=/ b $(formula b.formula)?. ?=(%0 -.b) b[%0 =(product.a product.b)]::[%6 test=* yes=* no=*]=/ result $(formula test.formula)?. ?=(%0 -.result) result?+ product.result[%2 trace]%& $(formula yes.formula)%| $(formula no.formula)==::[%7 subject=* next=*]=/ subject $(formula subject.formula)?. ?=(%0 -.subject) subject%= $subject product.subjectformula next.formula==::[%8 head=* next=*]=/ head $(formula head.formula)?. ?=(%0 -.head) head%= $subject [product.head subject]formula next.formula==::[%9 axis=@ core=*]=/ core $(formula core.formula)?. ?=(%0 -.core) core=/ arm (frag axis.formula product.core)?~ arm [%2 trace]%= $subject product.coreformula u.arm==::[%10 [axis=@ value=*] target=*]?: =(0 axis.formula) [%2 trace]=/ target $(formula target.formula)?. ?=(%0 -.target) target=/ value $(formula value.formula)?. ?=(%0 -.value) value=/ mutant=(unit *)(edit axis.formula product.target product.value)?~ mutant [%2 trace][%0 u.mutant]::[%11 tag=@ next=*]=/ next $(formula next.formula)?. ?=(%0 -.next) next:- %0.* subject[11 tag.formula 1 product.next]::[%11 [tag=@ clue=*] next=*]=/ clue $(formula clue.formula)?. ?=(%0 -.clue) clue=/ next=? trace?=(?(%hunk %hand %lose %mean %spot) tag.formula)[[tag.formula product.clue] trace]$(formula next.formula)?. ?=(%0 -.next) next:- %0.* subject[11 [tag.formula 1 product.clue] 1 product.next]::[%12 ref=* path=*]=/ ref $(formula ref.formula)?. ?=(%0 -.ref) ref=/ path $(formula path.formula)?. ?=(%0 -.path) path=/ result (scry product.ref product.path)?~ result[%1 product.path]?~ u.result[%2 [%hunk product.ref product.path] trace][%0 u.u.result]==::++ frag|= [axis=@ noun=*]^- (unit)?: =(0 axis) ~|- ^- (unit)?: =(1 axis) `noun?@ noun ~=/ pick (cap axis)%= $axis (mas axis)noun ?-(pick %2 -.noun, %3 +.noun)==::++ edit|= [axis=@ target=* value=*]^- (unit)?: =(1 axis) `value?@ target ~=/ pick (cap axis)=/ mutant%= $axis (mas axis)target ?-(pick %2 -.target, %3 +.target)==?~ mutant ~?- pick%2 `[u.mutant +.target]%3 `[-.target u.mutant]==--
Examples
> (mink [20 [4 0 1]] ,~)[%0 product=21]> (mink [[[4 5] [6 14 15]] [0 7]] ,~)[%0 product=[14 15]]> (mink [42 12 [0 1] [1 73]] |=(a=^ ``(add (,[@ @] a))))[%0 product=115]> (mink [0 12 [1 0] [1 0]] |=(* ~))[%1 block=0]> (mink [42 0 2] ,~)[%2 trace=~]
++mock
Compute formula on subject with hint
Produces a toon, which is either a sucessful, blocked, or crashed result. If nock 11 is invoked, gul computes on the subject and produces a (unit (unit)) result. An empty result becomes a %1 tune, indicating a block.
Accepts
sub is the subject as a noun.
fol is the formula as a noun.
gul is an %iron gate invoked with nock operator 11.
Produces
The unit of a noun.
Source
++ mock|= [[sub=* fol=*] gul=$-(^ (unit (unit)))](mook (mink [sub fol] gul))
Examples
> (mock [5 4 0 1] ,~)[%0 p=6]> (mock [0 12 [0 1] [0 1]] |=(* ``999))[%0 p=999]> (mock [42 12 [0 1] [0 1]] |=(* ~))[%1 p=42]> (mock [42 0 2] ,~)[%2 p=~]
++mook
Intelligently render crash annotation
Converts a %2 tone nock stack trace to a list of tank. Each may be a tank, cord, spot, or trapped tank.
Accepts
ton is a tone.
Produces
A toon.
Source
++ mook|= ton=tone^- toon?. ?=([%2 *] ton)ton|^ [%2 (turn skip rend)]::++ skip^+ trace.ton=/ yel (lent trace.ton)?. (gth yel 1.024) trace.ton%+ weld(scag 512 trace.ton)^+ trace.ton:_ (slag (sub yel 512) trace.ton):- %lose(crip "[skipped {(scow %ud (sub yel 1.024))} frames]"):::: +rend: raw stack frame to tank:::: $% [%hunk ref=* path] :: failed scry ([~ ~]):: [%lose cord] :: skipped frames:: [%hand *] :: mug any:: [%mean $@(cord (trap tank))] :: ~_ et al:: [%spot spot] :: source location:: ==::++ rend|= [tag=@ta dat=*]^- tank?+ tag::leaf+"mook.{(rip 3 tag)}"::%hunk?@ dat leaf+"mook.hunk"=/ sof=(unit path) ((soft path) +.dat)?~ sof leaf+"mook.hunk"(smyt u.sof)::%lose?^ dat leaf+"mook.lose"leaf+(rip 3 dat)::%handleaf+(scow %p (mug dat))::%mean?@ dat leaf+(rip 3 dat)=/ mac (mack dat -.dat)?~ mac leaf+"####"=/ sof ((soft tank) u.mac)?~ sof leaf+"mook.mean"u.sof::%spot=/ sof=(unit spot) ((soft spot) dat)?~ sof leaf+"mook.spot":+ %rose [":" ~ ~]:~ (smyt p.u.sof)=* l p.q.u.sof=* r q.q.u.sof=/ ud |=(a=@u (scow %ud a))leaf+"<[{(ud p.l)} {(ud q.l)}].[{(ud p.r)} {(ud q.r)}]>"====--
Examples
> (mook [%0 5 4 5 1])[%0 p=[5 4 5 1]]> (mook [%2 ~[[%hunk %rose ["<" "," ">"] ~[[%leaf "err"]]]]])[%2 p=~[[%leaf p="mook.hunk"]]]> (mook [%2 ~[[%mean |.(>(add 5 6)<)]]])[%2 p=~[[%leaf p="11"]]]> (mook [%2 ~[[%spot /b/repl [1 1]^[1 2]] [%mean |.(!!)]]])[ %2p~[[ %rosep=[p=":" q="" r=""]q[ i[ %rosep=[p="/" q="/" r=""]q=[i=[%leaf p="b"] t=[i=[%leaf p="repl"] t=~]]]t=[i=[%leaf p="<[1 1].[1 2]>"] t=~]]][%leaf p="####"]]]
++mole
Typed unitary virtual
Kicks a trap, producing its result in a unit if successful, or a null unit if it crashed. Unitized version of ++mule.
Accepts
tap is a trap.
Produces
A (unit *), where the * will be the type produced by the expression.
Source
++ mole~/ %mole|* tap=(trap)^- (unit _$:tap)=/ mur (mure tap)?~(mur ~ `$:tap)
Examples
> (mole |.(`@t`(add 50 47)))[~ 'a']> (mole |.(~|('Error!' !!)))~
++mong
Slam gate with sample
Produces a toon computation result from slamming gat with sam, using gul to compute or block on nock 11 when applicable.
Accepts
gat is a noun that is generally a gate.
sam is a sample noun.
gul is an %iron gate invoked with nock operator 11.
Produces
A toon.
Source
++ mong|= [[gat=* sam=*] gul=$-(^ (unit (unit)))]^- toon?. ?=([* ^] gat) [%2 ~](mock [gat(+< sam) %9 2 %0 1] gul)
Examples
> (mong [|=(@ 20) ~] ,~)[%0 p=20]> (mong [|=(@ !!) ~] ,~)[%2 p=~]> (mong [|=(a=@ (add 20 a)) ~] ,~)[%0 p=20]> (mong [|=(a=[@ @] (add 20 -.a)) ~] ,~)[%2 p=~]> (mong [|=(a=[@ @] (add 20 -.a)) [4 6]] ,~)[%0 p=24]> (mong [|=(a=@ .^(* a)) 99] |=(^ ``+<))[%0 p=[[140 1.853.189.998] 99]]> (mong [|=(a=@ .^(@ a)) 99] |=([* a=*] ``+((,@ a))))[%0 p=100]
++mule
Typed virtual
Kicks a trap, producing its results or any errors that occur along the way. Used to lazily compute stack traces.
Accepts
tap is a trap, generally producing a list of tanks.
Produces
An (each * (list tank)) - %.y indicates success and %.n indicates a crash.
Source
++ mule~/ %mule|* tap=(trap)=/ mud (mute tap)?- -.mud%& [%& p=$:tap]%| [%| p=p.mud]==
Examples
> (mule |.((add 1 1)))[%.y p=2]> (mule |.(~|(%error !!)))[%.n p=~[[%leaf p="%error"]]]
++mure
Untyped unitary virtual
Kicks a trap, producing its results in a unit which is null if it crashed. The result is just a noun, no type information is preserved.
Accepts
A trap.
Produces
A (unit *).
Source
++ mure|= tap=(trap)^- (unit)=/ ton (mink [tap %9 2 %0 1] |=((pair) ``.*(~ [%12 1+p 1+q])))?.(?=(%0 -.ton) ~ `product.ton)
Examples
> (mure |.(~|(%error !!)))~> (mure |.((add 1 1)))[~ 2]> (mure |.('foo'))[~ 7.303.014]> ((unit @t) (mure |.('foo')))[~ 'foo']
++mute
Untyped virtual
Kicks a trap, producing its result as a noun or the tanks of any error that occurs. Similar to ++mule, but preserves no type information.
Accepts
tap is a trap.
Produces
A (each * (list tank)), where %.y indicates success and %.n indicates failure.
Source
++ mute|= tap=(trap)^- (each * (list tank))=/ ton (mock [tap %9 2 %0 1] |=((pair) ``.*(~ [%12 1+p 1+q])))?- -.ton%0 [%& p.ton]::%1 =/ sof=(unit path) ((soft path) p.ton)[%| ?~(sof leaf+"mute.hunk" (smyt u.sof)) ~]::%2 [%| p.ton]==
Examples
> (mute |.(leaf+"hello"))[%.y p=[1.717.658.988 104 101 108 108 111 0]]> (mute |.(!!))[%.n p=~]> (mute |.(~|(%error !!)))[%.n p=~[[%leaf p="%error"]]]> (mute |.((cat 3 'foo' 'bar')))[%.y p=125.762.588.864.358]
++slum
Slam a gate on a sample using raw nock, untyped
Slam gat with sam. Uses a raw .* nock expression internally and does not preserve type information for the result. This will crash if evaluation crashes.
Examples
> (slum |=([a=@ b=@] (add a b)) [7 9])16> (slum (cury cat 3) ['foo' 'bar'])125.762.588.864.358> (@t (slum (cury cat 3) ['foo' 'bar']))'foobar'> (slum |=(* !!) 42)dojo: hoon expression failed
++soft
Virtual clam
Clam (mold) noun fud with mold han, producing a unit of the result. The unit is null if clamming failed. This is curried, so the soft-clamming gate can be stored and called repeatedly.
Accepts
han is a mold.
fud is a noun.
Produces
A (unit *), where the * will be the type produced by the mold.
Source
++ soft|* han=$-(* *)|=(fud=* (mole |.((han fud))))
Examples
> ((soft @t) 97)[~ 'a']> ((soft @t) [1 2])~> ((soft ,[@ux @ux]) ['a' 'b'])[~ [0x61 0x62]]