11Accepts a nock subject-formula cell and wraps it into a `++unit`.
12`fol` is pure nock, meaning that nock `11` operations result in a block,
18`sub` is a subject noun.
20`fol` is a formula noun, which is generally a `++nock`.
25The `++unit` of a noun.
33 =+ ton=(mink [sub fol] |=({* *} ~))
34 ?.(?=({$0 *} ton) ~ [~ p.ton])
41 > (mack [[1 2 3] [0 1]])
47 > (mack [[[0 2] [1 3]] 4 4 4 4 0 5])
49 > ;;((unit @tas) (mack [[1 %yes %no] 6 [0 2] [0 6] 0 7]))
59Bottom-level mock (virtual nock) interpreter. Produces a
60`++tone`, a nock computation result. If nock 11 is invoked, `sky`
61computes on the subject and produces a `++unit` result. An empty
62result becomes a `%1` `++tone`, indicating a block.
67`sub` is the subject as a noun.
69`fol` is the formula as a noun.
71`sky` is an `%iron` gate invoked with nock operator 11.
83 |= {{sub/* fol/*} gul/$-({* *} (unit (unit)))}
84 =+ tax=*(list {@ta *})
94 $0 ?-(-.hed $0 [%0 p.hed p.tal], $1 hed)
95 $1 ?-(-.hed $0 tal, $1 [%1 (weld p.hed p.tal)])
102 ?: =(0 b.fol) [%2 tax]
103 ?: =(1 b.fol) [%0 sub]
104 ?: ?=(@ sub) [%2 tax]
105 =+ [now=(cap b.fol) lat=(mas b.fol)]
106 $(b.fol lat, sub ?:(=(2 now) -.sub +.sub))
114 ?>(?=(^ p.ben) $(sub -.p.ben, fol +.p.ben))
115 ::?>(?=(^ p.ben) $([sub fol] p.ben)
125 ?. ?=(@ p.ben) [%2 tax]
131 ?. ?=(^ p.ben) [%2 tax]
132 [%0 =(-.p.ben +.p.ben)]
135 $(fol =>(fol [2 [0 1] 2 [1 c d] [1 0] 2 [1 2 3] [1 0] 4 4 b]))
137 {$7 b/* c/*} $(fol =>(fol [2 b 1 c]))
138 {$8 b/* c/*} $(fol =>(fol [7 [[0 1] b] c]))
139 {$9 b/* c/*} $(fol =>(fol [7 c 0 b]))
140 {$10 @ c/*} $(fol c.fol)
144 ?: ?=(?($hunk $hand $lose $mean $spot) b.fol)
145 $(fol d.fol, tax [[b.fol p.ben] tax])
153 =+ val=(gul p.ref p.ben)
154 ?~(val [%1 p.ben ~] ?~(u.val [%2 [[%hunk (mush p.ben)] tax]] [%0 u.u.val]))
162 > (mink [20 [4 0 1]] $~)
164 > (mink [[90 5 3] [0 3]] $~)
166 > (mink 20^[4 0 1] $~)
168 > (mink [90 5 3]^[0 3] $~)
170 > (mink [0]^[11 1 20] $~)
172 > (mink [0]^[11 1 20] |=(a=* `[40 a]))
174 > (mink [5]^[0 2] $~)
176 > (mink [5]^[10 yelp/[0 1] 0 0] $~)
183Compute formula on subject with hint
185Produces a `++toon`, which is either a sucessful, blocked, or
186crashed result. If nock 11 is invoked, `sky` computes on the subject and
187produces a `++unit` result. An empty result becomes a `%1` `++tune`,
193`sub` is the subject as a noun.
195`fol` is the formula as a noun.
197`sky` is an %iron gate invoked with nock operator 11.
202The `++unit` of a noun.
208 |= {{sub/* fol/*} gul/$-({* *} (unit (unit)))}
209 (mook (mink [sub fol] gul))
216 > (mock [5 4 0 1] ,~)
218 > (mock [~ 11 1 0] |=(* `999))
220 > (mock [~ 0 1.337] ,~)
222 > (mock [~ 11 1 1.337] ,~)
224 > (mock [[[4 4 4 4 0 3] 10] 11 9 2 0 1] |=(* `[+<]))
226 > (mock [[[4 4 4 4 0 3] 10] 11 9 2 0 1] |=(* `[<+<>]))
228 > ;;(tape +:(mock [[[4 4 4 4 0 3] 10] 11 9 2 0 1] |=(* `[<+<>])))
238Produces a `++toon` computation result from slamming `gat` with
239`sam`, using `sky` to compute or block on nock 11 when applicable.
244`gat` is a noun that is generally a `gate`.
246`sam` is a `sample` noun.
248`sky` is an %iron gate invoked with nock operator 11.
259 |= {{gat/* sam/*} gul/$-({* *} (unit (unit)))}
261 ?. &(?=(^ gat) ?=(^ +.gat))
263 (mock [[-.gat [sam +>.gat]] -.gat] gul)
269 > (mong [|=(@ 20) ~] ,~)
271 > (mong [|=(@ !!) ~] ,~)
273 > (mong [|=(a/@ (add 20 a)) ~] ,~)
275 > (mong [|=(a/[@ @] (add 20 -.a)) ~] ,~)
277 > (mong [|=(a/[@ @] (add 20 -.a)) [4 6]] ,~)
279 > (mong [|=(a/@ .^(a)) ~] ,~)
281 > (mong [|=(a/@ .^(a)) ~] ,[~ %42])
283 > (mong [|=(a/@ .^(a)) ~] |=(a/* [~ a 6]))
285 > (mong [|=(a/@ .^(a)) 8] |=(a/* [~ a 6]))
293Intelligently render crash annotation
295Converts a `%2` `++tone` nock stack trace to a list of `++tank`.
296Each may be a tank, cord, `++spot`, or trapped tank.
314 ?. ?=({$2 *} ton) ton
316 :: =. p.ton (moop p.ton)
319 ?. (gth yel 256) p.ton
323 :_ (slag (sub yel 128) p.ton)
326 "[skipped {(scow %ud (sub yel 256))} frames]"
329 =+ rep=$(p.ton t.p.ton)
331 $hunk [(tank +.i.p.ton) rep]
332 $lose [[%leaf (rip 3 (@ +.i.p.ton))] rep]
333 $hand [[%leaf (scow %p (mug +.i.p.ton))] rep]
335 ?@ +.i.p.ton [%leaf (rip 3 (@ +.i.p.ton))]
336 =+ mac=(mack +.i.p.ton +<.i.p.ton)
337 ?~(mac [%leaf "####"] (tank u.mac))
339 =+ sot=(spot +.i.p.ton)
342 => [ud=|=(a/@u (scow %ud a)) q.sot]
343 leaf+"<[{(ud p.p)} {(ud q.p)}].[{(ud p.q)} {(ud q.q)}]>"
350 > (mook [%0 5 4 5 1])
352 > (mook [%2 ~[[%hunk %rose ["<" "," ">"] ~[[%leaf "err"]]]]])
353 [%2 p=~[[%rose p=[p="<" q="," r=">"] q=[i=[%leaf p="err"] t=~]]]]
354 > (mook [%2 ~[[%malformed %elem] [%lose 'do print']]])
355 [%2 p=~[[%leaf p="do print"]]]
356 > (mook [%2 ~[[%mean |.(>(add 5 6)<)]]])
357 [%2 p=~[[%leaf p="11"]]]
358 > (mook [%2 ~[[%spot /b/repl [1 1]^[1 2]] [%mean |.(!!)]]])
359 [%2 p=~[[%leaf p="/b/repl/:<[1 1].[1 2]>"] [%leaf p="####"]]]
368Kicks a `++trap`, producing its results or any errors that occur along
369the way. Used to lazily compute stack traces.
374`taq` is a `++trap`, generally producing a list of `++tank`s.
384 ++ mule :: typed virtual
389 $& [%& p=$:taq] :: XX transition
398 > (mule |.(leaf/"hello"))
399 [%.y p=[%leaf "hello"]]
402 > (mule |.(.^(a//=pals/1)))
407 p=[p="/" q="/" r="/"]
410 t=[i=[%leaf p="~zod"] t=[i=[%leaf p="pals"] t=[i=[%leaf p="1"] t=~]]]
423Kicks a `++trap`, producing its result as a noun or the tanks of any
424error that occurs. Similar to `++mule`, but preserves no type
434Either a noun or a `++list` of `++tank`.
439 ++ mute :: untyped virtual
441 ^- (each * (list tank))
442 =+ ton=(mock [taq 9 2 0 1] |=({* *} ~))
445 $1 [%| (turn p.ton |=(a/* (smyt (path a))))]
453 > (mute |.(leaf/"hello"))
454 [%.y p=[1.717.658.988 104 101 108 108 111 0]]
keysesc to close
- j k
- move down, up
- enter
- open
- esc
- back, or up a level
- 1 2 3 4
- readme, files, commits, refs
- /
- filter
- y
- copy the clone command
- c
- compare the chosen commit with another (or shift-click both)
- ?
- show or hide this list