++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) ~ [~ p.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 11 is invoked, sky
computes on the subject and produces a ++unit result. An empty
result becomes a %1 ++tone, indicating a block.
Accepts
sub is the subject as a noun.
fol is the formula as a noun.
sky is an %iron gate invoked with nock operator 11.
Produces
A ++tone.
Source
++ mink
~/ %mink
|= {{sub/* fol/*} gul/$-({* *} (unit (unit)))}
=+ tax=*(list {@ta *})
|- ^- tone
?@ fol
[%2 tax]
?: ?=(^ -.fol)
=+ hed=$(fol -.fol)
?: ?=($2 -.hed)
hed
=+ tal=$(fol +.fol)
?- -.tal
$0 ?-(-.hed $0 [%0 p.hed p.tal], $1 hed)
$1 ?-(-.hed $0 tal, $1 [%1 (weld p.hed p.tal)])
$2 tal
==
?+ fol
[%2 tax]
::
{$0 b/@}
?: =(0 b.fol) [%2 tax]
?: =(1 b.fol) [%0 sub]
?: ?=(@ sub) [%2 tax]
=+ [now=(cap b.fol) lat=(mas b.fol)]
$(b.fol lat, sub ?:(=(2 now) -.sub +.sub))
::
{$1 b/*}
[%0 b.fol]
::
{$2 b/{^ *}}
=+ ben=$(fol b.fol)
?. ?=($0 -.ben) ben
?>(?=(^ p.ben) $(sub -.p.ben, fol +.p.ben))
::?>(?=(^ p.ben) $([sub fol] p.ben)
::
{$3 b/*}
=+ ben=$(fol b.fol)
?. ?=($0 -.ben) ben
[%0 .?(p.ben)]
::
{$4 b/*}
=+ ben=$(fol b.fol)
?. ?=($0 -.ben) ben
?. ?=(@ p.ben) [%2 tax]
[%0 .+(p.ben)]
::
{$5 b/*}
=+ ben=$(fol b.fol)
?. ?=($0 -.ben) ben
?. ?=(^ p.ben) [%2 tax]
[%0 =(-.p.ben +.p.ben)]
::
{$6 b/* c/* d/*}
$(fol =>(fol [2 [0 1] 2 [1 c d] [1 0] 2 [1 2 3] [1 0] 4 4 b]))
::
{$7 b/* c/*} $(fol =>(fol [2 b 1 c]))
{$8 b/* c/*} $(fol =>(fol [7 [[0 1] b] c]))
{$9 b/* c/*} $(fol =>(fol [7 c 0 b]))
{$10 @ c/*} $(fol c.fol)
{$10 {b/* c/*} d/*}
=+ ben=$(fol c.fol)
?. ?=($0 -.ben) ben
?: ?=(?($hunk $hand $lose $mean $spot) b.fol)
$(fol d.fol, tax [[b.fol p.ben] tax])
$(fol d.fol)
::
{$11 b/* c/*}
=+ ref=$(fol b.fol)
=+ ben=$(fol c.fol)
?. ?=($0 -.ref) ref
?. ?=($0 -.ben) ben
=+ val=(gul p.ref p.ben)
?~(val [%1 p.ben ~] ?~(u.val [%2 [[%hunk (mush p.ben)] tax]] [%0 u.u.val]))
==
::
Examples
> (mink [20 [4 0 1]] $~)
[%0 p=21]
> (mink [[90 5 3] [0 3]] $~)
[%0 p=[5 3]]
> (mink 20^[4 0 1] $~)
[%0 p=21]
> (mink [90 5 3]^[0 3] $~)
[%0 p=[5 3]]
> (mink [0]^[11 1 20] $~)
[%1 p=~[20]]
> (mink [0]^[11 1 20] |=(a=* `[40 a]))
[%0 p=[40 20]]
> (mink [5]^[0 2] $~)
[%2 p=~]
> (mink [5]^[10 yelp/[0 1] 0 0] $~)
[%2 p=~[[~.yelp 5]]]++mock
Compute formula on subject with hint
Produces a ++toon, which is either a sucessful, blocked, or
crashed result. If nock 11 is invoked, sky computes on the subject and
produces a ++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.
sky 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 [~ 11 1 0] |=(* `999))
[%0 p=999]
> (mock [~ 0 1.337] ,~)
[%2 p=~]
> (mock [~ 11 1 1.337] ,~)
[%1 p=~[1.337]]
> (mock [[[4 4 4 4 0 3] 10] 11 9 2 0 1] |=(* `[+<]))
[%0 p=14]
> (mock [[[4 4 4 4 0 3] 10] 11 9 2 0 1] |=(* `[<+<>]))
[%0 p=[49 52 0]]
> ;;(tape +:(mock [[[4 4 4 4 0 3] 10] 11 9 2 0 1] |=(* `[<+<>])))
"14"++mong
Slam gate with sample
Produces a ++toon computation result from slamming gat with
sam, using sky to compute or block on nock 11 when applicable.
Accepts
gat is a noun that is generally a gate.
sam is a sample noun.
sky is an %iron gate invoked with nock operator 11.
Produces
A ++toon.
Source
++ mong
|= {{gat/* sam/*} gul/$-({* *} (unit (unit)))}
^- toon
?. &(?=(^ gat) ?=(^ +.gat))
[%2 ~]
(mock [[-.gat [sam +>.gat]] -.gat] 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)) ~] ,~)
[%1 p=~[0]]
> (mong [|=(a/@ .^(a)) ~] ,[~ %42])
[%0 p=42]
> (mong [|=(a/@ .^(a)) ~] |=(a/* [~ a 6]))
[%0 p=[0 6]]
> (mong [|=(a/@ .^(a)) 8] |=(a/* [~ a 6]))
[%0 p=[8 6]]++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
:: =. p.ton (moop p.ton)
=+ yel=(lent p.ton)
=. p.ton
?. (gth yel 256) p.ton
%+ weld
(scag 128 p.ton)
^- (list {@ta *})
:_ (slag (sub yel 128) p.ton)
:- %lose
%+ rap 3
"[skipped {(scow %ud (sub yel 256))} frames]"
|- ^- (list tank)
?~ p.ton ~
=+ rep=$(p.ton t.p.ton)
?+ -.i.p.ton rep
$hunk [(tank +.i.p.ton) rep]
$lose [[%leaf (rip 3 (@ +.i.p.ton))] rep]
$hand [[%leaf (scow %p (mug +.i.p.ton))] rep]
$mean :_ rep
?@ +.i.p.ton [%leaf (rip 3 (@ +.i.p.ton))]
=+ mac=(mack +.i.p.ton +<.i.p.ton)
?~(mac [%leaf "####"] (tank u.mac))
$spot :_ rep
=+ sot=(spot +.i.p.ton)
:+ %rose [":" ~ ~]
:~ (smyt p.sot)
=> [ud=|=(a/@u (scow %ud a)) q.sot]
leaf+"<[{(ud p.p)} {(ud q.p)}].[{(ud p.q)} {(ud q.q)}]>"
== ==
::
Examples
> (mook [%0 5 4 5 1])
[%0 p=[5 4 5 1]]
> (mook [%2 ~[[%hunk %rose ["<" "," ">"] ~[[%leaf "err"]]]]])
[%2 p=~[[%rose p=[p="<" q="," r=">"] q=[i=[%leaf p="err"] t=~]]]]
> (mook [%2 ~[[%malformed %elem] [%lose 'do print']]])
[%2 p=~[[%leaf p="do print"]]]
> (mook [%2 ~[[%mean |.(>(add 5 6)<)]]])
[%2 p=~[[%leaf p="11"]]]
> (mook [%2 ~[[%spot /b/repl [1 1]^[1 2]] [%mean |.(!!)]]])
[%2 p=~[[%leaf p="/b/repl/:<[1 1].[1 2]>"] [%leaf p="####"]]]++mule
Typed virtual
Kicks a ++trap, producing its results or any errors that occur along
the way. Used to lazily compute stack traces.
Accepts
taq is a ++trap, generally producing a list of ++tanks.
Produces
XX
Source
++ mule :: typed virtual
~/ %mule
|* taq/_|.(**)
=+ mud=(mute taq)
?- -.mud
$& [%& p=$:taq] :: XX transition
$| [%| p=p.mud]
==
::
Examples
> (mule |.(leaf/"hello"))
[%.y p=[%leaf "hello"]]
> (mule |.(!!))
[%.n p=~]
> (mule |.(.^(a//=pals/1)))
[ %.n
p
~[
[ %rose
p=[p="/" q="/" r="/"]
q
[ i=[%leaf p="a"]
t=[i=[%leaf p="~zod"] t=[i=[%leaf p="pals"] t=[i=[%leaf p="1"] t=~]]]
]
]
]
]++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
taq is a ++trap.
Produces
Either a noun or a ++list of ++tank.
Source
++ mute :: untyped virtual
|= taq/_^?(|.(**))
^- (each * (list tank))
=+ ton=(mock [taq 9 2 0 1] |=({* *} ~))
?- -.ton
$0 [%& p.ton]
$1 [%| (turn p.ton |=(a/* (smyt (path a))))]
$2 [%| p.ton]
==
Examples
> (mute |.(leaf/"hello"))
[%.y p=[1.717.658.988 104 101 108 108 111 0]]
> (mute |.(!!))
[%.n p=~]