diff --git a/app/dojo.hoon b/app/dojo.hoon index 19874be8a..4c6fc5fdc 100644 --- a/app/dojo.hoon +++ b/app/dojo.hoon @@ -21,7 +21,7 @@ $: say/sole-share :: command-line state dir/beam :: active path poy/(unit dojo-project) :: working - {lib/(list hoof:ford) sur/(list hoof:ford)} :: lib+sur + {lib/(list hoof:ford) sur/(list hoof:ford)} :: lib+sur var/(map term cage) :: variable state old/(set term) :: used TLVs buf/tape :: multiline buffer @@ -41,7 +41,7 @@ r/purl:eyre == {$poke p/goal} :: poke app - {$show p/?($0 $1 $2 $3)} :: print val+span+twig + {$show p/?($0 $1 $2 $3)} :: print val+type+twig {$verb p/term} :: store variable {$help p/(list term)} :: look up help == :: @@ -536,7 +536,7 @@ ?- p.p.mad $0 ~ $1 [[%rose [~ " " ~] (skol p.q.cay) ~] (mar)] - $2 [[%rose [~ " " ~] (dy-show-span-noun p.q.cay) ~] (mar)] + $2 [[%rose [~ " " ~] (dy-show-type-noun p.q.cay) ~] (mar)] == == :: @@ -558,17 +558,17 @@ == :: ++ dy-inspect - |= {topic/(list term) sut/span} + |= {topic/(list term) sut/type} %+ dy-rash %tan |^ ^- tang - =+ to-display=(find-item-in-span (flop topic) sut) + =+ to-display=(find-item-in-type (flop topic) sut) ?~ to-display [%leaf "Could not find help"]~ (flop (print-item u.to-display)) :> # %models +| :: - :> an overview of all named things in the span. + :> an overview of all named things in the type. :> :> each item in the overview list is either a documentation for a sublist :> or an association between a term and documentation for it. @@ -582,15 +582,15 @@ {$item name/tape doc/what} == :: - :> the part of a {span} being inspected. + :> the part of a {type} being inspected. ++ item - $% :> overview of span + $% :> overview of type {$view items/overview} :> inspecting a full core. $: $core name/tape docs/what - sut/span + sut/type con/coil children/(unit item) == @@ -599,13 +599,13 @@ name/tape docs/what f/foot - sut/span + sut/type == :> inspecting a single chapter on a core. $: $chapter name/tape docs/what - sut/span + sut/type con/coil chapter-id/@ == @@ -623,11 +623,11 @@ +| :> returns the item to print while searching through {topic}. :> - :> this gate is called recursively to find the path {topic} in the span - :> {sut}. once it finds the correct part of the span, it switches to - :> ++build-inspectable-recursively to describe that part of the span. - ++ find-item-in-span - |= {topics/(list term) sut/span} + :> this gate is called recursively to find the path {topic} in the type + :> {sut}. once it finds the correct part of the type, it switches to + :> ++build-inspectable-recursively to describe that part of the type. + ++ find-item-in-type + |= {topics/(list term) sut/type} ^- (unit item) ?~ topics :: we have no more search path. return the rest as an overview @@ -682,31 +682,31 @@ ~ ?~ t.topics `[%face (trip q.p.sut) p.p.sut (build-inspectable-recursively q.sut)] - (find-item-in-span t.topics q.sut) + (find-item-in-type t.topics q.sut) :: {$fork *} - =/ spans/(list span) ~(tap in p.sut) + =/ types/(list type) ~(tap in p.sut) |- - ?~ spans + ?~ types ~ - =+ res=(find-item-in-span topics i.spans) + =+ res=(find-item-in-type topics i.types) ?~ res - $(spans t.spans) + $(types t.types) res :: {$help *} :: while we found a raw help, it's associated on the wrong side of a :: set of topics. Walk through it instead of showing it. - (find-item-in-span t.topics q.sut) + (find-item-in-type t.topics q.sut) :: {$hold *} $(sut (~(play ut p.sut) q.sut)) $noun ~ $void ~ == :: - :> changes a {span} into an {item}. + :> changes a {type} into an {item}. ++ build-inspectable-recursively - |= sut/span + |= sut/type ^- (unit item) ?- sut :: @@ -730,13 +730,13 @@ `[%face (trip q.p.sut) p.p.sut compiled-against] :: {$fork *} - =* spans ~(tap in p.sut) - =* items (turn spans build-inspectable-recursively) + =* types ~(tap in p.sut) + =* items (turn types build-inspectable-recursively) (roll items join-items) :: {$help *} - =* rest-span (build-inspectable-recursively q.sut) - `[%view [%header p.sut (item-as-overview rest-span)]~] + =* rest-type (build-inspectable-recursively q.sut) + `[%view [%header p.sut (item-as-overview rest-type)]~] :: {$hold *} $(sut (~(play ut p.sut) q.sut)) $noun ~ @@ -782,7 +782,7 @@ :: :> translate the internals of a core's {tomb} into an {overview}. ++ arms-as-overview - |= {a/(map term (pair what foot)) sut/span} + |= {a/(map term (pair what foot)) sut/type} ^- overview %+ turn ~(tap by a) |= (pair term (pair what foot)) @@ -807,7 +807,7 @@ :> returns an overview for arms which are part of unnamed chapters, :> and an overview of the named chapters. ++ arm-and-chapter-overviews - |= {sut/span con/coil core-name/tape} + |= {sut/type con/coil core-name/tape} ^- {overview overview} =| arm-docs/overview :< documented arms =| chapter-docs/overview :< documented chapters @@ -830,7 +830,7 @@ :: :> returns an overview of the arms in a specific chapter. ++ arms-in-chapter - |= {sut/span con/coil chapter-id/@} + |= {sut/type con/coil chapter-id/@} ^- overview =* chapter-tomb (~(got by q.s.con) chapter-id) (sort-overview (arms-as-overview q.chapter-tomb sut)) @@ -850,8 +850,8 @@ {$item *} name.ovr == :: - ++ what-from-span - |= sut/span + ++ what-from-type + |= sut/type ?+ sut ~ {$core *} q.r.q.sut {$help *} p.sut @@ -876,7 +876,7 @@ :: :> renders the documentation for a full core. ++ print-core - |= {core-name/tape docs/what sut/span con/coil uit/(unit item)} + |= {core-name/tape docs/what sut/type con/coil uit/(unit item)} ^- tang =+ [arms chapters]=(arm-and-chapter-overviews sut con core-name) ;: weld @@ -902,19 +902,19 @@ :> figures out which {what}s to use. :> :> there are three places with a relevant {what}: the {arm-doc} on the - :> arm, the {what} in the computed span of the foot, and the {what} on - :> the product of the default arm when the computed span is a core. + :> arm, the {what} in the computed type of the foot, and the {what} on + :> the product of the default arm when the computed type is a core. ++ select-arm-docs - |= {arm-doc/what f/foot sut/span} + |= {arm-doc/what f/foot sut/type} :> the computed arm documentation and the product documentation. ^- {what what} - =+ foot-span=(~(play ut sut) p.f) - =+ raw-product=(what-from-span foot-span) + =+ foot-type=(~(play ut sut) p.f) + =+ raw-product=(what-from-type foot-type) =/ product-product/what - ?. ?=({$core *} foot-span) + ?. ?=({$core *} foot-type) ~ - =* inner-span (~(play ut foot-span) [%limb %$]) - (what-from-span inner-span) + =* inner-type (~(play ut foot-type) [%limb %$]) + (what-from-type inner-type) :- ?~ arm-doc raw-product @@ -925,7 +925,7 @@ :: :> renders the documentation for a single arm in a core. ++ print-arm - |= {arm-name/tape arm-doc/what f/foot sut/span} + |= {arm-name/tape arm-doc/what f/foot sut/type} :: todo: need to get the sample here. also hoist this to the general :: core printing machinery, too. =+ [main-doc product-doc]=(select-arm-docs arm-doc f sut) @@ -939,7 +939,7 @@ :: :> renders the documentation for a chapter in a core. ++ print-chapter - |= {name/tape doc/what sut/span con/coil chapter-id/@} + |= {name/tape doc/what sut/type con/coil chapter-id/@} ;: weld (print-header name doc) :: @@ -1114,8 +1114,8 @@ $(ret l, c t.c) $(c t.c) :: - ++ dy-show-span-noun - |= a/span ^- tank + ++ dy-show-type-noun + |= a/type ^- tank =- >[-]< |- ^- $? $% {$atom @tas (unit @)} {$cell _$ _$} @@ -1130,7 +1130,7 @@ ?+ a a {?($cube $face) ^} a(q $(a q.a)) {$cell ^} a(p $(a p.a), q $(a q.a)) - {$fork *} a(p (silt (turn ~(tap in p.a) |=(b/span ^$(a b))))) + {$fork *} a(p (silt (turn ~(tap in p.a) |=(b/type ^$(a b))))) {$help *} !! {$core ^} `wain`/core {$hold *} a(p $(a p.a)) @@ -1180,7 +1180,7 @@ (dy-diff %mor [%det lic] [%bel ~] ~) (dy-slam(per `dat) /edit u.pro !>((tufa buf.say))) :: - ++ dy-span :: sole action + ++ dy-type :: sole action |= act/sole-action ?- -.act $det (dy-edit +.act) @@ -1574,11 +1574,11 @@ == == :: - ++ he-span :: apply input + ++ he-type :: apply input |= act/sole-action ^+ +> ?^ poy - he-pine:(~(dy-span dy u.poy) act) + he-pine:(~(dy-type dy u.poy) act) ?- -.act $det (he-stir +.act) $ret (he-done (tufa buf.say)) @@ -1704,7 +1704,7 @@ |= {moz/(list move) ses/session} => ~(. he moz ses) =- [wrap=- +] - |* he-arm/_he-span + |* he-arm/_he-type |= _+<.he-arm ^- (quip move _..he) he-abet:(he-arm +<) @@ -1721,7 +1721,7 @@ :: ++ poke-sole-action |= act/sole-action ~| poke+act %. act - (wrap he-span):arm + (wrap he-type):arm :: ++ poke-lens-command |= com/command:lens ~| poke-lens+com %. com diff --git a/sys/hoon.hoon b/sys/hoon.hoon index 7de44e03c..e1611d41b 100644 --- a/sys/hoon.hoon +++ b/sys/hoon.hoon @@ -25,6 +25,7 @@ :: ++ add :: unsigned addition ~/ %add + :> produce the sum of a and b |= [a=@ b=@] ^- @ ?: =(0 a) b @@ -1598,7 +1599,7 @@ ++ cork |*({a/_|=(* **) b/gate} (corl b a)) :: compose forward ++ corl :: compose backwards |* {a/gate b/_|=(* **)} - =< +:|.((a (b))) :: span check + =< +:|.((a (b))) :: type check |* c/_+<.b (a (b c)) :: @@ -5385,7 +5386,7 @@ :: :::: 4o: molds and mold builders :: -++ abel typo :: original sin: span +++ abel typo :: original sin: type ++ atom @ :: just an atom ++ aura @ta :: atom format ++ axis @ :: tree address @@ -5413,8 +5414,8 @@ {ven/term pro/term kel/@} :: vendor and product {ven/term pro/term ver/@ kel/@} :: all of the above == :: -++ coil $: p/?($gold $iron $lead $zinc) :: core span - q/span :: built with +++ coil $: p/?($gold $iron $lead $zinc) :: core type + q/type :: built with r/chap :: docs s/{p/?($~ ^) q/(map @ tomb)} :: arms == :: @@ -5429,22 +5430,22 @@ ++ metl ?($gold $iron $zinc $lead) :: core variance ++ noun * :: any noun ++ null $~ :: null, nil, etc -++ onyx (list (pair span foot)) :: arm activation +++ onyx (list (pair type foot)) :: arm activation ++ opal :: limb match - $% {$& p/span} :: leg - {$| p/axis q/(set {p/span q/foot})} :: arm + $% {$& p/type} :: leg + {$| p/axis q/(set {p/type q/foot})} :: arm == :: ++ pica (pair ? cord) :: & prose, | code ++ palo (pair vein opal) :: wing trace, match ++ pock (pair axis nock) :: changes -++ port (each palo (pair span nock)) :: successful match +++ port (each palo (pair type nock)) :: successful match ++ root twig :: produce model ++ tiki :: test case $% {$& p/(unit term) q/wing} :: simple wing {$| p/(unit term) q/twig} :: named wing == :: ++ tile $^ {p/tile q/tile} :: ordered pair - $% {$axil p/base} :: base span + $% {$axil p/base} :: base type {$bark p/toga q/tile} :: name {$deet p/spot q/tile} :: set debug {$fern p/{i/tile t/(list tile)}} :: plain selection @@ -5493,7 +5494,7 @@ {$bust p/base} :: bunt base {$dbug p/spot q/twig} :: debug info in trace {$eror p/tape} :: assembly error - {$hand p/span q/nock} :: premade result + {$hand p/type q/nock} :: premade result {$help p/what q/twig} :: annotate image {$halo p/what q/root} :: annotate model {$knit p/(list woof)} :: assemble string @@ -5550,7 +5551,7 @@ {$dttr p/twig q/twig} :: .* nock 2 {$dtts p/twig q/twig} :: .= nock 5 {$dtwt p/twig} :: .? nock 3 - :: :::::: span conversion + :: :::::: type conversion {$ktbr p/twig} :: ^| {$ktcn p/twig} :: ^% enter test mode {$ktdt p/twig q/twig} :: ^. @@ -5636,28 +5637,28 @@ {$10 p/$@(@ {p/@ q/nock}) q/nock} :: hint {$11 p/nock q/nock} :: grab data from sky == :: -++ span $@ $? $noun :: any nouns +++ type $@ $? $noun :: any nouns $void :: no noun == :: $% {$atom p/term q/(unit @)} :: atom / constant - {$cell p/span q/span} :: ordered pair - {$core p/span q/coil} :: object - {$face p/{p/what q/$@(term tune)} q/span} :: namespace (new) - {$fork p/(set span)} :: union - {$help p/what q/span} :: documentation - {$hold p/span q/twig} :: lazy evaluation + {$cell p/type q/type} :: ordered pair + {$core p/type q/coil} :: object + {$face p/{p/what q/$@(term tune)} q/type} :: namespace (new) + {$fork p/(set type)} :: union + {$help p/what q/type} :: documentation + {$hold p/type q/twig} :: lazy evaluation == :: ++ tone $% {$0 p/*} :: success {$1 p/(list)} :: blocks {$2 p/(list {@ta *})} :: error ~_s == :: -++ tool $@(term tune) :: span decoration +++ tool $@(term tune) :: type decoration ++ tune :: complex $: p/(map term (pair what (unit twig))) :: aliases q/(list twig) :: bridges == :: -++ typo span :: old span -++ vase {p/span q/*} :: span-value pair +++ typo type :: old type +++ vase {p/type q/*} :: type-value pair ++ vise {p/typo q/*} :: old vase ++ vial ?($read $rite $both $free) :: co/contra/in/bi ++ vair ?($gold $iron $lead $zinc) :: in/contra/bi/co @@ -5673,8 +5674,8 @@ ++ wing (list limb) :: search path ++ worm :: compiler cache $: nes/(set ^) :: ++nest - pay/(map (pair span twig) span) :: ++play - mit/(map (pair span twig) (pair span nock)) :: ++mint + pay/(map (pair type twig) type) :: ++play + mit/(map (pair type twig) (pair type nock)) :: ++mint == :: -- :: :: @@ -5699,40 +5700,40 @@ :: :::: 5a: compiler utilities :: -++ bool `span`(fork [%atom %f `0] [%atom %f `1] ~) :: make loobean -++ cell :: make %cell span +++ bool `type`(fork [%atom %f `0] [%atom %f `1] ~) :: make loobean +++ cell :: make %cell type ~/ %cell - |= {hed/span tal/span} - ^- span + |= {hed/type tal/type} + ^- type ?:(=(%void hed) %void ?:(=(%void tal) %void [%cell hed tal])) :: -++ core :: make %core span +++ core :: make %core type ~/ %core - |= {pac/span con/coil} - ^- span + |= {pac/type con/coil} + ^- type ?:(=(%void pac) %void [%core pac con]) :: ++ help ~/ %help - |= {p/what q/span} - ^- span + |= {p/what q/type} + ^- type ?: =(%void q) %void [%help p q] :: -++ face :: make %face span +++ face :: make %face type ~/ %face - |= {giz/{what $@(term tune)} der/span} - ^- span + |= {giz/{what $@(term tune)} der/type} + ^- type ?: =(%void der) %void [%face giz der] :: -++ fork :: make %fork span +++ fork :: make %fork type ~/ %fork - |= yed/(list span) - =| lez/(set span) - |- ^- span + |= yed/(list type) + =| lez/(set type) + |- ^- type ?~ yed ?~ lez %void ?: ?=({* $~ $~} lez) n.lez @@ -6066,7 +6067,6 @@ (hail [%rock p.sec q.sec]) :: {$plow *} - ?> =(*what wat) $(sec q.sec, wat p.sec) :: {$reed *} @@ -7141,15 +7141,15 @@ %toss toss %zpgr wrap == - =+ :* fan=*(set {span twig}) - rib=*(set {span span twig}) + =+ :* fan=*(set {type twig}) + rib=*(set {type type twig}) vet=`?`& fab=`?`& == - =+ sut=`span`%noun + =+ sut=`type`%noun |% ++ burn - =+ gil=*(set span) + =+ gil=*(set type) |- ^- (unit) ?- sut {$atom *} q.sut @@ -7177,18 +7177,18 @@ ++ busk ~/ %busk |= gen/twig - ^- span + ^- type [%face [~ ~ [gen ~]] sut] :: ++ buss ~/ %buss |= {{wat/what cog/term} gen/twig} - ^- span + ^- type [%face [wat [[cog ~ ~ gen] ~ ~] ~] sut] :: ++ conk |= got/toga - ^- span + ^- type ?@ got [%face [~ got] sut] ?- -.got $0 sut @@ -7201,12 +7201,12 @@ :: ++ crop ~/ %crop - |= ref/span - =+ bix=*(set {span span}) + |= ref/type + =+ bix=*(set {type type}) =< dext |% ++ dext - ^- span + ^- type ~_ leaf+"crop" :: ~_ (dunk 'dext: sut') :: ~_ (dunk(sut ref) 'dext: ref') @@ -7232,7 +7232,7 @@ :: {$core *} ?:(?=(?({$atom *} {$cell *}) ref) sut sint) {$face *} (face p.sut dext(sut q.sut)) - {$fork *} (fork (turn ~(tap in p.sut) |=(span dext(sut +<)))) + {$fork *} (fork (turn ~(tap in p.sut) |=(type dext(sut +<)))) {$help *} (help p.sut dext(sut q.sut)) {$hold *} ?< (~(has in bix) [sut ref]) dext(sut repo, bix (~(put in bix) [sut ref])) @@ -7241,12 +7241,12 @@ == :: ++ sint - ^- span + ^- type ?+ ref !! {$core *} sut {$face *} dext(ref repo(sut ref)) {$fork *} =+ yed=~(tap in p.ref) - |- ^- span + |- ^- type ?~ yed sut $(yed t.yed, sut dext(ref i.yed)) {$hold *} dext(ref repo(sut ref)) @@ -7254,14 +7254,14 @@ -- :: ++ cool - |= {pol/? hyp/wing ref/span} - ^- span + |= {pol/? hyp/wing ref/type} + ^- type =+ fid=(find %both hyp) ?- -.fid $| sut $& =< q %+ take p.p.fid - |=(a/span ?:(pol (fuse(sut a) ref) (crop(sut a) ref))) + |=(a/type ?:(pol (fuse(sut a) ref) (crop(sut a) ref))) == :: ++ duck ^-(tank ~(duck us sut)) @@ -7274,9 +7274,9 @@ :: ++ elbo |= {lop/palo rig/(list (pair wing twig))} - ^- span + ^- type ?: ?=($& -.q.lop) - |- ^- span + |- ^- type ?~ rig p.q.lop =+ zil=(play q.i.rig) @@ -7299,12 +7299,12 @@ :: ++ ergo |= {lop/palo rig/(list (pair wing twig))} - ^- (pair span nock) + ^- (pair type nock) =+ axe=(tend p.lop) =| hej/(list (pair axis nock)) ?: ?=($& -.q.lop) =- [p.- (hike axe q.-)] - |- ^- (pair span (list (pair axis nock))) + |- ^- (pair type (list (pair axis nock))) ?~ rig [p.q.lop hej] =+ zil=(mint %noun q.i.rig) @@ -7316,7 +7316,7 @@ == =+ hag=~(tap in q.q.lop) =- [(fire p.-) [%9 p.q.lop (hike axe q.-)]] - |- ^- (pair (list (pair span foot)) (list (pair axis nock))) + |- ^- (pair (list (pair type foot)) (list (pair axis nock))) ?~ rig [hag hej] =+ zil=(mint %noun q.i.rig) @@ -7328,11 +7328,11 @@ == :: ++ endo - |= {lop/(pair palo palo) dox/span rig/(list (pair wing twig))} - ^- (pair span span) + |= {lop/(pair palo palo) dox/type rig/(list (pair wing twig))} + ^- (pair type type) ?: ?=($& -.q.p.lop) ?> ?=($& -.q.q.lop) - |- ^- (pair span span) + |- ^- (pair type type) ?~ rig [p.q.p.lop p.q.q.lop] =+ zil=(mull %noun dox q.i.rig) @@ -7349,7 +7349,7 @@ ?> =(p.q.p.lop p.q.q.lop) =+ hag=[p=~(tap in q.q.p.lop) q=~(tap in q.q.q.lop)] =- [(fire p.-) (fire(vet |) q.-)] - |- ^- (pair (list (pair span foot)) (list (pair span foot))) + |- ^- (pair (list (pair type foot)) (list (pair type foot))) ?~ rig hag =+ zil=(mull %noun dox q.i.rig) @@ -7368,15 +7368,15 @@ |% ++ deft :: generic |% - ++ bath * :: leg match span - ++ claw * :: arm match span + ++ bath * :: leg match type + ++ claw * :: arm match type ++ form |*({* *} p=+<-) :: attach build state ++ skin |*(p/* p) :: reveal build state ++ meat |*(p/* p) :: remove build state -- ++ make :: for mint |% - ++ bath span :: leg match span + ++ bath type :: leg match type ++ claw onyx :: arm ++ form |*({* *} [p=+<- q=+<+]) :: ++ skin |*({p/* q/*} q) :: unwrap baggage @@ -7420,10 +7420,10 @@ ^- fleg (mint %noun a) ++ vant - |% ++ trep |= {a/span b/wing c/span} - ^- {axis span} + |% ++ trep |= {a/type b/wing c/type} + ^- {axis type} (tack(sut a) b c) - ++ tasp |= {a/(pair axis span) b/fleg c/foat} + ++ tasp |= {a/(pair axis type) b/fleg c/foat} ^- foat [q.a [[p.a (skin b)] (skin c)]] ++ tyle |=(foat +<) @@ -7490,7 +7490,7 @@ :: ++ etco |= {lop/palo rig/(list (pair wing twig))} - ^- (pair span nock) + ^- (pair type nock) =+ cin=(oc (bin:ad make:lib:ad)) =. rig (flop rig) :: XX this unbreaks, void order in devulc =+ axe=(tend p.lop) @@ -7504,22 +7504,22 @@ |_ {hyp/wing rig/(list (pair wing twig))} :: ++ play - ^- span + ^- type =+ lug=(find %read hyp) ?: ?=($| -.lug) ~>(%mean.[%leaf "twig"] ?>(?=($~ rig) p.p.lug)) (elbo p.lug rig) :: ++ mint - |= gol/span - ^- (pair span nock) + |= gol/type + ^- (pair type nock) =+ lug=(find %read hyp) ?: ?=($| -.lug) ~>(%mean.[%leaf "twig"] ?>(?=($~ rig) p.lug)) =- ?>(?|(!vet (nest(sut gol) & p.-)) -) (etco p.lug rig) :: ++ mull - |= {gol/span dox/span} - ^- {span span} + |= {gol/type dox/type} + ^- {type type} =+ lug=[p=(find %read hyp) q=(find(sut dox) %read hyp)] ?: ?=($| -.p.lug) ?> &(?=($| -.q.lug) ?=($~ rig)) @@ -7532,30 +7532,30 @@ ++ epla ~/ %epla |= {hyp/wing rig/(list (pair wing twig))} - ^- span + ^- type ~(play et hyp rig) :: ++ emin ~/ %emin - |= {gol/span hyp/wing rig/(list (pair wing twig))} - ^- (pair span nock) + |= {gol/type hyp/wing rig/(list (pair wing twig))} + ^- (pair type nock) (~(mint et hyp rig) gol) :: ++ emul ~/ %emul - |= {gol/span dox/span hyp/wing rig/(list (pair wing twig))} - ^- (pair span span) + |= {gol/type dox/type hyp/wing rig/(list (pair wing twig))} + ^- (pair type type) (~(mull et hyp rig) gol dox) :: ++ felt ~/ %felt |= lap/opal - ^- span + ^- type ?- -.lap $& p.lap $| %- fire %+ turn ~(tap in q.lap) - |= {a/span b/foot} + |= {a/type b/foot} [a [%ash %$ 1]] == :: @@ -7569,7 +7569,7 @@ (pair what palo) :: arm or leg %+ each :: abnormal @ud :: unmatched - (pair what (pair span nock)) :: synthetic + (pair what (pair type nock)) :: synthetic -- ^- pony ?~ hyp @@ -7593,7 +7593,7 @@ == ?: ?=($& -.heg) [%& ~ [`p.heg lon] %& (peek way p.heg)] - =| gil/(set span) + =| gil/(set type) =< $ |% ++ here ?: =(0 p.heg) [%& ~ [~ `axe lon] %& sut] @@ -7691,7 +7691,7 @@ ?~ fid ~ ?: ?=({$| $& *} fid) $(q.zot t.q.zot, p.heg p.p.fid) - =+ ^- {wat/what vat/(pair span nock)} + =+ ^- {wat/what vat/(pair type nock)} ?- -.fid $& [p.p.fid (fine %& q.p.fid)] $| [p.p.p.fid (fine %| q.p.p.fid)] @@ -7700,7 +7700,7 @@ -- :: {$fork *} - =+ wiz=(turn ~(tap in p.sut) |=(a/span ^$(sut a))) + =+ wiz=(turn ~(tap in p.sut) |=(a/type ^$(sut a))) ?~ wiz ~ |- ^- pony ?~ t.wiz i.wiz @@ -7740,27 +7740,27 @@ ++ fine ~/ %fine |= tor/port - ^- (pair span nock) + ^- (pair type nock) ?- -.tor $| p.tor $& =+ axe=(tend p.p.tor) ?- -.q.p.tor - $& [`span`p.q.p.tor %0 axe] + $& [`type`p.q.p.tor %0 axe] $| [(fire ~(tap in q.q.p.tor)) [%9 p.q.p.tor %0 axe]] == == :: ++ fire - |= hag/(list {p/span q/foot}) - ^- span + |= hag/(list {p/type q/foot}) + ^- type ?: ?=({{* {$elm $~ $1}} $~} hag) p.i.hag %- fork %+ turn hag.$ - |= {p/span q/foot} + |= {p/type q/foot} :- %hold ?. ?=({$core *} p) - ~_ (dunk %fire-span) + ~_ (dunk %fire-type) ~>(%mean.[%leaf "fire-core"] !!) =+ dox=[%core q.q.p q.p] ?: ?=($ash -.q) @@ -7780,7 +7780,7 @@ ++ fish ~/ %fish |= axe/axis - =+ vot=*(set span) + =+ vot=*(set type) |- ^- nock ?- sut $void [%1 1] @@ -7808,9 +7808,9 @@ :: ++ fuse ~/ %fuse - |= ref/span - =+ bix=*(set {span span}) - |- ^- span + |= ref/type + =+ bix=*(set {type type}) + |- ^- type ?: ?|(=(sut ref) =(%noun ref)) sut ?- sut @@ -7835,7 +7835,7 @@ :: {$core *} $(sut repo) {$face *} (face p.sut $(sut q.sut)) - {$fork *} (fork (turn ~(tap in p.sut) |=(span ^$(sut +<)))) + {$fork *} (fork (turn ~(tap in p.sut) |=(type ^$(sut +<)))) {$help *} (help p.sut $(sut q.sut)) {$hold *} ?: (~(has in bix) [sut ref]) @@ -7848,7 +7848,7 @@ :: ++ gain ~/ %gain - |= gen/twig ^- span + |= gen/twig ^- type (chip & gen) :: ++ harp @@ -7883,12 +7883,12 @@ :: ++ lose ~/ %lose - |= gen/twig ^- span + |= gen/twig ^- type (chip | gen) :: ++ chip ~/ %chip - |= {how/? gen/twig} ^- span + |= {how/? gen/twig} ^- type ?: ?=({$wtts *} gen) (cool how q.gen (play ~(bunt al [%herb p.gen]))) ?: ?&(how ?=({$wtpm *} gen)) @@ -7900,10 +7900,10 @@ :: ++ mint ~/ %mint - |= {gol/span gen/twig} - ^- {p/span q/nock} + |= {gol/type gen/twig} + ^- {p/type q/nock} ~& %pure-mint - |^ ^- {p/span q/nock} + |^ ^- {p/type q/nock} ?: ?&(=(%void sut) !?=({$dbug *} gen)) ?. |(!vet ?=({$lost *} gen) ?=({$zpzp *} gen)) ~>(%mean.[%leaf "mint-vain"] !!) @@ -8023,14 +8023,14 @@ {$zpsm *} =+ vos=$(gol %noun, gen q.gen) =+ ref=p:$(gol %noun, gen p.gen) - ?> (~(nest ut p:!>(*span)) & ref) + ?> (~(nest ut p:!>(*type)) & ref) [(nice (cell ref p.vos)) (cons [%1 p.vos] q.vos)] :: {$zpgr *} =+ vat=$(gen p.gen) %= $ gen - :- [%cnhp [%limb %onan] [%hand p:!>(*span) [%1 p.vat]] ~] + :- [%cnhp [%limb %onan] [%hand p:!>(*type) [%1 p.vat]] ~] [%hand p.vat q.vat] == :: @@ -8045,14 +8045,14 @@ == :: ++ nice - |= typ/span + |= typ/type ~_ leaf+"mint-nice" ?> ?|(!vet (nest(sut gol) & typ)) typ :: ++ grow |= {mel/vair ruf/twig wad/chap dom/(map @ tomb)} - ^- {p/span q/nock} + ^- {p/type q/nock} =+ dan=^$(gen ruf, gol %noun) =+ toc=(core p.dan [%gold p.dan wad [~ dom]]) =+ dez=(hope(sut toc) dom) @@ -8061,14 +8061,14 @@ -- :: ++ moot - =+ gil=*(set span) + =+ gil=*(set type) |- ^- ? ?- sut {$atom *} | {$cell *} |($(sut p.sut) $(sut q.sut)) {$core *} $(sut p.sut) {$face *} $(sut q.sut) - {$fork *} (lien ~(tap in p.sut) |=(span ^$(sut +<))) + {$fork *} (lien ~(tap in p.sut) |=(type ^$(sut +<))) {$help *} $(sut q.sut) {$hold *} |((~(has in gil) sut) $(gil (~(put in gil) sut), sut repo)) $noun | @@ -8077,8 +8077,8 @@ :: ++ mull ~/ %mull - |= {gol/span dox/span gen/twig} - |^ ^- {p/span q/span} + |= {gol/type dox/type gen/twig} + |^ ^- {p/type q/type} ?: =(%void sut) ~>(%mean.[%leaf "mull-none"] !!) ?- gen @@ -8142,7 +8142,7 @@ :: {$wtcl *} =+ nor=$(gen p.gen, gol bool) - =+ ^= hiq ^- {p/span q/span} + =+ ^= hiq ^- {p/type q/type} =+ fex=[p=(gain p.gen) q=(gain(sut dox) p.gen)] ?: =(%void p.fex) :- %void @@ -8152,7 +8152,7 @@ ?: =(%void q.fex) ~>(%mean.[%leaf "mull-bonk-b"] !!) $(sut p.fex, dox q.fex, gen q.gen) - =+ ^= ran ^- {p/span q/span} + =+ ^= ran ^- {p/type q/type} =+ wux=[p=(lose p.gen) q=(lose(sut dox) p.gen)] ?: =(%void p.wux) :- %void @@ -8201,11 +8201,11 @@ == :: ++ beth - |= typ/span + |= typ/type [(nice typ) typ] :: ++ nice - |= typ/span + |= typ/type :: ~_ (dunk(sut gol) 'need') :: ~_ (dunk(sut typ) 'have') ~_ leaf+"mull-nice" @@ -8215,7 +8215,7 @@ ++ grow |= {mel/vair ruf/twig wad/chap dom/(map @ tomb)} ~_ leaf+"mull-grow" - ^- {p/span q/span} + ^- {p/type q/type} =+ dan=^$(gen ruf, gol %noun) =+ ^= toc :- p=(core p.dan [%gold p.dan wad [~ dom]]) q=(core q.dan [%gold q.dan wad [~ dom]]) @@ -8253,17 +8253,17 @@ {* * *} [dov $(dom l.dom) $(dom r.dom)] == -- - ++ meet |=(ref/span &((nest | ref) (nest(sut ref) | sut))) + ++ meet |=(ref/type &((nest | ref) (nest(sut ref) | sut))) :: :: ++ miss :: nonintersection - |= $: :: ref: symmetric span + |= $: :: ref: symmetric type :: - ref/span + ref/type == :: intersection of sut and ref is empty :: ^- ? - =| gil/(set (set span)) + =| gil/(set (set type)) =< dext |% ++ dext @@ -8278,10 +8278,10 @@ {$cell *} sint {$core *} sint(sut [%cell %noun %noun]) {$fork *} %+ levy ~(tap in p.sut) - |=(span dext(sut +<)) + |=(type dext(sut +<)) {$face *} dext(sut q.sut) {$help *} dext(sut q.sut) - {$hold *} =+ (~(gas in *(set span)) `(list span)`[sut ref ~]) + {$hold *} =+ (~(gas in *(set type)) `(list type)`[sut ref ~]) ?: (~(has in gil) -) & %= dext @@ -8300,13 +8300,13 @@ dext(sut q.sut, ref q.ref) == == -- - ++ mite |=(ref/span |((nest | ref) (nest(sut ref) & sut))) + ++ mite |=(ref/type |((nest | ref) (nest(sut ref) & sut))) ++ nest ~/ %nest - |= {tel/? ref/span} - =| $: seg/(set span) :: degenerate sut - reg/(set span) :: degenerate ref - gil/(set {p/span q/span}) :: assume nest + |= {tel/? ref/type} + =| $: seg/(set type) :: degenerate sut + reg/(set type) :: degenerate ref + gil/(set {p/type q/type}) :: assume nest == =< dext |% @@ -8379,7 +8379,7 @@ == {$face *} dext(sut q.sut) {$fork *} ?. ?=(?({$atom *} $noun {$cell *} {$core *}) ref) sint - (lien ~(tap in p.sut) |=(span dext(tel |, sut +<))) + (lien ~(tap in p.sut) |=(type dext(tel |, sut +<))) {$help *} dext(sut q.sut) {$hold *} ?: (~(has in seg) sut) | ?: (~(has in gil) [sut ref]) & @@ -8399,7 +8399,7 @@ {$cell *} | {$core *} dext(ref repo(sut ref)) {$face *} dext(ref q.ref) - {$fork *} (levy ~(tap in p.ref) |=(span sint(ref +<))) + {$fork *} (levy ~(tap in p.ref) |=(type sint(ref +<))) {$help *} dext(ref q.ref) {$hold *} ?: (~(has in reg) ref) & ?: (~(has in gil) [sut ref]) & @@ -8413,12 +8413,12 @@ ++ peek ~/ %peek |= {way/?($read $rite $both $free) axe/axis} - ^- span + ^- type ?: =(1 axe) sut =+ [now=(cap axe) lat=(mas axe)] - =+ gil=*(set span) - |- ^- span + =+ gil=*(set type) + |- ^- type ?- sut {$atom *} %void {$cell *} ?:(=(2 now) ^$(sut p.sut, axe lat) ^$(sut q.sut, axe lat)) @@ -8434,7 +8434,7 @@ ?.(con.pec %noun ^$(sut p.sut, axe 3)) == :: - {$fork *} (fork (turn ~(tap in p.sut) |=(span ^$(sut +<)))) + {$fork *} (fork (turn ~(tap in p.sut) |=(type ^$(sut +<)))) {$hold *} ?: (~(has in gil) sut) %void @@ -8460,7 +8460,7 @@ ~/ %play => .(vet |) |= gen/twig - ^- span + ^- type ?- gen {^ *} (cell $(gen p.gen) $(gen q.gen)) {$ktcn *} $(fab |, gen p.gen) @@ -8468,10 +8468,10 @@ {$cnts *} ~(play et p.gen q.gen) {$dtkt *} $(gen [%bunt p.gen]) {$dtls *} [%atom %$ ~] - {$rock *} |- ^- span + {$rock *} |- ^- type ?@ q.gen [%atom p.gen `q.gen] [%cell $(q.gen -.q.gen) $(q.gen +.q.gen)] - {$sand *} |- ^- span + {$sand *} |- ^- type ?@ q.gen ?: =(%n p.gen) ?>(=(0 q.gen) [%atom p.gen ~ q.gen]) ?:(=(%f p.gen) ?>((lte q.gen 1) bool) [%atom p.gen ~]) @@ -8502,7 +8502,7 @@ {$zpcm *} (play p.gen) {$zpgr *} %= $ gen - [%cnhp [%limb %onan] [%hand p:!>(*span) [%1 $(gen p.gen)]] ~] + [%cnhp [%limb %onan] [%hand p:!>(*type) [%1 $(gen p.gen)]] ~] == {$lost *} %void {$zpsm *} (cell $(gen p.gen) $(gen q.gen)) @@ -8518,18 +8518,18 @@ ++ redo :: refurbish faces |= $: :: ref: raw payload :: - ref/span + ref/type == - :: :span: subject refurbished to reference namespace + :: :type: subject refurbished to reference namespace :: - ^- span + ^- type :: hos: subject tool stack :: wec: reference tool stack set :: gil: repetition set :: =| hos/(list tool) =/ wec/(set (list tool)) [~ ~ ~] - =| gil/(set (pair span span)) + =| gil/(set (pair type type)) =< :: errors imply subject/reference mismatch :: ~| %redo-match @@ -8589,9 +8589,9 @@ (weld hos (slag lip har)) :: :: ++ dext :: subject traverse - :: :span: refurbished subject + :: :type: refurbished subject :: - ^- span + ^- type :: check for trivial cases :: ?: ?| =(sut ref) @@ -8640,7 +8640,7 @@ {$fork *} :: reconstruct each case in fork :: - (fork (turn ~(tap in p.sut) |=(span dext(sut +<)))) + (fork (turn ~(tap in p.sut) |=(type dext(sut +<)))) :: {$hold *} :: reduce to hard @@ -8663,8 +8663,8 @@ == :: :: ++ done :: complete assembly - ^- span - :: :span: subject refurbished + ^- type + :: :type: subject refurbished :: :: lov: combined face stack :: @@ -8678,7 +8678,7 @@ (need lov) :: recompose faces :: - |- ^- span + |- ^- type ?~ lov sut $(lov t.lov, sut (face [~ i.lov] sut)) :: :: @@ -8712,7 +8712,7 @@ :: ~> %slog.[0 (dunk(sut (fork ->)) 'fork: pro')] +(wec -<, ref (fork ->)) =/ moy ~(tap in p.ref) - |- ^- (pair (set (list tool)) (list span)) + |- ^- (pair (set (list tool)) (list type)) ?~ moy [~ ~] :: head recurse :: @@ -8732,7 +8732,7 @@ -- :: ++ repo - ^- span + ^- type ?- sut {$core *} [%cell %noun p.sut] {$face *} q.sut @@ -8744,33 +8744,33 @@ :: ++ rest ~/ %rest - |= leg/(list {p/span q/twig}) - ^- span - ?: (lien leg |=({p/span q/twig} (~(has in fan) [p q]))) + |= leg/(list {p/type q/twig}) + ^- type + ?: (lien leg |=({p/type q/twig} (~(has in fan) [p q]))) ~>(%mean.[%leaf "rest-loop"] !!) => .(fan (~(gas in fan) leg)) %- fork %~ tap in - %- ~(gas in *(set span)) - (turn leg |=({p/span q/twig} (play(sut p) q))) + %- ~(gas in *(set type)) + (turn leg |=({p/type q/twig} (play(sut p) q))) == :: ++ take - |= {vit/vein duz/$-(span span)} - ^- (pair axis span) + |= {vit/vein duz/$-(type type)} + ^- (pair axis type) :- (tend vit) =. vit (flop vit) - |- ^- span + |- ^- type ?~ vit (duz sut) ?~ i.vit - |- ^- span + |- ^- type ?+ sut ^$(vit t.vit) {$face *} (face p.sut ^$(vit t.vit, sut q.sut)) - {$fork *} (fork (turn ~(tap in p.sut) |=(span ^$(sut +<)))) + {$fork *} (fork (turn ~(tap in p.sut) |=(type ^$(sut +<)))) {$hold *} $(sut repo) == - =+ vil=*(set span) - |- ^- span + =+ vil=*(set type) + |- ^- type ?: =(1 u.i.vit) ^$(vit t.vit) =+ [now lat]=(cap u.i.vit)^(mas u.i.vit) @@ -8785,7 +8785,7 @@ $(sut repo) (core $(sut p.sut, u.i.vit lat) q.sut) {$face *} (face p.sut $(sut q.sut)) - {$fork *} (fork (turn ~(tap in p.sut) |=(span ^$(sut +<)))) + {$fork *} (fork (turn ~(tap in p.sut) |=(type ^$(sut +<)))) {$help *} (help p.sut $(sut q.sut)) {$hold *} ?: (~(has in vil) sut) %void @@ -8793,11 +8793,11 @@ == :: ++ tack - |= {hyp/wing mur/span} + |= {hyp/wing mur/type} ~_ (show [%c %tack] %l hyp) =+ fid=(find %rite hyp) ?> ?=($& -.fid) - (take p.p.fid |=(span mur)) + (take p.p.fid |=(type mur)) :: ++ tend |= vit/vein @@ -8806,11 +8806,11 @@ :: ++ toss ~/ %toss - |= {hyp/wing mur/span men/(list {p/span q/foot})} - ^- {p/axis q/(list {p/span q/foot})} + |= {hyp/wing mur/type men/(list {p/type q/foot})} + ^- {p/axis q/(list {p/type q/foot})} =- [(need p.wib) q.wib] ^= wib - |- ^- {p/(unit axis) q/(list {p/span q/foot})} + |- ^- {p/(unit axis) q/(list {p/type q/foot})} ?~ men [*(unit axis) ~] =+ geq=(tack(sut p.i.men) hyp mur) @@ -8821,12 +8821,12 @@ ~/ %zpgr |= yoz/?($lead $iron $zinc) ~_ leaf+"wrap" - ^- span + ^- type ?+ sut sut {$cell *} (cell $(sut p.sut) $(sut q.sut)) {$core *} ?>(|(=(%gold p.q.sut) =(%lead yoz)) sut(p.q yoz)) {$face *} (face p.sut $(sut q.sut)) - {$fork *} (fork (turn ~(tap in p.sut) |=(span ^$(sut +<)))) + {$fork *} (fork (turn ~(tap in p.sut) |=(type ^$(sut +<)))) {$help *} (help p.sut $(sut q.sut)) {$hold *} $(sut repo) == @@ -8837,7 +8837,7 @@ ++ wine :: $@ $? $noun :: $path :: - $span :: + $type :: $void :: $wall :: $wool :: @@ -8855,7 +8855,7 @@ {$unit p/term q/wine} :: == :: -- - |_ sut/span + |_ sut/type ++ dash |= {mil/tape lim/char} ^- tape :- lim @@ -8885,7 +8885,7 @@ ?- q.ham $noun :_(gid [%leaf '*' ~]) $path :_(gid [%leaf '/' ~]) - $span :_(gid [%leaf '#' 't' ~]) + $type :_(gid [%leaf '#' 't' ~]) $void :_(gid [%leaf '#' '!' ~]) $wool :_(gid [%leaf '*' '"' '"' ~]) $wall :_(gid [%leaf '*' '\'' '\'' ~]) @@ -8969,7 +8969,7 @@ ?> ?=(@ -.lum) [[%leaf (rip 3 -.lum)] $(lum +.lum)] :: - $span + $type =+ tyr=|.((dial dole)) =+ vol=tyr(sut lum) =+ cis=((hard tank) .*(vol -:vol)) @@ -9183,15 +9183,15 @@ :: ++ dole ^- cape - =+ gil=*(set span) - =+ dex=[p=*(map span @) q=*(map @ wine)] + =+ gil=*(set type) + =+ dex=[p=*(map type @) q=*(map @ wine)] =< [q.p q] - |- ^- {p/{p/(map span @) q/(map @ wine)} q/wine} + |- ^- {p/{p/(map type @) q/(map @ wine)} q/wine} =- [p.tez (doge q.p.tez q.tez)] ^= tez - ^- {p/{p/(map span @) q/(map @ wine)} q/wine} - ?: (~(meet ut sut) -:!>(*span)) - [dex %span] + ^- {p/{p/(map type @) q/(map @ wine)} q/wine} + ?: (~(meet ut sut) -:!>(*type)) + [dex %type] ?- sut $noun [dex sut] $void [dex sut] @@ -9238,7 +9238,7 @@ {$fork *} =+ yed=~(tap in p.sut) =- [p [%bcwt q]] - |- ^- {p/{p/(map span @) q/(map @ wine)} q/(list wine)} + |- ^- {p/{p/(map type @) q/(map @ wine)} q/(list wine)} ?~ yed [dex ~] =+ mor=$(yed t.yed) @@ -9268,20 +9268,20 @@ |= vax/vase ^- tape ~(ram re (sell vax)) :: -++ seem |=(toy/typo `span`toy) :: promote typo +++ seem |=(toy/typo `type`toy) :: promote typo ++ seer |=(vix/vise `vase`vix) :: promote vise ++ sell :: tank pretty-print |= vax/vase ^- tank ~| %sell (~(deal us p.vax) q.vax) :: -++ skol :: $-(span tank) for ~! - |= typ/span ^- tank +++ skol :: $-(type tank) for ~! + |= typ/type ^- tank ~(duck ut typ) :: ++ slam :: slam a gate |= {gat/vase sam/vase} ^- vase - =+ :- ^= typ ^- span + =+ :- ^= typ ^- type [%cell p.gat p.sam] ^= gen ^- twig [%cnsg [%$ ~] [%$ 2] [%$ 3] ~] @@ -9289,7 +9289,7 @@ [p.gun .*([q.gat q.sam] q.gun)] :: ++ slab :: test if contains - |= {cog/@tas typ/span} + |= {cog/@tas typ/type} =(& -:(~(find ut typ) %free [cog ~])) :: ++ slap @@ -9310,13 +9310,13 @@ |= old/vise ^- vase old :: -++ slit :: span of slam - |= {gat/span sam/span} +++ slit :: type of slam + |= {gat/type sam/type} ?> (~(nest ut (~(peek ut gat) %free 6)) & sam) (~(play ut [%cell gat sam]) [%cnsg [%$ ~] [%$ 2] [%$ 3] ~]) :: ++ slob :: superficial arm - |= {cog/@tas typ/span} + |= {cog/@tas typ/type} ^- ? ?+ typ | {$hold *} $(typ ~(repo ut typ)) @@ -9330,7 +9330,7 @@ == :: ++ sloe :: get arms in core - |= typ/span + |= typ/type ^- (list term) ?+ typ ~ {$hold *} $(typ ~(repo ut typ)) @@ -9352,11 +9352,11 @@ |= {axe/@ vax/vase} ^- vase [(~(peek ut p.vax) %free axe) .*(q.vax [0 axe])] :: -++ slym :: slam w+o sample-span +++ slym :: slam w+o sample-type |= {gat/vase sam/*} ^- vase (slap gat(+<.q sam) [%limb %$]) :: -++ spec :: reconstruct span +++ spec :: reconstruct type |= vax/vase ^- vase :_ q.vax @@ -9395,6 +9395,7 @@ ++ hasp ;~ pose (ifix [sel ser] wide) (stag %cnhp (ifix [pel per] (most ace wide))) + (stag %sand (stag %tas (cold %$ buc))) (stag %sand (stag %t qut)) %+ cook |=(a/coin [%sand ?:(?=({$~ $tas *} a) %tas %ta) ~(rent co a)]) @@ -10323,7 +10324,7 @@ |= {naz/hair los/tape} ^+ *sab :: - :: vex: fenced span + :: vex: fenced type =/ vex/(like tape) (fex naz los) ?~ q.vex vex :: @@ -10333,7 +10334,7 @@ :: reparsed error position is always at start ?~ q.hav [naz ~] :: - :: the complete span with the main product + :: the complete type with the main product :- p.vex `[p.u.q.hav q.u.q.vex] :: @@ -11423,17 +11424,17 @@ (rain bon .^(@t %cx (weld bon `path`[%hoon ~]))) :: ++ ride :: end-to-end compiler - |= {typ/span txt/@} - ^- (pair span nock) + |= {typ/type txt/@} + ^- (pair type nock) (~(mint ut typ) %noun (ream txt)) :: :::: 5e: caching compiler :: ++ wa !: :: cached compile |_ worm - ++ nell |=(ref/span (nest [%cell %noun %noun] ref)) :: nest in cell + ++ nell |=(ref/type (nest [%cell %noun %noun] ref)) :: nest in cell ++ nest :: nest:ut - |= {sut/span ref/span} + |= {sut/type ref/type} ^- {? worm} ?: (~(has in nes) [sut ref]) [& +>+<] ?. (~(nest ut sut) | ref) @@ -11468,7 +11469,7 @@ [[p.dor q.dor(+6 +7.som)] +>+<.$] :: ++ neat :: type compliance - |= {typ/span som/(each vase ^)} + |= {typ/type som/(each vase ^)} ^- worm =^ hip +>+<.$ ?- -.som @@ -11478,11 +11479,11 @@ ?> hip +>+<.$ :: - ++ nets :: spanless nest + ++ nets :: typeless nest |= {sut/* ref/*} ^- {? worm} ?: (~(has in nes) [sut ref]) [& +>+<] - =+ gat=|=({a/span b/span} (~(nest ut a) | b)) + =+ gat=|=({a/type b/type} (~(nest ut a) | b)) ?. (? .*(gat(+< [sut ref]) -.gat)) ~& %nets-failed =+ tag=`*`skol @@ -11496,16 +11497,16 @@ [& +>+<.$(nes (~(put in nes) [sut ref]))] :: ++ play :: play:ut - |= {sut/span gen/twig} - ^- {span worm} + |= {sut/type gen/twig} + ^- {type worm} =+ old=(~(get by pay) [sut gen]) ?^ old [u.old +>+<.$] =+ new=(~(play ut sut) gen) [new +>+<.$(pay (~(put by pay) [sut gen] new))] :: ++ mint :: mint:ut to noun - |= {sut/span gen/twig} - ^- {(pair span nock) worm} + |= {sut/type gen/twig} + ^- {(pair type nock) worm} =+ old=(~(get by mit) [sut gen]) ?^ old [u.old +>+<.$] =+ new=(~(mint ut sut) %noun gen) @@ -11567,10 +11568,10 @@ $: p/(unit (set monk)) :: can be read by q/(set monk) :: caused or created by == :: -++ curd {p/@tas q/*} :: spanless card +++ curd {p/@tas q/*} :: typeless card ++ dock (pair @p term) :: message target ++ duct (list wire) :: causal history -++ hypo |*(a/$-(* *) (pair span a)) :: span associated +++ hypo |*(a/$-(* *) (pair type a)) :: type associated ++ hobo |* a/$-(* *) :: task wrapper $? $% {$soft p/*} :: == :: @@ -11600,7 +11601,7 @@ $@ mark :: plain mark $% {$tabl p/(list (pair marc marc))} :: map == :: -++ mark @tas :: content span +++ mark @tas :: content type ++ marl (list manx) :: XML node list ++ mars {t/{n/$$ a/{i/{n/$$ v/tape} t/$~}} c/$~} :: XML cdata ++ mart (list {n/mane v/tape}) :: XML attributes @@ -11615,7 +11616,7 @@ ++ muse {p/@tas q/duct r/arvo} :: sourced move ++ move {p/duct q/arvo} :: arvo move ++ octs {p/@ud q/@t} :: octet-stream -++ ovum {p/wire q/curd} :: spanless ovum +++ ovum {p/wire q/curd} :: typeless ovum ++ pane (list {p/@tas q/vase}) :: kernel modules ++ pass @ :: public key ++ pone (list {p/@tas q/vise}) :: kernel modules old @@ -11638,10 +11639,10 @@ ++ spur path :: ship desk case spur ++ time @da :: galactic time ++ vile :: reflexive constants - $: typ/span :: -:!>(*span) - duc/span :: -:!>(*duct) - pah/span :: -:!>(*path) - mev/span :: -:!>([%meta *vase]) + $: typ/type :: -:!>(*type) + duc/type :: -:!>(*duct) + pah/type :: -:!>(*path) + mev/type :: -:!>([%meta *vase]) == :: ++ wind :: new kernel action |* {a/$-(* *) b/$-(* *)} :: forward+reverse diff --git a/sys/ovra.hoon b/sys/ovra.hoon index 5afecf23c..2e4ba02e2 100644 --- a/sys/ovra.hoon +++ b/sys/ovra.hoon @@ -26,9 +26,9 @@ $: p/(unit (set monk)) :: can be read by q/(set monk) :: caused or created by == :: -++ curd {p/@tas q/*} :: spanless card +++ curd {p/@tas q/*} :: typeless card ++ duct (list wire) :: causal history -++ hypo |*(a/mold (pair span a)) :: span associated +++ hypo |*(a/mold (pair type a)) :: type associated ++ hobo |* a/mold :: kiss wrapper $? $% {$soft p/*} :: == :: @@ -48,7 +48,7 @@ $@ mark :: plain mark $% {$tabl p/(list (pair marc marc))} :: map == :: -++ mark @tas :: content span +++ mark @tas :: content type ++ mash |=(* (mass +<)) :: producing mass ++ mass (pair cord (each noun (list mash))) :: memory usage ++ mill (each vase milt) :: vase+metavase @@ -56,7 +56,7 @@ ++ monk (each ship {p/@tas q/@ta}) :: general identity ++ muse {p/@tas q/duct r/arvo} :: sourced move ++ move {p/duct q/arvo} :: arvo move -++ ovum {p/wire q/curd} :: spanless ovum +++ ovum {p/wire q/curd} :: typeless ovum ++ pane (list {p/@tas q/vase}) :: kernel modules ++ pone (list {p/@tas q/vise}) :: kernel modules old ++ ship @p :: network identity @@ -67,10 +67,10 @@ (unit (unit (cask))) :: ++ slyt $-({* *} (unit (unit))) :: old namespace ++ vile :: reflexive constants - $: typ/span :: -:!>(*span) - duc/span :: -:!>(*duct) - pah/span :: -:!>(*path) - mev/span :: -:!>([%meta *vase]) + $: typ/type :: -:!>(*type) + duc/type :: -:!>(*duct) + pah/type :: -:!>(*path) + mev/type :: -:!>([%meta *vase]) == :: ++ wind :: new kernel action |* {a/mold b/mold} :: forward+reverse @@ -192,9 +192,9 @@ ?. hip ~ :: a vase is a cell =^ vax p.sew (~(slot wa p.sew) 2 tiv) :: =^ hip p.sew (~(nest wa p.sew) typ.vil p.vax) :: - ?. hip ~ :: vase head is span + ?. hip ~ :: vase head is type %+ biff :: - =+ mut=(milt q.tiv) :: card span, value + =+ mut=(milt q.tiv) :: card type, value |- ^- (unit (pair milt worm)) :: ?. ?=({$meta p/* q/milt} q.mut) `[mut p.sew] :: ordinary metacard =^ hip p.sew (~(nets wa p.sew) mev.vil p.mut):: @@ -328,10 +328,10 @@ (vent lal vil bud *worm (slym (slap bud (rain pax txt)) bud)) :: ++ viol :: vane tools - |= but/span + |= but/type ^- vile - =+ pal=|=(a/@t ^-(span (~(play ut but) (vice a)))) - :* typ=(pal '*span') + =+ pal=|=(a/@t ^-(type (~(play ut but) (vice a)))) + :* typ=(pal '*type') duc=(pal '*duct') pah=(pal '*path') mev=(pal '*{$meta $vase}') diff --git a/sys/vane/ford.hoon b/sys/vane/ford.hoon index 8c2447847..1567f72a0 100644 --- a/sys/vane/ford.hoon +++ b/sys/vane/ford.hoon @@ -71,8 +71,8 @@ {$bake p/calm q/(pair mark beam) r/(unit vase)} :: load {$boil p/calm q/(trel coin beam beam) r/vase} :: execute {$path p/calm q/beam r/(unit beam)} :: -to/ transformation - {$slit p/calm q/{p/span q/span} r/span} :: slam type - {$slim p/calm q/{p/span q/twig} r/(pair span nock)}:: mint + {$slit p/calm q/{p/type q/type} r/type} :: slam type + {$slim p/calm q/{p/type q/twig} r/(pair type nock)}:: mint {$slap p/calm q/{p/vase q/twig} r/vase} :: compute {$slam p/calm q/{p/vase q/vase} r/vase} :: compute == :: @@ -92,7 +92,7 @@ -- :: |% :: ++ calf :: reduce calx - |* sem/* :: a spansystem hack + |* sem/* :: a typesystem hack |= cax/calx ?+ sem !! $hood ?>(?=($hood -.cax) r.cax) @@ -953,7 +953,7 @@ =< |. ^- tank :+ %palm [" " ~ ~ ~] ~[leaf+"ford: keel" rose+[" " ~ ~]^(murn yom +)] - |= {a/wing b/span *} ^- (unit tank) + |= {a/wing b/type *} ^- (unit tank) =+ typ=(mule |.(p:(slap suh wing+a))) ?: ?=($| -.typ) (some (show [%c %pull] %l a)) @@ -1035,10 +1035,10 @@ ?~ von [p=cof q=[%1 [%c %w bem ~] ~ ~]] (fine cof bem(r [%ud ((hard @) +.+:(need u.von))])) :: - ++ lane :: span infer - |= {cof/cafe typ/span gen/twig} + ++ lane :: type infer + |= {cof/cafe typ/type gen/twig} %+ (cowl cof) (mule |.((~(play ut typ) gen))) - |=(ref/span ref) + |=(ref/type ref) :: ++ lash :: filter at beam |* {cof/cafe bem/beam fun/(burg knot (unit))} @@ -1211,10 +1211,10 @@ :: ++ mail :: cached mint ~/ %mail - |= {cof/cafe sut/span gen/twig} - ^- (bolt (pair span nock)) + |= {cof/cafe sut/type gen/twig} + ^- (bolt (pair type nock)) %+ (clef %slim) (fine cof sut gen) - |= {cof/cafe sut/span gen/twig} + |= {cof/cafe sut/type gen/twig} =+ puz=(mule |.((~(mint ut sut) [%noun gen]))) ?- -.puz $| (flaw cof p.puz) @@ -1226,7 +1226,7 @@ |= {cof/cafe vax/vase gen/twig} ^- (bolt vase) %+ cope (mail cof p.vax gen) - |= {cof/cafe typ/span fol/nock} + |= {cof/cafe typ/type fol/nock} %+ (coup cof) (mock [q.vax fol] (sloy syve)) |=(val/* `vase`[typ val]) :: @@ -1416,10 +1416,10 @@ :: ++ malt :: cached slit ~/ %slit - |= {cof/cafe gat/span sam/span} - ^- (bolt span) + |= {cof/cafe gat/type sam/type} + ^- (bolt type) %+ (clef %slit) (fine cof gat sam) - |= {cof/cafe gat/span sam/span} + |= {cof/cafe gat/type sam/type} %+ cool |.(%.(%have ~(dunk ut sam))) %+ cool |.(%.(%want ~(dunk ut (~(peek ut gat) %free 6)))) =+ top=(mule |.((slit gat sam))) @@ -1433,7 +1433,7 @@ |= {cof/cafe gat/vase sam/vase} ^- (bolt vase) %+ cope (malt cof p.gat p.sam) - |= {cof/cafe typ/span} + |= {cof/cafe typ/type} %+ (coup cof) (mong [q.gat q.sam] (sloy syve)) |=(val/* `vase`[typ val]) :: @@ -1867,9 +1867,9 @@ %- %- lift |= (unit cage) :: ignore block %+ biff +< |= cay/cage ^- (unit cage) - ?. -:(nets:wa +.ref `span`p.q.cay) :: error if bad type + ?. -:(nets:wa +.ref `type`p.q.cay) :: error if bad type ~& :^ %ford-syve-lost `path`[tem (en-beam bem)] - want=;;(span +.ref) + want=;;(type +.ref) have=p.q.cay ~ `cay diff --git a/sys/zuse.hoon b/sys/zuse.hoon index 5731fcdc1..00c972d47 100644 --- a/sys/zuse.hoon +++ b/sys/zuse.hoon @@ -39,7 +39,7 @@ ++ roof (room vase) :: namespace ++ room :: either namespace |* vase/mold :: vase or maze - $- $: ref/* :: reference span + $- $: ref/* :: reference type lyc/(unit (set ship)) :: leakset car/term :: perspective bem/beam :: path