From 7df058dd6fc1878d435823fa20487aeec992780f Mon Sep 17 00:00:00 2001 From: "C. Guy Yarvin" Date: Tue, 24 Oct 2017 19:04:45 -0700 Subject: [PATCH] Reset %zuse pre 143. --- sys/zuse.hoon | 2693 ++++++++++++++++++++++++------------------------- 1 file changed, 1346 insertions(+), 1347 deletions(-) diff --git a/sys/zuse.hoon b/sys/zuse.hoon index b6c4d9042..74e1a7b2e 100644 --- a/sys/zuse.hoon +++ b/sys/zuse.hoon @@ -1,5 +1,5 @@ -:: :: =van=zuse -:: :: %reference=1 +:: :: /van/zuse +:: :: %reference/1 :: %zuse: arvo library. :: :: %zuse is two nested cores: the first for models @@ -31,30 +31,29 @@ :: that vane. :: ~% %zuse +> ~ -!: => :: :: :: :::: :: :: (1) models :: :: :: |% -+= roof (room vase) :: namespace +++ roof (room vase) :: namespace ++ room :: either namespace - |* vase=mold :: vase or maze - $- $: ref=* :: reference span - lyc=(unit (set ship)) :: leakset - car=term :: perspective - bem=beam :: path + |* vase/mold :: vase or maze + $- $: ref/* :: reference span + lyc/(unit (set ship)) :: leakset + car/term :: perspective + bem/beam :: path == :: %- unit :: ~: unknown %- unit :: ~ ~: invalid (cask vase) :: marked cargo ++ vane :: kernel module - |* $: task=mold :: ->$ in request - gift=mold :: <-$ out result - sign=mold :: $<- in result - note=mold :: $-> out request - mind=mold :: current state - seed=mold :: prior state + |* $: task/mold :: ->$ in request + gift/mold :: <-$ out result + sign/mold :: $<- in result + note/mold :: $-> out request + mind/mold :: current state + seed/mold :: prior state == :: =* self (vane task gift sign note mind seed) :: $_ =| mind @@ -62,29 +61,29 @@ ++ load |~(seed ^|(+>)) ++ stay *mind :: preserve ++ plow :: work in time - =| $: now=@da :: date - eny=@e :: entropy - sky=roof :: namespace + =| $: now/@da :: date + eny/@e :: entropy + sky/roof :: namespace == :: ^| |% ++ doze *(unit @da) :: awake when ++ peek - |~ $: lyc=(unit (set ship)) :: leakset - car=term :: perspective - bem=beam :: global path + |~ $: lyc/(unit (set ship)) :: leakset + car/term :: perspective + bem/beam :: global path == *(unit (unit (cask vase))) :: ++ spin :: work on state - =| $: hen=duct :: cause stack - moz=(list (pair duct (wind note gift))) :: actions, reversed + =| $: hen/duct :: cause stack + moz/(list (pair duct (wind note gift))) :: actions, reversed == ^| |% ++ call :: advancing effect |~(task ^|(+>)) :: ++ take :: returning effect - |~([wire sign] ^|(+>)) + |~({wire sign} ^|(+>)) -- :: -- -- :: @@ -98,55 +97,55 @@ :: :::: ++ able ^? |% - += note :: out request $-> - $? $: %d :: to %dill - $% [%flog p=flog:dill] :: + ++ note :: out request $-> + $? $: $d :: to %dill + $% {$flog p/flog:dill} :: == == :: - $: %a :: to %ames - $% [%kick p=@da] :: + $: $a :: to %ames + $% {$kick p/@da} :: == == :: - $: %g :: to %gall - $% [%deal p=sock q=cush:gall] :: + $: $g :: to %gall + $% {$deal p/sock q/cush:gall} :: == == :: $: @tas :: to any - $% [%init p=@p] :: - [%west p=sack q=path r=*] :: + $% {$init p/@p} :: + {$west p/sack q/path r/*} :: == == == :: - += gift :: out result <-$ - $% [%hear p=lane q=@] :: receive packet - [%init p=@p] :: report install - [%mack p=(unit tang)] :: - [%mass p=mass] :: memory usage - [%send p=lane q=@] :: transmit packet - [%woot p=ship q=coop] :: reaction message + ++ gift :: out result <-$ + $% {$hear p/lane q/@} :: receive packet + {$init p/@p} :: report install + {$mack p/(unit tang)} :: + {$mass p/mass} :: memory usage + {$send p/lane q/@} :: transmit packet + {$woot p/ship q/coop} :: reaction message == :: - += sign :: in result _<- - $? $: %g :: from %gall - $% [%unto p=cuft:gall] :: - [%mean p=ares] :: XX old clean up - [%nice ~] :: + ++ sign :: in result _<- + $? $: $g :: from %gall + $% {$unto p/cuft:gall} :: + {$mean p/ares} :: XX old clean up + {$nice $~} :: == == :: $: @tas :: - $% [%crud p=@tas q=(list tank)] :: by any - [%mack p=(unit tang)] :: message ack - [%woot p=ship q=coop] :: reaction message + $% {$crud p/@tas q/(list tank)} :: by any + {$mack p/(unit tang)} :: message ack + {$woot p/ship q/coop} :: reaction message == == == :: - += task :: in request ->$ - $% [%barn ~] :: new unix process - [%crud p=@tas q=(list tank)] :: error with trace - [%cash p=@p q=buck] :: civil license - [%hear p=lane q=@] :: receive packet - [%halo p=lane q=@ r=ares] :: hole with trace - [%hole p=lane q=@] :: packet failed - [%junk p=@] :: entropy - [%kick p=@da] :: wake up - [%nuke p=@p] :: toggle auto-block - [%make p=(unit @t) q=@ud r=@ s=?] :: wild license - [%sith p=@p q=@uw r=?] :: imperial generator - [%wake ~] :: timer activate - [%wegh ~] :: report memory - [%west p=sack q=path r=*] :: network request - [%want p=sock q=path r=*] :: forward message + ++ task :: in request ->$ + $% {$barn $~} :: new unix process + {$crud p/@tas q/(list tank)} :: error with trace + {$cash p/@p q/buck} :: civil license + {$hear p/lane q/@} :: receive packet + {$halo p/lane q/@ r/ares} :: hole with trace + {$hole p/lane q/@} :: packet failed + {$junk p/@} :: entropy + {$kick p/@da} :: wake up + {$nuke p/@p} :: toggle auto-block + {$make p/(unit @t) q/@ud r/@ s/?} :: wild license + {$sith p/@p q/@uw r/?} :: imperial generator + {$wake $~} :: timer activate + {$wegh $~} :: report memory + {$west p/sack q/path r/*} :: network request + {$want p/sock q/path r/*} :: forward message == :: -- ::able :: @@ -155,15 +154,15 @@ ++ acru $_ ^? :: asym cryptosuite |% :: opaque object ++ as ^? :: asym ops - |% ++ seal |~([a=pass b=@ c=@] *@) :: encrypt to a - ++ sign |~([a=@ b=@] *@) :: certify as us - ++ sure |~([a=@ b=@] *(unit @)) :: authenticate from us - ++ tear |~ [a=pass b=@] :: accept from a - *(unit [p=@ q=@]) :: + |% ++ seal |~({a/pass b/@ c/@} *@) :: encrypt to a + ++ sign |~({a/@ b/@} *@) :: certify as us + ++ sure |~({a/@ b/@} *(unit @)) :: authenticate from us + ++ tear |~ {a/pass b/@} :: accept from a + *(unit {p/@ q/@}) :: -- ::as :: - ++ de |~([a=@ b=@] *(unit @)) :: symmetric de, soft - ++ dy |~([a=@ b=@] *@) :: symmetric de, hard - ++ en |~([a=@ b=@] *@) :: symmetric en + ++ de |~({a/@ b/@} *(unit @)) :: symmetric de, soft + ++ dy |~({a/@ b/@} *@) :: symmetric de, hard + ++ en |~({a/@ b/@} *@) :: symmetric en ++ ex ^? :: export |% ++ fig *@uvH :: fingerprint ++ pac *@uvG :: default passcode @@ -171,164 +170,164 @@ ++ sec *ring :: private key -- ::ex :: ++ nu ^? :: reconstructors - |% ++ pit |~([a=@ b=@] ^?(..nu)) :: from [width seed] - ++ nol |~(a=@ ^?(..nu)) :: from naked ring - ++ com |~(a=@ ^?(..nu)) :: from naked pass + |% ++ pit |~({a/@ b/@} ^?(..nu)) :: from [width seed] + ++ nol |~(a/@ ^?(..nu)) :: from naked ring + ++ com |~(a/@ ^?(..nu)) :: from naked pass -- ::nu :: -- ::acru :: - += bait [p=skin q=@ud r=dove] :: fmt nrecvd spec - += bath :: convo per client - $: sop=shed :: not stalled - raz=(map path race) :: statements inbound - ryl=(map path rill) :: statements outbound + ++ bait {p/skin q/@ud r/dove} :: fmt nrecvd spec + ++ bath :: convo per client + $: sop/shed :: not stalled + raz/(map path race) :: statements inbound + ryl/(map path rill) :: statements outbound == :: - += boon :: fort output - $% [%beer p=ship q=@uvG] :: gained ownership - [%cake p=sock q=soap r=coop s=duct] :: e2e message result - [%mead p=lane q=rock] :: accept packet - [%milk p=sock q=soap r=*] :: e2e pass message - [%ouzo p=lane q=rock] :: transmit packet - [%wine p=sock q=tape] :: notify user + ++ boon :: fort output + $% {$beer p/ship q/@uvG} :: gained ownership + {$cake p/sock q/soap r/coop s/duct} :: e2e message result + {$mead p/lane q/rock} :: accept packet + {$milk p/sock q/soap r/*} :: e2e pass message + {$ouzo p/lane q/rock} :: transmit packet + {$wine p/sock q/tape} :: notify user == :: - += bray [p=life q=(unit life) r=ship s=@da] :: our parent us now - += buck [p=mace q=wyll] :: all security data - += cake [p=sock q=skin r=@] :: top level packet - += cape :: end-to-end result - $? %good :: delivered - %dead :: rejected + ++ bray {p/life q/(unit life) r/ship s/@da} :: our parent us now + ++ buck {p/mace q/wyll} :: all security data + ++ cake {p/sock q/skin r/@} :: top level packet + ++ cape :: end-to-end result + $? $good :: delivered + $dead :: rejected == :: - += clot :: symmetric record - $: yed=(unit [p=hand q=code]) :: outbound - heg=(map hand code) :: proposed - qim=(map hand code) :: inbound + ++ clot :: symmetric record + $: yed/(unit {p/hand q/code}) :: outbound + heg/(map hand code) :: proposed + qim/(map hand code) :: inbound == :: - += code @uvI :: symmetric key - += corn :: flow by server - $: hen=duct :: admin channel - nys=(map flap bait) :: packets incoming - olz=(map flap cape) :: packets completed - wab=(map ship bath) :: relationship + ++ code @uvI :: symmetric key + ++ corn :: flow by server + $: hen/duct :: admin channel + nys/(map flap bait) :: packets incoming + olz/(map flap cape) :: packets completed + wab/(map ship bath) :: relationship == :: - += deyd [p=@ q=step r=?] :: sig stage fake? - += dore :: foreign contact - $: wod=road :: connection to - wyl=wyll :: inferred mirror - caq=clot :: symmetric key state + ++ deyd {p/@ q/step r/?} :: sig stage fake? + ++ dore :: foreign contact + $: wod/road :: connection to + wyl/wyll :: inferred mirror + caq/clot :: symmetric key state == :: - += dove [p=@ud q=(map @ud @)] :: count hash 13-blocks - += flap @uvH :: network packet id - += flow :: packet connection - $: rtt=@dr :: decaying avg rtt - wid=@ud :: logical wdow msgs + ++ dove {p/@ud q/(map @ud @)} :: count hash 13-blocks + ++ flap @uvH :: network packet id + ++ flow :: packet connection + $: rtt/@dr :: decaying avg rtt + wid/@ud :: logical wdow msgs == :: - += fort :: formal state + ++ fort :: formal state $: $0 :: version - gad=duct :: client interface - hop=@da :: network boot date - bad=(set @p) :: bad ships - ton=town :: security - zac=(map ship corn) :: flows by server + gad/duct :: client interface + hop/@da :: network boot date + bad/(set @p) :: bad ships + ton/town :: security + zac/(map ship corn) :: flows by server == :: - += gcos :: id description - $% [%czar ~] :: 8-bit ship - [%duke p=what] :: 32-bit ship - [%earl p=@t] :: 64-bit ship - [%king p=@t] :: 16-bit ship - [%pawn p=(unit @t)] :: 128-bit ship + ++ gcos :: id description + $% {$czar $~} :: 8-bit ship + {$duke p/what} :: 32-bit ship + {$earl p/@t} :: 64-bit ship + {$king p/@t} :: 16-bit ship + {$pawn p/(unit @t)} :: 128-bit ship == :: - += gens [p=lang q=gcos] :: general identity - += govt path :: country+postcode - += hand @uvH :: 128-bit hash - += lane :: packet route - $% [%if p=@da q=@ud r=@if] :: IP4=public UDP=addr - [%is p=@ud q=(unit lane) r=@is] :: IPv6 w+alternates - [%ix p=@da q=@ud r=@if] :: IPv4 provisional + ++ gens {p/lang q/gcos} :: general identity + ++ govt path :: country+postcode + ++ hand @uvH :: 128-bit hash + ++ lane :: packet route + $% {$if p/@da q/@ud r/@if} :: IP4/public UDP/addr + {$is p/@ud q/(unit lane) r/@is} :: IPv6 w+alternates + {$ix p/@da q/@ud r/@if} :: IPv4 provisional == :: - += lang @ta :: IETF lang as code - += lice [p=ship q=buck] :: full license - += life @ud :: regime number - += mace (list [p=life q=ring]) :: private secrets - += meal :: payload - $% [%back p=coop q=flap r=@dr] :: ack - [%bond p=life q=path r=@ud s=*] :: message - [%carp p=@ q=@ud r=@ud s=flap t=@] :: skin+inx+cnt+hash - [%fore p=ship q=(unit lane) r=@] :: forwarded packet + ++ lang @ta :: IETF lang as code + ++ lice {p/ship q/buck} :: full license + ++ life @ud :: regime number + ++ mace (list {p/life q/ring}) :: private secrets + ++ meal :: payload + $% {$back p/coop q/flap r/@dr} :: ack + {$bond p/life q/path r/@ud s/*} :: message + {$carp p/@ q/@ud r/@ud s/flap t/@} :: skin+inx+cnt+hash + {$fore p/ship q/(unit lane) r/@} :: forwarded packet == :: - += name [p=@t q=(unit @t) r=(unit @t) s=@t] :: first mid+nick last - += putt :: outgoing message - $: ski=snow :: sequence acked+sent - wyv=(list rock) :: packet list XX gear + ++ name {p/@t q/(unit @t) r/(unit @t) s/@t} :: first mid+nick last + ++ putt :: outgoing message + $: ski/snow :: sequence acked+sent + wyv/(list rock) :: packet list XX gear == :: - += race :: inbound stream - $: did=@ud :: filled sequence - dod=? :: not processing - bum=(map @ud ares) :: nacks - mis=(map @ud [p=cape q=lane r=flap s=(unit)]) :: misordered + ++ race :: inbound stream + $: did/@ud :: filled sequence + dod/? :: not processing + bum/(map @ud ares) :: nacks + mis/(map @ud {p/cape q/lane r/flap s/(unit)}) :: misordered == :: - += rank ?(%czar %king %duke %earl %pawn) :: ship width class - += rill :: outbound stream - $: sed=@ud :: sent - san=(map @ud duct) :: outstanding + ++ rank ?($czar $king $duke $earl $pawn) :: ship width class + ++ rill :: outbound stream + $: sed/@ud :: sent + san/(map @ud duct) :: outstanding == :: - += road :: secured oneway route - $: exp=@da :: expiration date - lun=(unit lane) :: route to friend - lew=wyll :: wyll of friend + ++ road :: secured oneway route + $: exp/@da :: expiration date + lun/(unit lane) :: route to friend + lew/wyll :: wyll of friend == :: - += rock @uvO :: packet - += sect ?(%black %blue %red %orange %white) :: banner - += shed :: packet flow - $: $: rtt=@dr :: smoothed rtt - rto=@dr :: retransmit timeout - rtn=(unit @da) :: next timeout - rue=(unit @da) :: last heard from + ++ rock @uvO :: packet + ++ sect ?($black $blue $red $orange $white) :: banner + ++ shed :: packet flow + $: $: rtt/@dr :: smoothed rtt + rto/@dr :: retransmit timeout + rtn/(unit @da) :: next timeout + rue/(unit @da) :: last heard from == :: - $: nus=@ud :: number sent - nif=@ud :: number live - nep=@ud :: next expected - caw=@ud :: logical window - cag=@ud :: congest thresh + $: nus/@ud :: number sent + nif/@ud :: number live + nep/@ud :: next expected + caw/@ud :: logical window + cag/@ud :: congest thresh == :: - $: diq=(map flap @ud) :: packets sent - pyz=(map soup @ud) :: message+unacked - puq=(qeu [p=@ud q=soul]) :: packet queue + $: diq/(map flap @ud) :: packets sent + pyz/(map soup @ud) :: message+unacked + puq/(qeu {p/@ud q/soul}) :: packet queue == :: == :: - += skin ?(%none %open %fast %full) :: encoding stem - += snow [p=@ud q=@ud r=(set @ud)] :: window exceptions - += soap [p=[p=life q=life] q=path r=@ud] :: statement id - += soup [p=path q=@ud] :: new statement id - += soul :: packet in travel - $: gom=soup :: message identity - nux=@ud :: xmission count - liv=? :: deemed live - lys=@da :: last sent - pac=rock :: packet data + ++ skin ?($none $open $fast $full) :: encoding stem + ++ snow {p/@ud q/@ud r/(set @ud)} :: window exceptions + ++ soap {p/{p/life q/life} q/path r/@ud} :: statement id + ++ soup {p/path q/@ud} :: new statement id + ++ soul :: packet in travel + $: gom/soup :: message identity + nux/@ud :: xmission count + liv/? :: deemed live + lys/@da :: last sent + pac/rock :: packet data == :: - += step [p=bray q=gens r=pass] :: identity stage - += sufi :: domestic host - $: hoy=(list ship) :: hierarchy - val=wund :: private keys - law=wyll :: server wyll - seh=(map hand [p=ship q=@da]) :: key cache - hoc=(map ship dore) :: neighborhood + ++ step {p/bray q/gens r/pass} :: identity stage + ++ sufi :: domestic host + $: hoy/(list ship) :: hierarchy + val/wund :: private keys + law/wyll :: server wyll + seh/(map hand {p/ship q/@da}) :: key cache + hoc/(map ship dore) :: neighborhood == :: - += tick @ud :: process id - += town :: all security state - $: lit=@ud :: imperial modulus - any=@ :: entropy - urb=(map ship sufi) :: all keys and routes - fak=? :: + ++ tick @ud :: process id + ++ town :: all security state + $: lit/@ud :: imperial modulus + any/@ :: entropy + urb/(map ship sufi) :: all keys and routes + fak/? :: == :: - += what :: logical identity - $% [%anon ~] :: anonymous - [%lady p=whom] :: female person () - [%lord p=whom] :: male person [] - [%punk p=sect q=@t] :: opaque handle "" + ++ what :: logical identity + $% {$anon $~} :: anonymous + {$lady p/whom} :: female person () + {$lord p/whom} :: male person [] + {$punk p/sect q/@t} :: opaque handle "" == :: - += whom [p=@ud q=govt r=sect s=name] :: year+govt+id - += wund (list [p=life q=ring r=acru]) :: mace in action - += wyll (list deyd) :: certificate + ++ whom {p/@ud q/govt r/sect s/name} :: year+govt+id + ++ wund (list {p/life q/ring r/acru}) :: mace in action + ++ wyll (list deyd) :: certificate -- ::ames :: :::: :::: ++behn :: (1b) timekeeping @@ -340,15 +339,15 @@ :: :::: ++ able ^? |% - += gift :: out result <-$ - $% [%mass p=mass] :: memory usage - [%wake ~] :: wakeup + ++ gift :: out result <-$ + $% {$mass p/mass} :: memory usage + {$wake $~} :: wakeup == :: - += task :: in request ->$ - $% [%rest p=@da] :: cancel alarm - [%wait p=@da] :: set alarm - [%wake ~] :: timer activate - [%wegh ~] :: report memory + ++ task :: in request ->$ + $% {$rest p/@da} :: cancel alarm + {$wait p/@da} :: set alarm + {$wake $~} :: timer activate + {$wegh $~} :: report memory == :: -- ::able -- ::behn @@ -362,135 +361,135 @@ :: :::: ++ able ^? |% - += gift :: out result <-$ - $% [%dirk p=@tas] :: mark mount dirty - [%ergo p=@tas q=mode] :: version update - [%hill p=(list @tas)] :: mount points - [%mack p=(unit tang)] :: ack - [%mass p=mass] :: memory usage - [%mere p=(each (set path) (pair term tang))] :: merge result - [%note p=@tD q=tank] :: debug message - [%ogre p=@tas] :: delete mount point - [%send p=lane:ames q=@] :: transmit packet - [%writ p=riot] :: response + ++ gift :: out result <-$ + $% {$dirk p/@tas} :: mark mount dirty + {$ergo p/@tas q/mode} :: version update + {$hill p/(list @tas)} :: mount points + {$mack p/(unit tang)} :: ack + {$mass p/mass} :: memory usage + {$mere p/(each (set path) (pair term tang))} :: merge result + {$note p/@tD q/tank} :: debug message + {$ogre p/@tas} :: delete mount point + {$send p/lane:ames q/@} :: transmit packet + {$writ p/riot} :: response == :: - += task :: in request ->$ - $% [%boat ~] :: pier rebooted - [%drop p=@p q=desk] :: cancel pending merge - [%info p=@p q=desk r=nori] :: internal edit - [%init p=@p] :: report install - [%into p=desk q=? r=mode] :: external edit - [%merg p=@p q=desk r=@p s=desk t=case u=germ] :: merge desks - [%mont p=desk q=beam] :: mount to unix - [%dirk p=desk] :: mark mount dirty - [%ogre p=$@(desk beam)] :: delete mount point - [%warp p=sock q=riff] :: file request - [%wegh ~] :: report memory - [%went p=sack q=path r=@ud s=coop] :: response confirm - [%west p=sack q=path r=*] :: network request + ++ task :: in request ->$ + $% {$boat $~} :: pier rebooted + {$drop p/@p q/desk} :: cancel pending merge + {$info p/@p q/desk r/nori} :: internal edit + {$init p/@p} :: report install + {$into p/desk q/? r/mode} :: external edit + {$merg p/@p q/desk r/@p s/desk t/case u/germ} :: merge desks + {$mont p/desk q/beam} :: mount to unix + {$dirk p/desk} :: mark mount dirty + {$ogre p/$@(desk beam)} :: delete mount point + {$warp p/sock q/riff} :: file request + {$wegh $~} :: report memory + {$went p/sack q/path r/@ud s/coop} :: response confirm + {$west p/sack q/path r/*} :: network request == :: -- ::able :: :::: :: (1c2) :: - += aeon @ud :: version number - += ankh :: fs node (new) - $: fil=(unit [p=lobe q=cage]) :: file - dir=(map @ta ankh) :: folders + ++ aeon @ud :: version number + ++ ankh :: fs node (new) + $: fil/(unit {p/lobe q/cage}) :: file + dir/(map @ta ankh) :: folders == :: - += beam [[p=ship q=desk r=case] s=path] :: global name - += beak [p=ship q=desk r=case] :: path prefix - += blob :: fs blob - $% [%delta p=lobe q=[p=mark q=lobe] r=page] :: delta on q - [%direct p=lobe q=page] :: immediate + ++ beam {{p/ship q/desk r/case} s/path} :: global name + ++ beak {p/ship q/desk r/case} :: path prefix + ++ blob :: fs blob + $% {$delta p/lobe q/{p/mark q/lobe} r/page} :: delta on q + {$direct p/lobe q/page} :: immediate == :: - += care ?(%d %u %v %w %x %y %z) :: clay submode - += case :: ship desk case spur - $% [%da p=@da] :: date - [%tas p=@tas] :: label - [%ud p=@ud] :: number + ++ care ?($d $u $v $w $x $y $z) :: clay submode + ++ case :: ship desk case spur + $% {$da p/@da} :: date + {$tas p/@tas} :: label + {$ud p/@ud} :: number == :: - += coop (unit ares) :: e2e ack - += dome :: project state - $: ank=ankh :: state - let=@ud :: top id - hit=(map @ud tako) :: changes by id - lab=(map @tas @ud) :: labels + ++ coop (unit ares) :: e2e ack + ++ dome :: project state + $: ank/ankh :: state + let/@ud :: top id + hit/(map @ud tako) :: changes by id + lab/(map @tas @ud) :: labels == :: - += germ :: merge style - $? %init :: new desk - %this :: ours with parents - %that :: hers with parents - %fine :: fast forward - %meet :: orthogonal files - %mate :: orthogonal changes - %meld :: force merge + ++ germ :: merge style + $? $init :: new desk + $this :: ours with parents + $that :: hers with parents + $fine :: fast forward + $meet :: orthogonal files + $mate :: orthogonal changes + $meld :: force merge == :: - += khan :: - $: fil=(unit (unit cage)) :: see ++khan-to-soba - dir=(unit (map @ta (unit khan))) :: + ++ khan :: + $: fil/(unit (unit cage)) :: see ++khan-to-soba + dir/(unit (map @ta (unit khan))) :: == :: - += lobe @uvI :: blob ref - += maki [p=@ta q=@ta r=@ta s=path] :: - += miso :: ankh delta - $% [%del ~] :: delete - [%ins p=cage] :: insert - [%dif p=cage] :: mutate from diff - [%mut p=cage] :: mutate from raw + ++ lobe @uvI :: blob ref + ++ maki {p/@ta q/@ta r/@ta s/path} :: + ++ miso :: ankh delta + $% {$del $~} :: delete + {$ins p/cage} :: insert + {$dif p/cage} :: mutate from diff + {$mut p/cage} :: mutate from raw == :: - += misu :: computed delta - $% [%del ~] :: delete - [%ins p=cage] :: insert - [%dif p=lobe q=cage] :: mutate from diff + ++ misu :: computed delta + $% {$del $~} :: delete + {$ins p/cage} :: insert + {$dif p/lobe q/cage} :: mutate from diff == :: - += mizu [p=@u q=(map @ud tako) r=rang] :: new state - += moar [p=@ud q=@ud] :: normal change range - += moat [p=case q=case r=path] :: change range - += mode (list [path (unit mime)]) :: external files - += mood [p=care q=case r=path] :: request in desk - += nori :: repository action - $% [$& p=soba] :: delta - [$| p=@tas] :: label + ++ mizu {p/@u q/(map @ud tako) r/rang} :: new state + ++ moar {p/@ud q/@ud} :: normal change range + ++ moat {p/case q/case r/path} :: change range + ++ mode (list {path (unit mime)}) :: external files + ++ mood {p/care q/case r/path} :: request in desk + ++ nori :: repository action + $% {$& p/soba} :: delta + {$| p/@tas} :: label == :: - += nuri :: repository action - $% [$& p=suba] :: delta - [$| p=@tas] :: label + ++ nuri :: repository action + $% {$& p/suba} :: delta + {$| p/@tas} :: label == :: - += page (cask *) :: untyped cage - += plop blob :: unvalidated blob - += rang :: repository - $: hut=(map tako yaki) :: changes - lat=(map lobe blob) :: data + ++ page (cask *) :: untyped cage + ++ plop blob :: unvalidated blob + ++ rang :: repository + $: hut/(map tako yaki) :: changes + lat/(map lobe blob) :: data == :: - += rant :: response to request - $: p=[p=care q=case r=@tas] :: clade release book - q=path :: spur - r=cage :: data + ++ rant :: response to request + $: p/{p/care q/case r/@tas} :: clade release book + q/path :: spur + r/cage :: data == :: - += rave :: general request - $% [%sing p=mood] :: single request - [%next p=mood] :: await next version - [%many p=? q=moat] :: track range + ++ rave :: general request + $% {$sing p/mood} :: single request + {$next p/mood} :: await next version + {$many p/? q/moat} :: track range == :: - += riff [p=desk q=(unit rave)] :: request+desist - += riot (unit rant) :: response+complete - += rump [p=care q=case r=@tas s=path] :: relative path - += saba [p=ship q=@tas r=moar s=dome] :: patch+merge - += soba (list [p=path q=miso]) :: delta - += suba (list [p=path q=misu]) :: delta - += tako @ :: yaki ref - += toro [p=@ta q=nori] :: general change + ++ riff {p/desk q/(unit rave)} :: request+desist + ++ riot (unit rant) :: response+complete + ++ rump {p/care q/case r/@tas s/path} :: relative path + ++ saba {p/ship q/@tas r/moar s/dome} :: patch+merge + ++ soba (list {p/path q/miso}) :: delta + ++ suba (list {p/path q/misu}) :: delta + ++ tako @ :: yaki ref + ++ toro {p/@ta q/nori} :: general change ++ unce :: change part - |* a=mold :: - $% [$& p=@ud] :: skip[copy] - [$| p=(list a) q=(list a)] :: p -> q[chunk] + |* a/mold :: + $% {$& p/@ud} :: skip[copy] + {$| p/(list a) q/(list a)} :: p -> q[chunk] == :: - ++ urge |*(a=mold (list (unce a))) :: list change - += yaki :: commit - $: p=(list tako) :: parents - q=(map path lobe) :: namespace - r=tako :: self-reference - t=@da :: date + ++ urge |*(a/mold (list (unce a))) :: list change + ++ yaki :: commit + $: p/(list tako) :: parents + q/(map path lobe) :: namespace + r/tako :: self-reference + t/@da :: date == :: -- ::clay :: :::: @@ -503,109 +502,109 @@ :: :::: ++ able ^? |% - += gift :: out result <-$ - $% [%bbye ~] :: reset prompt - [%blit p=(list blit)] :: terminal output - [%burl p=@t] :: activate url - [%init p=@p] :: set owner - [%logo ~] :: logout - [%mass p=mass] :: memory usage - [%send p=lane:ames q=@] :: transmit packet - [%veer p=@ta q=path r=@t] :: install vane - [%vega p=path q=path] :: old reboot - [%velo p=@t q=@t] :: reboot - [%verb ~] :: verbose mode + ++ gift :: out result <-$ + $% {$bbye $~} :: reset prompt + {$blit p/(list blit)} :: terminal output + {$burl p/@t} :: activate url + {$init p/@p} :: set owner + {$logo $~} :: logout + {$mass p/mass} :: memory usage + {$send p/lane:ames q/@} :: transmit packet + {$veer p/@ta q/path r/@t} :: install vane + {$vega p/path q/path} :: old reboot + {$velo p/@t q/@t} :: reboot + {$verb $~} :: verbose mode == :: - += task :: in request ->$ - $% [%belt p=belt] :: terminal input - [%blew p=blew] :: terminal config - [%boot p=*] :: weird %dill boot - [%crud p=@tas q=(list tank)] :: error with trace - [%flog p=flog] :: wrapped error - [%flow p=@tas q=(list gill:gall)] :: terminal config - [%hail ~] :: terminal refresh - [%heft ~] :: memory report - [%hook ~] :: this term hung up - [%harm ~] :: all terms hung up - [%init p=ship] :: after gall ready - [%tick p=@p q=@p] :: initial ticket - [%noop ~] :: no operation - [%talk p=tank] :: - [%text p=tape] :: - [%veer p=@ta q=path r=@t] :: install vane - [%vega p=path q=path] :: old reboot - [%velo p=@t q=@t] :: reboot - [%verb ~] :: verbose mode + ++ task :: in request ->$ + $% {$belt p/belt} :: terminal input + {$blew p/blew} :: terminal config + {$boot p/*} :: weird %dill boot + {$crud p/@tas q/(list tank)} :: error with trace + {$flog p/flog} :: wrapped error + {$flow p/@tas q/(list gill:gall)} :: terminal config + {$hail $~} :: terminal refresh + {$heft $~} :: memory report + {$hook $~} :: this term hung up + {$harm $~} :: all terms hung up + {$init p/ship} :: after gall ready + {$tick p/@p q/@p} :: initial ticket + {$noop $~} :: no operation + {$talk p/tank} :: + {$text p/tape} :: + {$veer p/@ta q/path r/@t} :: install vane + {$vega p/path q/path} :: old reboot + {$velo p/@t q/@t} :: reboot + {$verb $~} :: verbose mode == :: -- ::able :: :::: :: (1d2) :: - += blew [p=@ud q=@ud] :: columns rows - += belt :: old belt - $% [%aro p=?(%d %l %r %u)] :: arrow key - [%bac ~] :: true backspace - [%ctl p=@c] :: control-key - [%del ~] :: true delete - [%met p=@c] :: meta-key - [%ret ~] :: return - [%txt p=(list @c)] :: utf32 text + ++ blew {p/@ud q/@ud} :: columns rows + ++ belt :: old belt + $% {$aro p/?($d $l $r $u)} :: arrow key + {$bac $~} :: true backspace + {$ctl p/@c} :: control-key + {$del $~} :: true delete + {$met p/@c} :: meta-key + {$ret $~} :: return + {$txt p/(list @c)} :: utf32 text == :: - += blit :: old blit - $% [%bel ~] :: make a noise - [%clr ~] :: clear the screen - [%hop p=@ud] :: set cursor position - [%lin p=(list @c)] :: set current line - [%mor ~] :: newline - [%sag p=path q=*] :: save to jamfile - [%sav p=path q=@] :: save to file - [%url p=@t] :: activate url + ++ blit :: old blit + $% {$bel $~} :: make a noise + {$clr $~} :: clear the screen + {$hop p/@ud} :: set cursor position + {$lin p/(list @c)} :: set current line + {$mor $~} :: newline + {$sag p/path q/*} :: save to jamfile + {$sav p/path q/@} :: save to file + {$url p/@t} :: activate url == :: - += deco ?(~ %bl %br %un) :: text decoration - += dill-belt :: new belt - $% [%aro p=?(%d %l %r %u)] :: arrow key - [%bac ~] :: true backspace - [%cru p=@tas q=(list tank)] :: echo error - [%ctl p=@] :: control-key - [%del ~] :: true delete - [%hey ~] :: refresh - [%met p=@] :: meta-key - [%ret ~] :: return - [%rez p=@ud q=@ud] :: resize, cols, rows - [%txt p=(list @c)] :: utf32 text - [%yow p=gill:gall] :: connect to app + ++ deco ?($~ $bl $br $un) :: text decoration + ++ dill-belt :: new belt + $% {$aro p/?($d $l $r $u)} :: arrow key + {$bac $~} :: true backspace + {$cru p/@tas q/(list tank)} :: echo error + {$ctl p/@} :: control-key + {$del $~} :: true delete + {$hey $~} :: refresh + {$met p/@} :: meta-key + {$ret $~} :: return + {$rez p/@ud q/@ud} :: resize, cols, rows + {$txt p/(list @c)} :: utf32 text + {$yow p/gill:gall} :: connect to app == :: - += dill-blit :: new blit - $% [%bel ~] :: make a noise - [%clr ~] :: clear the screen - [%hop p=@ud] :: set cursor position - [%klr p=stub] :: styled text - [%mor p=(list dill-blit)] :: multiple blits - [%pom p=stub] :: styled prompt - [%pro p=(list @c)] :: show as cursor+line - [%qit ~] :: close console - [%out p=(list @c)] :: send output line - [%sag p=path q=*] :: save to jamfile - [%sav p=path q=@] :: save to file - [%url p=@t] :: activate url + ++ dill-blit :: new blit + $% {$bel $~} :: make a noise + {$clr $~} :: clear the screen + {$hop p/@ud} :: set cursor position + {$klr p/stub} :: styled text + {$mor p/(list dill-blit)} :: multiple blits + {$pom p/stub} :: styled prompt + {$pro p/(list @c)} :: show as cursor+line + {$qit $~} :: close console + {$out p/(list @c)} :: send output line + {$sag p/path q/*} :: save to jamfile + {$sav p/path q/@} :: save to file + {$url p/@t} :: activate url == :: - += flog :: sent to %dill - $% [%crud p=@tas q=(list tank)] :: - [%heft ~] :: - [%text p=tape] :: - [%veer p=@ta q=path r=@t] :: install vane - [%vega p=path q=path] :: old reboot - [%velo p=@t q=@t] :: reboot - [%verb ~] :: verbose mode + ++ flog :: sent to %dill + $% {$crud p/@tas q/(list tank)} :: + {$heft $~} :: + {$text p/tape} :: + {$veer p/@ta q/path r/@t} :: install vane + {$vega p/path q/path} :: old reboot + {$velo p/@t q/@t} :: reboot + {$verb $~} :: verbose mode == :: - += stub (list (pair stye (list @c))) :: styled tuba - += stye (pair (set deco) (pair tint tint)) :: decos=bg=fg - += styl :: cascading stye + ++ stub (list (pair stye (list @c))) :: styled tuba + ++ stye (pair (set deco) (pair tint tint)) :: decos/bg/fg + ++ styl :: cascading stye %+ pair (unit deco) :: (pair (unit tint) (unit tint)) :: :: :: - += styx (list $@(@t (pair styl styx))) :: styled text - += tint ?(~ %r %g %b %c %m %y %k %w) :: text color + ++ styx (list $@(@t (pair styl styx))) :: styled text + ++ tint ?($~ $r $g $b $c $m $y $k $w) :: text color -- ::dill :: :::: :::: ++eyre :: (1e) oldweb @@ -617,124 +616,124 @@ :: :::: ++ able ^? |% - += gift :: out result <-$ - $% [%mass p=mass] :: memory usage - [%mack p=(unit tang)] :: message ack - [%sigh p=cage] :: marked http response - [%thou p=httr] :: raw http response - [%thus p=@ud q=(unit hiss)] :: http request+cancel - [%veer p=@ta q=path r=@t] :: drop-through - [%vega p=path q=path] :: drop-through - [%velo p=@t q=@t] :: drop-through - [%mini-jael-gift *] + ++ gift :: out result <-$ + $% {$mass p/mass} :: memory usage + {$mack p/(unit tang)} :: message ack + {$sigh p/cage} :: marked http response + {$thou p/httr} :: raw http response + {$thus p/@ud q/(unit hiss)} :: http request+cancel + {$veer p/@ta q/path r/@t} :: drop-through + {$vega p/path q/path} :: drop-through + {$velo p/@t q/@t} :: drop-through + {$mini-jael-gift *} == :: - += task :: in request ->$ - $% [%born ~] :: new unix process - [%crud p=@tas q=(list tank)] :: XX rethink - [%hiss p=(unit user) q=mark r=cage] :: outbound user req - [%init p=@p] :: report install - [%serv p=$@(desk beam)] :: set serving root - [%them p=(unit hiss)] :: outbound request - [%they p=@ud q=httr] :: inbound response - [%chis p=? q=clip r=httq] :: IPC inbound request - [%this p=? q=clip r=httq] :: inbound request - [%thud ~] :: inbound cancel - [%wegh ~] :: report memory - [%went p=sack q=path r=@ud s=coop] :: response confirm - [%west p=sack q=[path *]] :: network request - [%mini-jael-task *] + ++ task :: in request ->$ + $% {$born $~} :: new unix process + {$crud p/@tas q/(list tank)} :: XX rethink + {$hiss p/(unit user) q/mark r/cage} :: outbound user req + {$init p/@p} :: report install + {$serv p/$@(desk beam)} :: set serving root + {$them p/(unit hiss)} :: outbound request + {$they p/@ud q/httr} :: inbound response + {$chis p/? q/clip r/httq} :: IPC inbound request + {$this p/? q/clip r/httq} :: inbound request + {$thud $~} :: inbound cancel + {$wegh $~} :: report memory + {$went p/sack q/path r/@ud s/coop} :: response confirm + {$west p/sack q/{path *}} :: network request + {$mini-jael-task *} == :: -- ::able :: :::: :: (1e2) :: ++ bale :: driver state - |* a=_* :: %jael keys type - $: [our=ship now=@da eny=@uvJ byk=beak] :: base info - [usr=user dom=(list @t)] :: req user, domain - key=a :: secrets from %jael + |* a/_* :: %jael keys type + $: {our/ship now/@da eny/@uvJ byk/beak} :: base info + {usr/user dom/(list @t)} :: req user, domain + key/a :: secrets from %jael == :: :: - += clip (each @if @is) :: client IP - += cred :: credential - $: hut=hart :: client host - aut=(jug @tas @t) :: client identities - orx=oryx :: CSRF secret - acl=(unit @t) :: accept-language - cip=(each @if @is) :: client IP - cum=(map @tas *) :: custom dirt + ++ clip (each @if @is) :: client IP + ++ cred :: credential + $: hut/hart :: client host + aut/(jug @tas @t) :: client identities + orx/oryx :: CSRF secret + acl/(unit @t) :: accept-language + cip/(each @if @is) :: client IP + cum/(map @tas *) :: custom dirt == :: - += epic :: FCGI parameters - $: qix=(map @t @t) :: query - ced=cred :: client credentials - bem=beam :: original path - but=path :: ending + ++ epic :: FCGI parameters + $: qix/(map @t @t) :: query + ced/cred :: client credentials + bem/beam :: original path + but/path :: ending == :: - += gram :: inter-ship message - $? [[%get ~] p=@uvH q=[? clip httq]] :: remote request - [[%got ~] p=@uvH q=httr] :: remote response - [[%gib ~] p=@uvH] :: remote cancel + ++ gram :: inter-ship message + $? {{$get $~} p/@uvH q/{? clip httq}} :: remote request + {{$got $~} p/@uvH q/httr} :: remote response + {{$gib $~} p/@uvH} :: remote cancel == :: - += hart [p=? q=(unit @ud) r=host] :: http sec+port+host - += hate [p=purl q=@p r=moth] :: semi-cooked request - += heir [p=@ud q=mess r=(unit love)] :: status+headers+data - += hiss [p=purl q=moth] :: outbound request - += hole @t :: session identity - += hort [p=(unit @ud) q=host] :: http port+host - += host (each (list @t) @if) :: http host - += hoke %+ each [%localhost ~] :: local host + ++ hart {p/? q/(unit @ud) r/host} :: http sec+port+host + ++ hate {p/purl q/@p r/moth} :: semi-cooked request + ++ heir {p/@ud q/mess r/(unit love)} :: status+headers+data + ++ hiss {p/purl q/moth} :: outbound request + ++ hole @t :: session identity + ++ hort {p/(unit @ud) q/host} :: http port+host + ++ host (each (list @t) @if) :: http host + ++ hoke %+ each {$localhost $~} :: local host ?($.0.0.0.0 $.127.0.0.1) :: - += httq :: raw http request - $: p=meth :: method - q=@t :: unparsed url - r=(list [p=@t q=@t]) :: headers - s=(unit octs) :: body + ++ httq :: raw http request + $: p/meth :: method + q/@t :: unparsed url + r/(list {p/@t q/@t}) :: headers + s/(unit octs) :: body == :: - += httr [p=@ud q=mess r=(unit octs)] :: raw http response - += httx :: encapsulated http - $: p=? :: https? - q=clip :: source IP - r=httq :: + ++ httr {p/@ud q/mess r/(unit octs)} :: raw http response + ++ httx :: encapsulated http + $: p/? :: https? + q/clip :: source IP + r/httq :: == :: - += user knot :: username - += love :: http response - $% [%ham p=manx] :: html node - [%mid p=mite q=octs] :: mime-typed data - [%raw p=httr] :: raw http response - [%wan p=wain] :: text lines - [%zap p=@ud q=(list tank)] :: status+error + ++ user knot :: username + ++ love :: http response + $% {$ham p/manx} :: html node + {$mid p/mite q/octs} :: mime-typed data + {$raw p/httr} :: raw http response + {$wan p/wain} :: text lines + {$zap p/@ud q/(list tank)} :: status+error == :: - += math (map @t (list @t)) :: semiparsed headers - += mess (list [p=@t q=@t]) :: raw http headers - += meth :: http methods - $? %conn :: CONNECT - %delt :: DELETE - %get :: GET - %head :: HEAD - %opts :: OPTIONS - %post :: POST - %put :: PUT - %trac :: TRACE + ++ math (map @t (list @t)) :: semiparsed headers + ++ mess (list {p/@t q/@t}) :: raw http headers + ++ meth :: http methods + $? $conn :: CONNECT + $delt :: DELETE + $get :: GET + $head :: HEAD + $opts :: OPTIONS + $post :: POST + $put :: PUT + $trac :: TRACE == :: - += mite (list @ta) :: mime type - += moth [p=meth q=math r=(unit octs)] :: http operation - += octs [p=@ud q=@t] :: octet-stream - += oryx @t :: CSRF secret - += pork [p=(unit @ta) q=(list @t)] :: fully parsed url - += purf (pair purl (unit @t)) :: url with fragment - += purl [p=hart q=pork r=quay] :: parsed url - += quay (list [p=@t q=@t]) :: parsed url query - ++ quer |-($@(~ [p=@t q=@t t=$])) :: query tree - += quri :: request-uri - $% [$& p=purl] :: absolute - [$| p=pork q=quay] :: relative + ++ mite (list @ta) :: mime type + ++ moth {p/meth q/math r/(unit octs)} :: http operation + ++ octs {p/@ud q/@t} :: octet-stream + ++ oryx @t :: CSRF secret + ++ pork {p/(unit @ta) q/(list @t)} :: fully parsed url + ++ purf (pair purl (unit @t)) :: url with fragment + ++ purl {p/hart q/pork r/quay} :: parsed url + ++ quay (list {p/@t q/@t}) :: parsed url query + ++ quer |-($@($~ {p/@t q/@t t/$})) :: query tree + ++ quri :: request-uri + $% {$& p/purl} :: absolute + {$| p/pork q/quay} :: relative == :: - += rout [p=(list host) q=path r=oryx s=path] :: http route (new) - += sec-move :: driver effect - $% [%send p=hiss] :: http out - [%show p=purl] :: direct user to url - [%give p=httr] :: respond immediately - [%redo ~] :: restart request qeu + ++ rout {p/(list host) q/path r/oryx s/path} :: http route (new) + ++ sec-move :: driver effect + $% {$send p/hiss} :: http out + {$show p/purl} :: direct user to url + {$give p/httr} :: respond immediately + {$redo $~} :: restart request qeu == :: -- ::eyre :: :::: @@ -747,83 +746,83 @@ :: :::: ++ able ^? |% - += gift :: out result <-$ - $% [%made p=@uvH q=gage] :: computed result - [%mass p=mass] :: memory usage - [%news p=@uvH] :: fresh depends + ++ gift :: out result <-$ + $% {$made p/@uvH q/gage} :: computed result + {$mass p/mass} :: memory usage + {$news p/@uvH} :: fresh depends == :: - += task :: in request ->$ - $% [%exec p=@p q=(unit bilk)] :: make = kill - [%wasp p=@p q=[@uvH ?]] :: depends ask = kill - [%wegh ~] :: report memory - [%wipe p=@p ~] :: clear cache + ++ task :: in request ->$ + $% {$exec p/@p q/(unit bilk)} :: make / kill + {$wasp p/@p q/{@uvH ?}} :: depends ask / kill + {$wegh $~} :: report memory + {$wipe p/@p $~} :: clear cache == :: -- ::able - += bilk (pair beak silk) :: sourced request - += gage :: recursive cage+tang - $% [$& p=cage] :: success - [$| p=tang] :: error - [%tabl p=(list (pair gage gage))] :: table of results + ++ bilk (pair beak silk) :: sourced request + ++ gage :: recursive cage+tang + $% {$& p/cage} :: success + {$| p/tang} :: error + {$tabl p/(list (pair gage gage))} :: table of results == :: - += hood :: assembly plan - $: zus=@ud :: zuse kelvin - sur=(list hoof) :: structures - lib=(list hoof) :: libraries - fan=(list horn) :: resources - src=(list hoop) :: program + ++ hood :: assembly plan + $: zus/@ud :: zuse kelvin + sur/(list hoof) :: structures + lib/(list hoof) :: libraries + fan/(list horn) :: resources + src/(list hoop) :: program == :: - += hoof (trel ? term (unit (pair case ship))) :: resource reference - += hoop :: source in hood - $% [$& p=twig] :: direct twig - [$| p=beam] :: resource location + ++ hoof (trel ? term (unit (pair case ship))) :: resource reference + ++ hoop :: source in hood + $% {$& p/twig} :: direct twig + {$| p/beam} :: resource location == :: - += hops :: XX late-bound path - $: pre=(unit tyke) :: - pof=(unit [p=@ud q=tyke]) :: + ++ hops :: XX late-bound path + $: pre/(unit tyke) :: + pof/(unit {p/@ud q/tyke}) :: == :: - += horn :: resource tree - $% [%ape p=twig] :: =~ twig by hand - [%arg p=twig] :: =$ argument - [%alt p=(list horn)] :: =| options - [%dep p=horn] :: =/ insert dephash - [%dub p=term q=horn] :: == apply face - [%fan p=(list horn)] :: =. list - [%for p=(list (pair spur horn))] :: =, switch by path - [%hel p=horn] :: =% propagate args - [%lin p=(list mark) q=horn] :: =& translates - [%man p=(map knot horn)] :: =* hetero map - [%nap p=horn] :: =_ homo map - [%now p=horn] :: deprecated - [%nod p=term q=horn] :: =_ @ list by odor - [%saw p=twig q=horn] :: =; operate on - [%see p=hops q=horn] :: =: relative to - [%sic p=twig q=horn] :: =^ cast - [%toy p=? q=mark] :: =mark= static=hook + ++ horn :: resource tree + $% {$ape p/twig} :: /~ twig by hand + {$arg p/twig} :: /$ argument + {$alt p/(list horn)} :: /| options + {$dep p/horn} :: /# insert dephash + {$dub p/term q/horn} :: /= apply face + {$fan p/(list horn)} :: /. list + {$for p/(list (pair spur horn))} :: /, switch by path + {$hel p/horn} :: /% propagate args + {$lin p/(list mark) q/horn} :: /& translates + {$man p/(map knot horn)} :: /* hetero map + {$nap p/horn} :: /_ homo map + {$now p/horn} :: deprecated + {$nod p/term q/horn} :: /_ @ list by odor + {$saw p/twig q/horn} :: /; operate on + {$see p/hops q/horn} :: /: relative to + {$sic p/twig q/horn} :: /^ cast + {$toy p/? q/mark} :: /mark/ static/hook == :: - += milk (trel ship desk silk) :: sourced silk - += silk :: construction layer - $^ [p=silk q=silk] :: cons - $% [$$ p=cage] :: literal - [%alts p=(list silk)] :: options - [%bake p=mark q=coin r=beam] :: local synthesis - [%bunt p=mark] :: example of mark - [%call p=silk q=silk] :: slam - [%cast p=mark q=silk] :: translate - [%core p=beam] :: build program - [%diff p=silk q=silk] :: diff - [%dude p=(trap tank) q=silk] :: error wrap - [%file p=beam] :: from clay - [%flag p=(set $@(@uvH beam)) q=silk] :: add dependencies - [%join p=mark q=silk r=silk] :: merge - [%mash p=mark q=milk r=milk] :: annotate - [%mute p=silk q=(list (pair wing silk))] :: mutant - [%pact p=silk q=silk] :: patch - [%plan p=beam q=coin r=hood] :: structured assembly - [%reef ~] :: kernel reef - [%ride p=twig q=silk] :: silk thru twig - [%tabl p=(list (pair silk silk))] :: list - [%vale p=mark q=*] :: validate - [%volt p=(cask *)] :: unsafe add type + ++ milk (trel ship desk silk) :: sourced silk + ++ silk :: construction layer + $^ {p/silk q/silk} :: cons + $% {$$ p/cage} :: literal + {$alts p/(list silk)} :: options + {$bake p/mark q/coin r/beam} :: local synthesis + {$bunt p/mark} :: example of mark + {$call p/silk q/silk} :: slam + {$cast p/mark q/silk} :: translate + {$core p/beam} :: build program + {$diff p/silk q/silk} :: diff + {$dude p/(trap tank) q/silk} :: error wrap + {$file p/beam} :: from clay + {$flag p/(set $@(@uvH beam)) q/silk} :: add dependencies + {$join p/mark q/silk r/silk} :: merge + {$mash p/mark q/milk r/milk} :: annotate + {$mute p/silk q/(list (pair wing silk))} :: mutant + {$pact p/silk q/silk} :: patch + {$plan p/beam q/coin r/hood} :: structured assembly + {$reef $~} :: kernel reef + {$ride p/twig q/silk} :: silk thru twig + {$tabl p/(list (pair silk silk))} :: list + {$vale p/mark q/*} :: validate + {$volt p/(cask *)} :: unsafe add type == :: -- ::ford :: :::: @@ -836,68 +835,68 @@ :: :::: ++ able ^? |% - += gift :: outgoing result - $% [%mass p=mass] :: memory usage - [%onto p=(each suss tang)] :: about agent - [%rend p=path q=*] :: network request - [%unto p=cuft] :: - [%mack p=(unit tang)] :: message ack + ++ gift :: outgoing result + $% {$mass p/mass} :: memory usage + {$onto p/(each suss tang)} :: about agent + {$rend p/path q/*} :: network request + {$unto p/cuft} :: + {$mack p/(unit tang)} :: message ack == :: - += task :: incoming request - $% [%conf p=dock q=culm] :: configure app - [%init p=ship] :: set owner - [%deal p=sock q=cush] :: full transmission - [%went p=sack q=path r=@ud s=coop] :: response confirm - [%west p=sack q=path r=*] :: network request - [%wegh ~] :: report memory + ++ task :: incoming request + $% {$conf p/dock q/culm} :: configure app + {$init p/ship} :: set owner + {$deal p/sock q/cush} :: full transmission + {$went p/sack q/path r/@ud s/coop} :: response confirm + {$west p/sack q/path r/*} :: network request + {$wegh $~} :: report memory == :: -- ::able - += bitt (map bone (pair ship path)) :: incoming subs - += boat :: outgoing subs + ++ bitt (map bone (pair ship path)) :: incoming subs + ++ boat :: outgoing subs %+ map (pair bone wire) :: (trel bean ship path) :: - += bowl :: standard app state - $: $: our=ship :: host - src=ship :: guest - dap=term :: agent + ++ bowl :: standard app state + $: $: our/ship :: host + src/ship :: guest + dap/term :: agent == :: - $: wex=boat :: outgoing subs - sup=bitt :: incoming subs + $: wex/boat :: outgoing subs + sup/bitt :: incoming subs == :: - $: ost=bone :: opaque cause - act=@ud :: change number - eny=@uvJ :: entropy - now=@da :: current time - byk=beak :: load source + $: ost/bone :: opaque cause + act/@ud :: change number + eny/@uvJ :: entropy + now/@da :: current time + byk/beak :: load source == == :: - += club :: agent action - $% [%peel p=mark q=path] :: translated peer - [%peer p=path] :: subscribe - [%poke p=cage] :: apply - [%puff p=mark q=noun] :: unchecked poke - [%pull ~] :: unsubscribe - [%punk p=mark q=cage] :: translated poke - [%pump ~] :: pump yes+no - [%peer-not p=tang] :: poison pill peer + ++ club :: agent action + $% {$peel p/mark q/path} :: translated peer + {$peer p/path} :: subscribe + {$poke p/cage} :: apply + {$puff p/mark q/noun} :: unchecked poke + {$pull $~} :: unsubscribe + {$punk p/mark q/cage} :: translated poke + {$pump $~} :: pump yes+no + {$peer-not p/tang} :: poison pill peer == :: - += cuft :: internal gift - $% [%coup p=(unit tang)] :: poke result - [%diff p=cage] :: subscription output - [%quit ~] :: close subscription - [%reap p=(unit tang)] :: peer result + ++ cuft :: internal gift + $% {$coup p/(unit tang)} :: poke result + {$diff p/cage} :: subscription output + {$quit $~} :: close subscription + {$reap p/(unit tang)} :: peer result == :: - += culm :: config action - $% [%load p=scup] :: load+reload - :: [%kick ~] :: restart everything - :: [%stop ~] :: toggle suspend - :: [%wipe ~] :: destroy all state + ++ culm :: config action + $% {$load p/scup} :: load+reload + :: {$kick $~} :: restart everything + :: {$stop $~} :: toggle suspend + :: {$wipe $~} :: destroy all state == :: - += cush (pair term club) :: internal task - += dude term :: server identity - += gill (pair ship term) :: general contact - += scup (pair ship desk) :: autoupdate - += suss (trel dude @tas @da) :: config report - += well (pair desk term) :: + ++ cush (pair term club) :: internal task + ++ dude term :: server identity + ++ gill (pair ship term) :: general contact + ++ scup (pair ship desk) :: autoupdate + ++ suss (trel dude @tas @da) :: config report + ++ well (pair desk term) :: -- ::gall :: :::: :::: ++jael :: (1h) security @@ -930,111 +929,111 @@ :: %jael only talks to %ames and %behn. we send messages :: through %ames and use %behn timers. :: - += action :: balance change + ++ action :: balance change %+ pair ship :: partner - %+ each bump :: &=liability change - bump :: |=asset change + %+ each bump :: &/liability change + bump :: |/asset change :: :: - += balance :: balance sheet + ++ balance :: balance sheet %+ pair :: (map ship safe) :: liabilities (map ship safe) :: assets :: :: - += change :: urbit change - $% $: %fact :: certificate change - rex=ship :: owner - vie=(unit (unit ship)) :: made=heard from - lyf=life :: deed added=modified - gan=growth :: info gained + ++ change :: urbit change + $% $: $fact :: certificate change + rex/ship :: owner + vie/(unit (unit ship)) :: made/heard from + lyf/life :: deed added/modified + gan/growth :: info gained == :: - $: %rite :: rights change - rex=ship :: issuer - pal=ship :: issued to - del=bump :: change + $: $rite :: rights change + rex/ship :: issuer + pal/ship :: issued to + del/bump :: change == == :: :: :: - += channel :: secure channel - $: out=(unit (pair hand bill)) :: outbound key - inn=(map hand bill) :: inbound keys - cur=(unit life) :: their version - sax=(list ship) :: their ancestry - pub=will :: their public keys + ++ channel :: secure channel + $: out/(unit (pair hand bill)) :: outbound key + inn/(map hand bill) :: inbound keys + cur/(unit life) :: their version + sax/(list ship) :: their ancestry + pub/will :: their public keys == :: - += gift :: out result <-$ - $? [%veil p=channel] :: secure channel - [%vest p=tally] :: balance update - [%vein p=life q=(map life ring)] :: private keys - [%vine p=(list change)] :: all raw changes + ++ gift :: out result <-$ + $? {$veil p/channel} :: secure channel + {$vest p/tally} :: balance update + {$vein p/life q/(map life ring)} :: private keys + {$vine p/(list change)} :: all raw changes == :: - += growth :: unit of learning - $% [%sign p=mind q=@] :: add=update signature - [%step p=cert] :: add whole deed + ++ growth :: unit of learning + $% {$sign p/mind q/@} :: add/update signature + {$step p/cert} :: add whole deed == :: - += note :: out request $-> - $% [%b %wait p=@da] :: wait until - [%x %mess p=ship q=path r=*] :: send message + ++ note :: out request $-> + $% {$b $wait p/@da} :: wait until + {$x $mess p/ship q/path r/*} :: send message == :: - += remote :: remote notification - %+ each safe :: &=addition - safe :: |=replacement + ++ remote :: remote notification + %+ each safe :: &/addition + safe :: |/replacement :: :: - += sign :: in result $<- - $% [%b %wake ~] :: wakeup - [%x %rest p=coop] :: message result + ++ sign :: in result $<- + $% {$b $wake $~} :: wakeup + {$x $rest p/coop} :: message result == :: - += tally :: balance update + ++ tally :: balance update %+ each balance :: complete action :: change :: - += task :: in request ->$ - $% [%ktsg p=ship q=safe] :: destroy rights - [%hail p=ship q=remote] :: remote update - [%init p=@pG q=arms] :: initialize urbit - [%meet p=(unit (unit ship)) q=farm] :: integrate pki from - [%mint p=ship q=safe] :: create rights - [%move p=ship q=ship r=safe] :: transfer from=to - [%next p=bull] :: update private key - [%nuke ~] :: cancel tracker from - [%veil p=ship] :: view secret channel - [%vein ~] :: view signing keys - [%vest ~] :: view public balance - [%vine ~] :: view secret history - [%jaelwomb p=task:womb] :: XX not factored in - [%west p=ship q=path r=*] :: remote request + ++ task :: in request ->$ + $% {$ktsg p/ship q/safe} :: destroy rights + {$hail p/ship q/remote} :: remote update + {$init p/@pG q/arms} :: initialize urbit + {$meet p/(unit (unit ship)) q/farm} :: integrate pki from + {$mint p/ship q/safe} :: create rights + {$move p/ship q/ship r/safe} :: transfer from/to + {$next p/bull} :: update private key + {$nuke $~} :: cancel tracker from + {$veil p/ship} :: view secret channel + {$vein $~} :: view signing keys + {$vest $~} :: view public balance + {$vine $~} :: view secret history + {$jaelwomb p/task:womb} :: XX not factored in + {$west p/ship q/path r/*} :: remote request == :: - += gilt gilt:womb + ++ gilt gilt:womb -- :: ++ womb ^? - :: types used to serve the lib=womb invite controller + :: types used to serve the lib/womb invite controller |% - += ticket @G :: old 64-bit ticket - += passcode @uvH :: 128-bit passcode - += passhash @uwH :: passocde hash - += mail @t :: email address - += invite :: - $: who=mail :: owner email - pla=@ud :: planets to send - sta=@ud :: stars to send + ++ ticket @G :: old 64-bit ticket + ++ passcode @uvH :: 128-bit passcode + ++ passhash @uwH :: passocde hash + ++ mail @t :: email address + ++ invite :: + $: who/mail :: owner email + pla/@ud :: planets to send + sta/@ud :: stars to send == :: :: :: - += reinvite [tid=passcode inv=invite] :: new from old - += task :: manage ship %fungi - $% [%claim aut=passcode her=@p tik=ticket] :: convert to %final - [%bonus tid=passcode pla=@ud sta=@ud] :: supplement passcode - [%invite tid=passcode inv=invite] :: alloc to passcode - [%reinvite aut=passcode reinvite] :: move to another + ++ reinvite {tid/passcode inv/invite} :: new from old + ++ task :: manage ship %fungi + $% {$claim aut/passcode her/@p tik/ticket} :: convert to %final + {$bonus tid/passcode pla/@ud sta/@ud} :: supplement passcode + {$invite tid/passcode inv/invite} :: alloc to passcode + {$reinvite aut/passcode reinvite} :: move to another == :: - += scry :: - $% [%shop typ=?(%star %planet) nth=@u] :: available ships - [%stats who=ship] :: ship details - [%balance aut=passcode] :: invite details + ++ scry :: + $% {$shop typ/?($star $planet) nth/@u} :: available ships + {$stats who/ship} :: ship details + {$balance aut/passcode} :: invite details == :: - += balance [who=mail pla=@ud sta=@ud] :: XX same as invite? - += gilt :: - $% [%ships (list ship)] :: - [%womb-owner (unit mail)] :: - [%womb-balance (unit balance)] :: + ++ balance {who/mail pla/@ud sta/@ud} :: XX same as invite? + ++ gilt :: + $% {$ships (list ship)} :: + {$womb-owner (unit mail)} :: + {$womb-balance (unit balance)} :: == -- :: :: @@ -1054,35 +1053,35 @@ :: bit is set, the new life of this ship may have :: lost information that the old life had. :: - += arms (map chip (pair @ta @t)) :: stated identity - += bull :: cert metadata - $: dad=ship :: parent - dob=? :: & clean, | dirty - nym=arms :: identity strings + ++ arms (map chip (pair @ta @t)) :: stated identity + ++ bull :: cert metadata + $: dad/ship :: parent + dob/? :: & clean, | dirty + nym/arms :: identity strings == :: - += cert (tale deed) :: signed deed - += chip :: standard identity - $? %giv :: given name - %sur :: surname - %had :: fictitious name - %mid :: middle name + ++ cert (tale deed) :: signed deed + ++ chip :: standard identity + $? $giv :: given name + $sur :: surname + $had :: fictitious name + $mid :: middle name == :: - += deed :: certificate deed - $: doc=bull :: metadata - pub=pass :: public key + ++ deed :: certificate deed + $: doc/bull :: metadata + pub/pass :: public key == :: - += farm (map ship will) :: pki dump set - += hand @uvH :: 128-bit hash - += life @ud :: ship version - += mind [who=ship lyf=life] :: key identifier - += name (pair @ta @t) :: ascii = unicode - += oath @ :: signature + ++ farm (map ship will) :: pki dump set + ++ hand @uvH :: 128-bit hash + ++ life @ud :: ship version + ++ mind {who/ship lyf/life} :: key identifier + ++ name (pair @ta @t) :: ascii / unicode + ++ oath @ :: signature ++ tale :: urbit-signed * - |* typ=mold :: payload mold - $: dat=typ :: data - syg=(map ship (pair life oath)) :: signatures + |* typ/mold :: payload mold + $: dat/typ :: data + syg/(map ship (pair life oath)) :: signatures == :: - += will (map life cert) :: meta-certificate + ++ will (map life cert) :: meta-certificate -- :: pki :: :: :::: ++rights:jael :: (1h3) claims @@ -1103,13 +1102,13 @@ :: %apple: application secret for a web api. :: %block: the promisee is banned. :: %email: email tied to promissee's ship. - :: %final: ship=ticket pair, ready to launch. + :: %final: ship/ticket pair, ready to launch. :: %fungi: fungible, countable asset. :: %guest: permission to adopt foreign child. :: %hotel: block of unissued children. :: %jewel: urbit private keys. :: %login: user's login passcode. - :: %pword: password for a website=api. + :: %pword: password for a website/api. :: %token: user access token for a web api. :: %urban: symmetric key for urbit networking. :: @@ -1119,29 +1118,29 @@ :: :: you can think of [our her rite] as an rdf triple. :: - += bill (pair @da @) :: expiring value - += bump :: rights change - $: mor=safe :: add rights - les=safe :: lose rights + ++ bill (pair @da @) :: expiring value + ++ bump :: rights change + $: mor/safe :: add rights + les/safe :: lose rights == :: - += dorm (pair ship bloq) :: issuing group - += pile (tree (pair @ @)) :: efficient ship set - += rite :: urbit commitment - $% [%apple p=(map site @)] :: web api key - [%block ~] :: banned - [%email p=(set @t)] :: email addresses - [%final p=@pG] :: recognize by ticket - [%fungi p=(map term @ud)] :: fungibles - [%guest ~] :: refugee visa - [%hotel p=(map dorm pile)] :: reserved block - [%jewel p=(map life ring)] :: private keyring - [%login p=(set @pG)] :: login secret - [%pword p=(map site (map @t @t))] :: web passwd by user - [%token p=(map site (map @t @t))] :: app tokens by user - [%urban p=(map hand bill)] :: urbit symmetric keys + ++ dorm (pair ship bloq) :: issuing group + ++ pile (tree (pair @ @)) :: efficient ship set + ++ rite :: urbit commitment + $% {$apple p/(map site @)} :: web api key + {$block $~} :: banned + {$email p/(set @t)} :: email addresses + {$final p/@pG} :: recognize by ticket + {$fungi p/(map term @ud)} :: fungibles + {$guest $~} :: refugee visa + {$hotel p/(map dorm pile)} :: reserved block + {$jewel p/(map life ring)} :: private keyring + {$login p/(set @pG)} :: login secret + {$pword p/(map site (map @t @t))} :: web passwd by user + {$token p/(map site (map @t @t))} :: app tokens by user + {$urban p/(map hand bill)} :: urbit symmetric keys == :: - += site (list @ta) :: [%com %yahoo %www ~] - += safe (tree rite) :: rights set + ++ site (list @ta) :: [%com %yahoo %www ~] + ++ safe (tree rite) :: rights set -- :: rights -- :: jael :: :::: @@ -1154,46 +1153,46 @@ |% ++ able ^? |% - += gift :: - $% [%east p=*] :: response message - [%home p=lane q=@] :: process forward - [%send p=lane q=@] :: send packet - [%rest p=coop] :: acknowledgment + ++ gift :: + $% {$east p/*} :: response message + {$home p/lane q/@} :: process forward + {$send p/lane q/@} :: send packet + {$rest p/coop} :: acknowledgment == :: - += task :: in request ->$ - $% [%hear p=lane q=@] :: - [%mess p=ship q=path r=*] :: send message - [%wake ~] :: + ++ task :: in request ->$ + $% {$hear p/lane q/@} :: + {$mess p/ship q/path r/*} :: send message + {$wake $~} :: == :: - += card :: out cards - $% [%west p=ship q=path r=*] :: network request + ++ card :: out cards + $% {$west p/ship q/path r/*} :: network request == :: - += sign :: in response $-< - $% [%g %rend p=path q=*] :: network request - [%g %mack p=(unit tang)] :: message ack + ++ sign :: in response $-< + $% {$g $rend p/path q/*} :: network request + {$g $mack p/(unit tang)} :: message ack == :: - += note :: out request $-> - $% [%c %west p=ship q=path r=*] :: to %clay - [%e %west p=ship q=path r=*] :: to %eyre - [%g %west p=ship q=path r=*] :: to %gall - $: %j :: to %jael - $% [%line p=ship q=@da r=code] :: - [%link p=ship q=@da r=code] :: - [%meet p=farm:pki:jael] :: - [%veil p=ship] :: - [%west p=ship q=path r=*] :: to %gall + ++ note :: out request $-> + $% {$c $west p/ship q/path r/*} :: to %clay + {$e $west p/ship q/path r/*} :: to %eyre + {$g $west p/ship q/path r/*} :: to %gall + $: $j :: to %jael + $% {$line p/ship q/@da r/code} :: + {$link p/ship q/@da r/code} :: + {$meet p/farm:pki:jael} :: + {$veil p/ship} :: + {$west p/ship q/path r/*} :: to %gall == == == :: -- :: able :: :::: :: (1i2) :: - += code @uvI :: symmetric key - += lane :: packet route - $% [%if p=@da q=@ud r=@if] :: IP4=public UDP=addr - [%is p=@ud q=(unit lane) r=@is] :: IPv6 w+alternates - [%ix p=@da q=@ud r=@if] :: IPv4 provisional + ++ code @uvI :: symmetric key + ++ lane :: packet route + $% {$if p/@da q/@ud r/@if} :: IP4/public UDP/addr + {$is p/@ud q/(unit lane) r/@is} :: IPv6 w+alternates + {$ix p/@da q/@ud r/@if} :: IPv4 provisional == :: - += life @ud :: regime number + ++ life @ud :: regime number -- ::xmas -- :: :: :: :: @@ -1207,41 +1206,41 @@ |% :: :: ++fu:number ++ fu :: modulo (mul p q) - |= a=[p=@ q=@] + |= a/{p/@ q/@} =+ b=?:(=([0 0] a) 0 (~(inv fo p.a) (~(sit fo p.a) q.a))) |% :: :: ++dif:fu:number ++ dif :: subtract - |= [c=[@ @] d=[@ @]] + |= {c/{@ @} d/{@ @}} [(~(dif fo p.a) -.c -.d) (~(dif fo q.a) +.c +.d)] :: :: ++exp:fu:number ++ exp :: exponent - |= [c=@ d=[@ @]] + |= {c/@ d/{@ @}} :- (~(exp fo p.a) (mod c (dec p.a)) -.d) (~(exp fo q.a) (mod c (dec q.a)) +.d) :: :: ++out:fu:number ++ out :: garner's formula - |= c=[@ @] + |= c/{@ @} %+ add +.c %+ mul q.a %+ ~(pro fo p.a) b (~(dif fo p.a) -.c (~(sit fo p.a) +.c)) :: :: ++pro:fu:number ++ pro :: multiply - |= [c=[@ @] d=[@ @]] + |= {c/{@ @} d/{@ @}} [(~(pro fo p.a) -.c -.d) (~(pro fo q.a) +.c +.d)] :: :: ++sum:fu:number ++ sum :: add - |= [c=[@ @] d=[@ @]] + |= {c/{@ @} d/{@ @}} [(~(sum fo p.a) -.c -.d) (~(sum fo q.a) +.c +.d)] :: :: ++sit:fu:number ++ sit :: represent - |= c=@ + |= c/@ [(mod c p.a) (mod c q.a)] -- ::fu :: :: ++pram:number ++ pram :: rabin-miller - |= a=@ ^- ? + |= a/@ ^- ? ?: ?| =(0 (end 0 1 a)) =(1 a) =+ b=1 @@ -1253,7 +1252,7 @@ | =+ ^= b =+ [s=(dec a) t=0] - |- ^- [s=@ t=@] + |- ^- {s/@ t/@} ?: =(0 (end 0 1 s)) $(s (rsh 0 1 s), t +(t)) [s t] @@ -1277,19 +1276,19 @@ == :: :: ++ramp:number ++ ramp :: make r-m prime - |= [a=@ b=(list @) c=@] ^- @ux :: [bits snags seed] + |= {a/@ b/(list @) c/@} ^- @ux :: {bits snags seed} => .(c (shas %ramp c)) =+ d=*@ |- ?: =((mul 100 a) d) ~|(%ar-ramp !!) =+ e=(~(raw og c) a) - ?: &((levy b |=(f=@ !=(1 (mod e f)))) (pram e)) + ?: &((levy b |=(f/@ !=(1 (mod e f)))) (pram e)) e $(c +(c), d (shax d)) :: :: ++curt:number ++ curt :: curve25519 - |= [a=@ b=@] + |= {a/@ b/@} => %= . + => + @@ -1299,20 +1298,20 @@ |% :: :: ++cla:curt:number ++ cla :: - |= raw=@ + |= raw/@ =+ low=(dis 248 (cut 3 [0 1] raw)) =+ hih=(con 64 (dis 127 (cut 3 [31 1] raw))) =+ mid=(cut 3 [1 30] raw) (can 3 [[1 low] [30 mid] [1 hih] ~]) :: :: ++sqr:curt:number ++ sqr :: - |=(a=@ (mul a a)) + |=(a/@ (mul a a)) :: :: ++inv:curt:number ++ inv :: - |=(a=@ (~(exp fo q) (sub q 2) a)) + |=(a/@ (~(exp fo q) (sub q 2) a)) :: :: ++cad:curt:number ++ cad :: - |= [n=[x=@ z=@] m=[x=@ z=@] d=[x=@ z=@]] + |= {n/{x/@ z/@} m/{x/@ z/@} d/{x/@ z/@}} =+ ^= xx ;: mul 4 z.d %- sqr %- abs:si @@ -1330,7 +1329,7 @@ [(sit.fq xx) (sit.fq zz)] :: :: ++cub:curt:number ++ cub :: - |= [x=@ z=@] + |= {x/@ z/@} =+ ^= xx %+ mul %- sqr %- abs:si @@ -1357,19 +1356,19 @@ $(i (dec i), r (cad r s one), s (cub s)) :: :: ++ga:number ++ ga :: GF (bex p.a) - |= a=[p=@ q=@ r=@] :: dim poly gen + |= a/{p/@ q/@ r/@} :: dim poly gen =+ si=(bex p.a) =+ ma=(dec si) => |% :: :: ++dif:ga:number ++ dif :: add and sub - |= [b=@ c=@] + |= {b/@ c/@} ~| [%dif-ga a] ?> &((lth b si) (lth c si)) (mix b c) :: :: ++dub:ga:number ++ dub :: mul by x - |= b=@ + |= b/@ ~| [%dub-ga a] ?> (lth b si) ?: =(1 (cut 0 [(dec p.a) 1] b)) @@ -1377,7 +1376,7 @@ (lsh 0 1 b) :: :: ++pro:ga:number ++ pro :: slow multiply - |= [b=@ c=@] + |= {b/@ c/@} ?: =(0 b) 0 ?: =(1 (dis 1 b)) @@ -1386,7 +1385,7 @@ :: :: ++toe:ga:number ++ toe :: exp+log tables =+ ^= nu - |= [b=@ c=@] + |= {b/@ c/@} ^- (map @ @) =+ d=*(map @ @) |- @@ -1398,7 +1397,7 @@ == =+ [p=(nu 0 (bex p.a)) q=(nu ma ma)] =+ [b=1 c=0] - |- ^- [p=(map @ @) q=(map @ @)] + |- ^- {p/(map @ @) q/(map @ @)} ?: =(ma c) [(~(put by p) c b) q] %= $ @@ -1409,18 +1408,18 @@ == :: :: ++sit:ga:number ++ sit :: reduce - |= b=@ + |= b/@ (mod b (bex p.a)) -- :: =+ toe |% :: :: ++fra:ga:number ++ fra :: divide - |= [b=@ c=@] + |= {b/@ c/@} (pro b (inv c)) :: :: ++inv:ga:number ++ inv :: invert - |= b=@ + |= b/@ ~| [%inv-ga a] =+ c=(~(get by q) b) ?~ c !! @@ -1428,7 +1427,7 @@ (need d) :: :: ++pow:ga:number ++ pow :: exponent - |= [b=@ c=@] + |= {b/@ c/@} =+ [d=1 e=c f=0] |- ?: =(p.a f) @@ -1438,7 +1437,7 @@ $(e (pro e e), f +(f)) :: :: ++pro:ga:number ++ pro :: multiply - |= [b=@ c=@] + |= {b/@ c/@} ~| [%pro-ga a] =+ d=(~(get by q) b) ?~ d 0 @@ -1463,16 +1462,16 @@ |% :: :: ++ahem:aes:crypto ++ ahem :: kernel state - |= [nnk=@ nnb=@ nnr=@] + |= {nnk/@ nnb/@ nnr/@} => =+ => [gr=(ga 8 0x11b 3) few==>(fe .(a 5))] [pro=pro.gr dif=dif.gr pow=pow.gr ror=ror.few] => |% :: ++ cipa $_ ^? :: AES params |% - ++ co *[p=@ q=@ r=@ s=@] :: column coefficients - ++ ix |~(a=@ *@) :: key index - ++ ro *[p=@ q=@ r=@ s=@] :: row shifts + ++ co *{p/@ q/@ r/@ s/@} :: column coefficients + ++ ix |~(a/@ *@) :: key index + ++ ro *{p/@ q/@ r/@ s/@} :: row shifts ++ su *@ :: s-box -- ::cipa -- :: @@ -1486,7 +1485,7 @@ [0x2 0x3 1 1] :: :: ++ix:pen:ahem:aes: ++ ix :: key index - |~(a=@ a) + |~(a/@ a) :: :: ++ro:pen:ahem:aes: ++ ro :: row shifts [0 1 2 3] @@ -1518,7 +1517,7 @@ [0xe 0xb 0xd 0x9] :: :: ++ix:pin:ahem:aes: ++ ix :: key index - |~(a=@ (sub nnr a)) + |~(a/@ (sub nnr a)) :: :: ++ro:pin:ahem:aes: ++ ro :: row shifts [0 3 2 1] @@ -1543,7 +1542,7 @@ -- :: :: ++mcol:ahem:aes: ++ mcol :: - |= [a=(list @) b=[p=@ q=@ r=@ s=@]] + |= {a/(list @) b/{p/@ q/@ r/@ s/@}} ^- (list @) =+ c=[p=*@ q=*@ r=*@ s=*@] |- ^- (list @) @@ -1561,11 +1560,11 @@ [[p.c r.b] [q.c s.b] [r.c p.b] [s.c q.b]] [[p.c q.b] [q.c r.b] [r.c s.b] [s.c p.b]] == - |= [a=[@ @] b=[@ @] c=[@ @] d=[@ @]] + |= {a/{@ @} b/{@ @} c/{@ @} d/{@ @}} :(dif (pro a) (pro b) (pro c) (pro d)) :: :: ++pode:ahem:aes: ++ pode :: explode to block - |= [a=bloq b=@ c=@] ^- (list @) + |= {a/bloq b/@ c/@} ^- (list @) =+ d=(rip a c) =+ m=(met a c) |- @@ -1574,13 +1573,13 @@ $(m +(m), d (weld d (limo [0 ~]))) :: :: ++sube:ahem:aes: ++ sube :: s-box word - |= [a=@ b=@] ^- @ - (rep 3 (turn (pode 3 4 a) |=(c=@ (cut 3 [c 1] b)))) + |= {a/@ b/@} ^- @ + (rep 3 (turn (pode 3 4 a) |=(c/@ (cut 3 [c 1] b)))) -- :: |% :: :: ++be:ahem:aes:crypto ++ be :: block cipher - |= [a=? b=@ c=@H] ^- @uxH + |= {a/? b/@ c/@H} ^- @uxH ~| %be-aesc => %= . + @@ -1588,18 +1587,18 @@ |% :: :: ++ankh:be:ahem:aes: ++ ankh :: - |= [a=cipa b=@ c=@] + |= {a/cipa b/@ c/@} (pode 5 nnb (cut 5 [(mul (ix.a b) nnb) nnb] c)) :: :: ++sark:be:ahem:aes: ++ sark :: - |= [c=(list @) d=(list @)] + |= {c/(list @) d/(list @)} ^- (list @) ?~ c ~ ?~ d !! [(mix i.c i.d) $(c t.c, d t.d)] :: :: ++srow:be:ahem:aes: ++ srow :: - |= [a=cipa b=(list @)] ^- (list @) + |= {a/cipa b/(list @)} ^- (list @) =+ [c=0 d=~ e=ro.a] |- ?: =(c nnb) @@ -1608,11 +1607,11 @@ %+ rep 3 %+ turn (limo [0 p.e] [1 q.e] [2 r.e] [3 s.e] ~) - |= [f=@ g=@] + |= {f/@ g/@} (cut 3 [f 1] (snag (mod (add g c) nnb) b)) :: :: ++subs:be:ahem:aes: ++ subs :: - |= [a=cipa b=(list @)] ^- (list @) + |= {a/cipa b/(list @)} ^- (list @) ?~ b ~ [(sube i.b su.a) $(b t.b)] -- @@ -1632,7 +1631,7 @@ (rep 5 e) :: :: ++ex:ahem:aes:crypto ++ ex :: key expand - |= a=@I ^- @ + |= a/@I ^- @ =+ [b=a c=0 d=su:pen i=nnk] |- ?: =(i (mul nnb +(nnr))) @@ -1650,7 +1649,7 @@ $(i +(i)) :: :: ++ix:ahem:aes:crypto ++ ix :: key expand, inv - |= a=@ ^- @ + |= a/@ ^- @ =+ [i=1 j=*@ b=*@ c=co:pin] |- ?: =(nnr i) @@ -1671,11 +1670,11 @@ :: :: ++ecba:aes:crypto ++ ecba :: AES-128 ECB ~% %ecba +> ~ - |_ key=@H + |_ key/@H :: :: ++en:ecba:aes:crypto ++ en :: encrypt - ~= %en - |= blk=@H ^- @uxH + ~/ %en + |= blk/@H ^- @uxH =+ (ahem 4 4 10) =: key (~(net fe 7) key) @@ -1685,8 +1684,8 @@ (be & (ex key) blk) :: :: ++de:ecba:aes:crypto ++ de :: decrypt - ~= %de - |= blk=@H ^- @uxH + ~/ %de + |= blk/@H ^- @uxH =+ (ahem 4 4 10) =: key (~(net fe 7) key) @@ -1698,11 +1697,11 @@ :: :: ++ecbb:aes:crypto ++ ecbb :: AES-192 ECB ~% %ecbb +> ~ - |_ key=@I + |_ key/@I :: :: ++en:ecbb:aes:crypto ++ en :: encrypt - ~= %en - |= blk=@H ^- @uxH + ~/ %en + |= blk/@H ^- @uxH =+ (ahem 6 4 12) =: key (rsh 6 1 (~(net fe 8) key)) @@ -1712,8 +1711,8 @@ (be & (ex key) blk) :: :: ++de:ecbb:aes:crypto ++ de :: decrypt - ~= %de - |= blk=@H ^- @uxH + ~/ %de + |= blk/@H ^- @uxH =+ (ahem 6 4 12) =: key (rsh 6 1 (~(net fe 8) key)) @@ -1725,11 +1724,11 @@ :: :: ++ecbc:aes:crypto ++ ecbc :: AES-256 ECB ~% %ecbc +> ~ - |_ key=@I + |_ key/@I :: :: ++en:ecbc:aes:crypto ++ en :: encrypt - ~= %en - |= blk=@H ^- @uxH + ~/ %en + |= blk/@H ^- @uxH =+ (ahem 8 4 14) =: key (~(net fe 8) key) @@ -1739,8 +1738,8 @@ (be & (ex key) blk) :: :: ++de:ecbc:aes:crypto ++ de :: decrypt - ~= %de - |= blk=@H ^- @uxH + ~/ %de + |= blk/@H ^- @uxH =+ (ahem 8 4 14) =: key (~(net fe 8) key) @@ -1752,13 +1751,13 @@ :: :: ++cbca:aes:crypto ++ cbca :: AES-128 CBC ~% %cbca +> ~ - |_ [key=@H prv=@H] + |_ {key/@H prv/@H} :: :: ++en:cbca:aes:crypto ++ en :: encrypt - ~= %en - |= txt=@ ^- @ux + ~/ %en + |= txt/@ ^- @ux =+ pts=?:(=(txt 0) `(list @)`~[0] (flop (rip 7 txt))) - =| cts=(list @) + =| cts/(list @) %+ rep 7 :: logically, flop twice here |- ^- (list @) @@ -1772,10 +1771,10 @@ == :: :: ++de:cbca:aes:crypto ++ de :: decrypt - ~= %de - |= txt=@ ^- @ux + ~/ %de + |= txt/@ ^- @ux =+ cts=?:(=(txt 0) `(list @)`~[0] (flop (rip 7 txt))) - =| pts=(list @) + =| pts/(list @) %+ rep 7 :: logically, flop twice here |- ^- (list @) @@ -1791,13 +1790,13 @@ :: :: ++cbcb:aes:crypto ++ cbcb :: AES-192 CBC ~% %cbcb +> ~ - |_ [key=@I prv=@H] + |_ {key/@I prv/@H} :: :: ++en:cbcb:aes:crypto ++ en :: encrypt - ~= %en - |= txt=@ ^- @ux + ~/ %en + |= txt/@ ^- @ux =+ pts=?:(=(txt 0) `(list @)`~[0] (flop (rip 7 txt))) - =| cts=(list @) + =| cts/(list @) %+ rep 7 :: logically, flop twice here |- ^- (list @) @@ -1811,10 +1810,10 @@ == :: :: ++de:cbcb:aes:crypto ++ de :: decrypt - ~= %de - |= txt=@ ^- @ux + ~/ %de + |= txt/@ ^- @ux =+ cts=?:(=(txt 0) `(list @)`~[0] (flop (rip 7 txt))) - =| pts=(list @) + =| pts/(list @) %+ rep 7 :: logically, flop twice here |- ^- (list @) @@ -1830,13 +1829,13 @@ :: :: ++cbcc:aes:crypto ++ cbcc :: AES-256 CBC ~% %cbcc +> ~ - |_ [key=@I prv=@H] + |_ {key/@I prv/@H} :: :: ++en:cbcc:aes:crypto ++ en :: encrypt - ~= %en - |= txt=@ ^- @ux + ~/ %en + |= txt/@ ^- @ux =+ pts=?:(=(txt 0) `(list @)`~[0] (flop (rip 7 txt))) - =| cts=(list @) + =| cts/(list @) %+ rep 7 :: logically, flop twice here |- ^- (list @) @@ -1850,10 +1849,10 @@ == :: :: ++de:cbcc:aes:crypto ++ de :: decrypt - ~= %de - |= txt=@ ^- @ux + ~/ %de + |= txt/@ ^- @ux =+ cts=?:(=(txt 0) `(list @)`~[0] (flop (rip 7 txt))) - =| pts=(list @) + =| pts/(list @) %+ rep 7 :: logically, flop twice here |- ^- (list @) @@ -1868,7 +1867,7 @@ -- ::cbcc :: :: ++inc:aes:crypto ++ inc :: inc. low bloq - |= [mod=bloq ctr=@H] + |= {mod/bloq ctr/@H} ^- @uxH =+ bqs=(rip mod ctr) ?~ bqs 0x1 @@ -1877,11 +1876,11 @@ :: :: ++ctra:aes:crypto ++ ctra :: AES-128 CTR ~% %ctra +> ~ - |_ [key=@H mod=bloq len=@ ctr=@H] + |_ {key/@H mod/bloq len/@ ctr/@H} :: :: ++en:ctra:aes:crypto ++ en :: encrypt - ~= %en - |= txt=@ + ~/ %en + |= txt/@ ^- @ux =/ encrypt ~(en ecba key) =/ blocks (add (div len 16) ?:(=((^mod len 16) 0) 0 1)) @@ -1901,11 +1900,11 @@ :: :: ++ctrb:aes:crypto ++ ctrb :: AES-192 CTR ~% %ctrb +> ~ - |_ [key=@I mod=bloq len=@ ctr=@H] + |_ {key/@I mod/bloq len/@ ctr/@H} :: :: ++en:ctrb:aes:crypto ++ en - ~= %en - |= txt=@ + ~/ %en + |= txt/@ ^- @ux =/ encrypt ~(en ecbb key) =/ blocks (add (div len 16) ?:(=((^mod len 16) 0) 0 1)) @@ -1925,11 +1924,11 @@ :: :: ++ctrc:aes:crypto ++ ctrc :: AES-256 CTR ~% %ctrc +> ~ - |_ [key=@I mod=bloq len=@ ctr=@H] + |_ {key/@I mod/bloq len/@ ctr/@H} :: :: ++en:ctrc:aes:crypto ++ en :: encrypt - ~= %en - |= txt=@ + ~/ %en + |= txt/@ ^- @ux =/ encrypt ~(en ecbc key) =/ blocks (add (div len 16) ?:(=((^mod len 16) 0) 0 1)) @@ -1950,7 +1949,7 @@ ++ doub :: double 128-bit |= :: string mod finite :: - str=@H + str/@H :: :: field (see spec) :: @@ -1961,7 +1960,7 @@ (mix 0x87 (lsh 0 1 str)) :: :: ++mpad:aes:crypto ++ mpad :: - |= [oct=@ txt=@] + |= {oct/@ txt/@} :: :: pad message to multiple of 128 bits :: by appending 1, then 0s @@ -1974,32 +1973,32 @@ (lsh 3 (sub 15 pad) (mix 0x80 (lsh 3 1 txt))) :: :: ++suba:aes:crypto ++ suba :: AES-128 subkeys - |= key=@H + |= key/@H =+ l=(~(en ecba key) 0) =+ k1=(doub l) =+ k2=(doub k1) - ^- [@ux @ux] + ^- {@ux @ux} [k1 k2] :: :: ++subb:aes:crypto ++ subb :: AES-192 subkeys - |= key=@I + |= key/@I =+ l=(~(en ecbb key) 0) =+ k1=(doub l) =+ k2=(doub k1) - ^- [@ux @ux] + ^- {@ux @ux} [k1 k2] :: :: ++subc:aes:crypto ++ subc :: AES-256 subkeys - |= key=@I + |= key/@I =+ l=(~(en ecbc key) 0) =+ k1=(doub l) =+ k2=(doub k1) - ^- [@ux @ux] + ^- {@ux @ux} [k1 k2] :: :: ++maca:aes:crypto ++ maca :: AES-128 CMAC - ~= %maca - |= [key=@H oct=(unit @) txt=@] + ~/ %maca + |= {key/@H oct/(unit @) txt/@} ^- @ux =+ [sub=(suba key) len=?~(oct (met 3 txt) u.oct)] =+ ^= pdt @@ -2018,8 +2017,8 @@ (~(sit fe 7) mac) :: :: ++macb:aes:crypto ++ macb :: AES-192 CMAC - ~= %macb - |= [key=@I oct=(unit @) txt=@] + ~/ %macb + |= {key/@I oct/(unit @) txt/@} ^- @ux =+ [sub=(subb key) len=?~(oct (met 3 txt) u.oct)] =+ ^= pdt @@ -2038,8 +2037,8 @@ (~(sit fe 7) mac) :: :: ++macc:aes:crypto ++ macc :: AES-256 CMAC - ~= %macc - |= [key=@I oct=(unit @) txt=@] + ~/ %macc + |= {key/@I oct/(unit @) txt/@} ^- @ux =+ [sub=(subc key) len=?~(oct (met 3 txt) u.oct)] =+ ^= pdt @@ -2058,8 +2057,8 @@ (~(sit fe 7) mac) :: :: ++s2va:aes:crypto ++ s2va :: AES-128 S2V - ~= %s2va - |= [key=@H ads=(list @)] + ~/ %s2va + |= {key/@H ads/(list @)} =+ res=(maca key `16 0x0) %^ maca key ~ |- ^- @uxH @@ -2078,8 +2077,8 @@ == :: :: ++s2vb:aes:crypto ++ s2vb :: AES-192 S2V - ~= %s2vb - |= [key=@I ads=(list @)] + ~/ %s2vb + |= {key/@I ads/(list @)} =+ res=(macb key `16 0x0) %^ macb key ~ |- ^- @uxH @@ -2098,8 +2097,8 @@ == :: :: ++s2vc:aes:crypto ++ s2vc :: AES-256 S2V - ~= %s2vc - |= [key=@I ads=(list @)] + ~/ %s2vc + |= {key/@I ads/(list @)} =+ res=(macc key `16 0x0) %^ macc key ~ |- ^- @uxH @@ -2119,11 +2118,11 @@ :: :: ++siva:aes:crypto ++ siva :: AES-128 SIV ~% %siva +> ~ - |_ [key=@I vec=(list @)] + |_ {key/@I vec/(list @)} :: :: ++en:siva:aes:crypto ++ en :: encrypt - ~= %en - |= txt=@ + ~/ %en + |= txt/@ ^- (trel @uxH @ud @ux) =+ [k1=(rsh 7 1 key) k2=(end 7 1 key)] =+ iv=(s2va k1 (weld vec (limo ~[txt]))) @@ -2135,8 +2134,8 @@ (~(en ctra k2 7 len hib) txt) :: :: ++de:siva:aes:crypto ++ de :: decrypt - ~= %de - |= [iv=@H len=@ txt=@] + ~/ %de + |= {iv/@H len/@ txt/@} ^- (unit @ux) =+ [k1=(rsh 7 1 key) k2=(end 7 1 key)] =* hib (dis iv 0xffff.ffff.ffff.ffff.7fff.ffff.7fff.ffff) @@ -2149,11 +2148,11 @@ :: :: ++sivb:aes:crypto ++ sivb :: AES-192 SIV ~% %sivb +> ~ - |_ [key=@J vec=(list @)] + |_ {key/@J vec/(list @)} :: :: ++en:sivb:aes:crypto ++ en :: encrypt - ~= %en - |= txt=@ + ~/ %en + |= txt/@ ^- (trel @uxH @ud @ux) =+ [k1=(rsh 5 3 key) k2=(end 5 3 key)] =+ iv=(s2vb k1 (weld vec (limo ~[txt]))) @@ -2164,8 +2163,8 @@ (~(en ctrb k2 7 len hib) txt) :: :: ++de:sivb:aes:crypto ++ de :: decrypt - ~= %de - |= [iv=@H len=@ txt=@] + ~/ %de + |= {iv/@H len/@ txt/@} ^- (unit @ux) =+ [k1=(rsh 5 3 key) k2=(end 5 3 key)] =* hib (dis iv 0xffff.ffff.ffff.ffff.7fff.ffff.7fff.ffff) @@ -2178,11 +2177,11 @@ :: :: ++sivc:aes:crypto ++ sivc :: AES-256 SIV ~% %sivc +> ~ - |_ [key=@J vec=(list @)] + |_ {key/@J vec/(list @)} :: :: ++en:sivc:aes:crypto ++ en :: encrypt - ~= %en - |= txt=@ + ~/ %en + |= txt/@ ^- (trel @uxH @ud @ux) =+ [k1=(rsh 8 1 key) k2=(end 8 1 key)] =+ iv=(s2vc k1 (weld vec (limo ~[txt]))) @@ -2194,8 +2193,8 @@ (~(en ctrc k2 7 len hib) txt) :: :: ++de:sivc:aes:crypto ++ de :: decrypt - ~= %de - |= [iv=@H len=@ txt=@] + ~/ %de + |= {iv/@H len/@ txt/@} ^- (unit @ux) =+ [k1=(rsh 8 1 key) k2=(end 8 1 key)] =* hib (dis iv 0xffff.ffff.ffff.ffff.7fff.ffff.7fff.ffff) @@ -2224,10 +2223,10 @@ |% :: :: ++norm:ed:crypto ++ norm :: - |=(x=@ ?:(=(0 (mod x 2)) x (sub q x))) + |=(x/@ ?:(=(0 (mod x 2)) x (sub q x))) :: :: ++xrec:ed:crypto ++ xrec :: recover x-coord - |= y=@ ^- @ + |= y/@ ^- @ =+ ^= xx %+ mul (dif.fq (mul y y) 1) (inv.fq +(:(mul d y y))) @@ -2237,7 +2236,7 @@ (norm x) :: :: ++ward:ed:crypto ++ ward :: edwards multiply - |= [pp=[@ @] qq=[@ @]] ^- [@ @] + |= {pp/{@ @} qq/{@ @}} ^- {@ @} =+ dp=:(pro.fq d -.pp -.qq +.pp +.qq) =+ ^= xt %+ pro.fq @@ -2254,7 +2253,7 @@ [xt yt] :: :: ++scam:ed:crypto ++ scam :: scalar multiply - |= [pp=[@ @] e=@] ^- [@ @] + |= {pp/{@ @} e/@} ^- {@ @} ?: =(0 e) [0 1] =+ qq=$(e (div e 2)) @@ -2264,11 +2263,11 @@ qq :: :: ++etch:ed:crypto ++ etch :: encode point - |= pp=[@ @] ^- @ + |= pp/{@ @} ^- @ (can 0 ~[[(sub b 1) +.pp] [1 (dis 1 -.pp)]]) :: :: ++curv:ed:crypto ++ curv :: point on curve? - |= [x=@ y=@] ^- ? + |= {x/@ y/@} ^- ? .= 0 %+ dif.fq %+ sum.fq @@ -2277,7 +2276,7 @@ (sum.fq 1 :(pro.fq d x x y y)) :: :: ++deco:ed:crypto ++ deco :: decode point - |= s=@ ^- (unit [@ @]) + |= s/@ ^- (unit {@ @}) =+ y=(cut 0 [0 (dec b)] s) =+ si=(cut 0 [(dec b) 1] s) =+ x=(xrec y) @@ -2295,8 +2294,8 @@ |% :: :: ++puck:ed:crypto ++ puck :: public key - ~= %puck - |= sk=@I ^- @ + ~/ %puck + |= sk/@I ^- @ ?: (gth (met 3 sk) 32) !! =+ h=(shal (rsh 0 3 b) sk) =+ ^= a @@ -2307,13 +2306,13 @@ (etch aa) :: :: ++suck:ed:crypto ++ suck :: keypair from seed - |= se=@I ^- @uJ + |= se/@I ^- @uJ =+ pu=(puck se) (can 0 ~[[b se] [b pu]]) :: :: ++shar:ed:crypto ++ shar :: curve25519 secret - ~= %shar - |= [pub=@ sek=@] + ~/ %shar + |= {pub/@ sek/@} ^- @ux =+ exp=(shal (rsh 0 3 b) (suck sek)) =. exp (dis exp (can 0 ~[[3 0] [251 (fil 0 251 1)]])) @@ -2323,8 +2322,8 @@ (curt prv crv) :: :: ++sign:ed:crypto ++ sign :: certify - ~= %sign - |= [m=@ se=@] ^- @ + ~/ %sign + |= {m/@ se/@} ^- @ =+ sk=(suck se) =+ pk=(cut 0 [b b] sk) =+ h=(shal (rsh 0 3 b) sk) @@ -2353,8 +2352,8 @@ (can 0 ~[[b (etch rr)] [b ss]]) :: :: ++veri:ed:crypto ++ veri :: validate - ~= %veri - |= [s=@ m=@ pk=@] ^- ? + ~/ %veri + |= {s/@ m/@ pk/@} ^- ? ?: (gth (div b 4) (met 3 s)) | ?: (gth (div b 8) (met 3 pk)) | =+ cb=(rsh 0 3 b) @@ -2369,7 +2368,7 @@ -- ::ed :: :: ++hmac:crypto ++ hmac :: HMAC-SHA1 - |= [key=@ mes=@] + |= {key/@ mes/@} =+ ip=(fil 3 64 0x36) =+ op=(fil 3 64 0x5c) =+ ^= kex @@ -2386,19 +2385,19 @@ |% :: :: ++sal:scr:crypto ++ sal :: salsa20 hash - |= [x=@ r=@] :: with r rounds + |= {x/@ r/@} :: with r rounds ?> =((mod r 2) 0) :: =+ few==>(fe .(a 5)) =+ ^= rot - |= [a=@ b=@] + |= {a/@ b/@} (mix (end 5 1 (lsh 0 a b)) (rsh 0 (sub 32 a) b)) =+ ^= lea - |= [a=@ b=@] + |= {a/@ b/@} (net:few (sum:few (net:few a) (net:few b))) => |% :: :: ++qr:sal:scr:crypto ++ qr :: quarterround - |= y=[@ @ @ @ ~] + |= y/{@ @ @ @ $~} =+ zb=(mix &2.y (rot 7 (sum:few &1.y &4.y))) =+ zc=(mix &3.y (rot 9 (sum:few zb &1.y))) =+ zd=(mix &4.y (rot 13 (sum:few zc zb))) @@ -2406,7 +2405,7 @@ ~[za zb zc zd] :: :: ++rr:sal:scr:crypto ++ rr :: rowround - |= [y=(list @)] + |= {y/(list @)} =+ za=(qr ~[&1.y &2.y &3.y &4.y]) =+ zb=(qr ~[&6.y &7.y &8.y &5.y]) =+ zc=(qr ~[&11.y &12.y &9.y &10.y]) @@ -2418,7 +2417,7 @@ &2.zd &3.zd &4.zd &1.zd == :: :: ++cr:sal:scr:crypto ++ cr :: columnround - |= [x=(list @)] + |= {x/(list @)} =+ ya=(qr ~[&1.x &5.x &9.x &13.x]) =+ yb=(qr ~[&6.x &10.x &14.x &2.x]) =+ yc=(qr ~[&11.x &15.x &3.x &7.x]) @@ -2430,11 +2429,11 @@ &4.ya &3.yb &2.yc &1.yd == :: :: ++dr:sal:scr:crypto ++ dr :: doubleround - |= [x=(list @)] + |= {x/(list @)} (rr (cr x)) :: :: ++al:sal:scr:crypto ++ al :: add two lists - |= [a=(list @) b=(list @)] + |= {a/(list @) b/(list @)} |- ^- (list @) ?~ a ~ ?~ b ~ [i=(sum:few -.a -.b) t=$(a +.a, b +.b)] @@ -2446,7 +2445,7 @@ (rep 5 (al xw ow)) :: :: ++rpp:scr:crypto ++ rpp :: rip+filler blocks - |= [a=bloq b=@ c=@] + |= {a/bloq b/@ c/@} =+ q=(rip a c) =+ w=(lent q) ?. =(w b) @@ -2455,23 +2454,23 @@ q :: :: ++bls:scr:crypto ++ bls :: split to sublists - |= [a=@ b=(list @)] + |= {a/@ b/(list @)} ?> =((mod (lent b) a) 0) |- ^- (list (list @)) ?~ b ~ [i=(scag a `(list @)`b) t=$(b (slag a `(list @)`b))] :: :: ++slb:scr:crypto ++ slb :: - |= [a=(list (list @))] + |= {a/(list (list @))} |- ^- (list @) ?~ a ~ (weld `(list @)`-.a $(a +.a)) :: :: ++sbm:scr:crypto ++ sbm :: scryptBlockMix - |= [r=@ b=(list @)] + |= {r/@ b/(list @)} ?> =((lent b) (mul 2 r)) =+ [x=(snag (dec (mul 2 r)) b) c=0] - =| [ya=(list @) yb=(list @)] + =| {ya/(list @) yb/(list @)} |- ^- (list @) ?~ b (flop (weld yb ya)) =. x (sal (mix x -.b) 8) @@ -2480,7 +2479,7 @@ $(c +(c), b +.b, yb [i=x t=yb]) :: :: ++srm:scr:crypto ++ srm :: scryptROMix - |= [r=@ b=(list @) n=@] + |= {r/@ b/(list @) n/@} ?> ?& =((lent b) (mul 2 r)) =(n (bex (dec (xeb n)))) (lth n (bex (mul r 16))) @@ -2502,11 +2501,11 @@ $(x (sbm r w), c +(c)) :: :: ++hmc:scr:crypto ++ hmc :: HMAC-SHA-256 - |= [k=@ t=@] + |= {k/@ t/@} (hml k (met 3 k) t (met 3 t)) :: :: ++hml:scr:crypto ++ hml :: w+length - |= [k=@ kl=@ t=@ tl=@] + |= {k/@ kl/@ t/@ tl/@} => .(k (end 3 kl k), t (end 3 tl t)) =+ b=64 =? k (gth kl b) (shay kl k) @@ -2516,13 +2515,13 @@ (add (lsh 3 b q) (mix k (fil 3 b 0x5c))) :: :: ++pbk:scr:crypto ++ pbk :: PBKDF2-HMAC-SHA256 - ~= %pbk - |= [p=@ s=@ c=@ d=@] + ~/ %pbk + |= {p/@ s/@ c/@ d/@} (pbl p (met 3 p) s (met 3 s) c d) :: :: ++pbl:scr:crypto ++ pbl :: w+length - ~= %pbl - |= [p=@ pl=@ s=@ sl=@ c=@ d=@] + ~/ %pbl + |= {p/@ pl/@ s/@ sl/@ c/@ d/@} => .(p (end 3 pl p), s (end 3 sl s)) =+ h=32 :: @@ -2549,14 +2548,14 @@ (end 3 d t) :: :: ++hsh:scr:crypto ++ hsh :: scrypt - ~= %hsh - |= [p=@ s=@ n=@ r=@ z=@ d=@] + ~/ %hsh + |= {p/@ s/@ n/@ r/@ z/@ d/@} (hsl p (met 3 p) s (met 3 s) n r z d) :: :: ++hsl:scr:crypto ++ hsl :: w+length - ~= %hsl - |= [p=@ pl=@ s=@ sl=@ n=@ r=@ z=@ d=@] - =| v=(list (list @)) + ~/ %hsl + |= {p/@ pl/@ s/@ sl/@ n/@ r/@ z/@ d/@} + =| v/(list (list @)) => .(p (end 3 pl p), s (end 3 sl s)) =+ u=(mul (mul 128 r) z) :: @@ -2572,17 +2571,17 @@ == =+ ^= b =+ (rpp 3 u (pbl p pl s sl 1 u)) %+ turn (bls (mul 128 r) -) - |=(a=(list @) (rpp 9 (mul 2 r) (rep 3 a))) + |=(a/(list @) (rpp 9 (mul 2 r) (rep 3 a))) ?> =((lent b) z) =+ ^= q =+ |- ?~ b (flop v) $(b +.b, v [i=(srm r -.b n) t=v]) %+ turn `(list (list @))`- - |=(a=(list @) (rpp 3 (mul 128 r) (rep 9 a))) + |=(a/(list @) (rpp 3 (mul 128 r) (rep 9 a))) (pbl p pl (rep 3 (slb q)) u 1 d) :: :: ++ypt:scr:crypto - ++ ypt :: 256bit [salt pass] - |= [s=@ p=@] + ++ ypt :: 256bit {salt pass} + |= {s/@ p/@} ^- @ (hsh p s 16.384 8 1 256) -- ::scr @@ -2591,27 +2590,27 @@ :: :::: ++ crub !: ^- acru - =| [pub=[cry=@ sgn=@] sek=(unit [cry=@ sgn=@])] + =| {pub/{cry/@ sgn/@} sek/(unit {cry/@ sgn/@})} |% :: :: ++as:crub:crypto ++ as :: |% :: :: ++sign:as:crub: ++ sign :: - |= [@ msg=@] + |= {@ msg/@} ^- @ux ?~ sek ~| %pubkey-only !! (jam [(sign:ed msg sgn.u.sek) msg]) :: :: ++sure:as:crub: ++ sure :: - |= [@ txt=@] + |= {@ txt/@} ^- (unit @ux) - =+ ((hard ,[sig=@ msg=@]) (cue txt)) + =+ ((hard {sig/@ msg/@}) (cue txt)) ?. (veri:ed sig msg sgn.pub) ~ (some msg) :: :: ++seal:as:crub: ++ seal :: - |= [bpk=pass m1=@ m2=@] + |= {bpk/pass m1/@ m2/@} ^- @ux ?~ sek ~| %pubkey-only !! ?> =('b' (end 3 1 bpk)) @@ -2622,13 +2621,13 @@ (jam (~(en siva:aes shar ~) smsg)) :: :: ++tear:as:crub: ++ tear :: - |= [bpk=pass txt=@] + |= {bpk/pass txt/@} ^- (unit (pair @ux @ux)) ?~ sek ~| %pubkey-only !! ?> =('b' (end 3 1 bpk)) =+ pk=(rsh 8 1 (rsh 3 1 bpk)) =+ shar=(shax (shar:ed pk cry.u.sek)) - =+ ((hard ,[iv=@ len=@ cph=@]) (cue txt)) + =+ ((hard {iv/@ len/@ cph/@}) (cue txt)) =+ try=(~(de siva:aes shar ~) iv len cph) ?~ try ~ =+ veri=(sure:as:(com:nu:crub bpk) ~ u.try) @@ -2637,20 +2636,20 @@ -- ::as :: :: ++de:crub:crypto ++ de :: decrypt - |= [key=@J txt=@] + |= {key/@J txt/@} ^- (unit @ux) - =+ ((hard ,[iv=@ len=@ cph=@]) (cue txt)) + =+ ((hard {iv/@ len/@ cph/@}) (cue txt)) %^ ~(de sivc:aes (shaz key) ~) iv len cph :: :: ++dy:crub:crypto ++ dy :: need decrypt - |= [key=@J cph=@] + |= {key/@J cph/@} (need (de key cph)) :: :: ++en:crub:crypto ++ en :: encrypt - |= [key=@J msg=@] + |= {key/@J msg/@} ^- @ux (jam (~(en sivc:aes (shaz key) ~) msg)) :: :: ++ex:crub:crypto @@ -2680,21 +2679,21 @@ |% :: :: ++pit:nu:crub:crypto ++ pit :: create keypair - |= [w=@ seed=@] + |= {w/@ seed/@} =+ wid=(add (div w 8) ?:(=((mod w 8) 0) 0 1)) =+ bits=(shal wid seed) =+ [c=(rsh 8 1 bits) s=(end 8 1 bits)] ..nu(pub [cry=(puck:ed c) sgn=(puck:ed s)], sek `[cry=c sgn=s]) :: :: ++nol:nu:crub:crypto ++ nol :: activate secret - |= a=ring + |= a/ring =+ [mag=(end 3 1 a) bod=(rsh 3 1 a)] ~| %not-crub-seckey ?> =('B' mag) =+ [c=(rsh 8 1 bod) s=(end 8 1 bod)] ..nu(pub [cry=(puck:ed c) sgn=(puck:ed s)], sek `[cry=c sgn=s]) :: :: ++com:nu:crub:crypto ++ com :: activate public - |= a=pass + |= a/pass =+ [mag=(end 3 1 a) bod=(rsh 3 1 a)] ~| %not-crub-pubkey ?> =('b' mag) ..nu(pub [cry=(rsh 8 1 bod) sgn=(end 8 1 bod)], sek ~) @@ -2705,21 +2704,21 @@ :: :::: ++ crua !: ^- acru - =| [mos=@ pon=(unit [p=@ q=@ r=[p=@ q=@] s=_*fu])] + =| {mos/@ pon/(unit {p/@ q/@ r/{p/@ q/@} s/_*fu})} => |% :: :: ++mx:crua:crypto ++ mx :: bit length (dec (met 0 mos)) :: :: ++dap:crua:crypto ++ dap :: OEAP decode - |= [wid=@ xar=@ dog=@] ^- [p=@ q=@] + |= {wid/@ xar/@ dog/@} ^- {p/@ q/@} =+ pav=(sub wid xar) =+ qoy=(cut 0 [xar pav] dog) =+ dez=(mix (end 0 xar dog) (shaw %pad-b xar qoy)) [dez (mix qoy (shaw %pad-a pav dez))] :: :: ++pad:crua:crypto ++ pad :: OEAP encode - |= [wid=@ rax=[p=@ q=@] meg=@] ^- @ + |= {wid/@ rax/{p/@ q/@} meg/@} ^- @ =+ pav=(sub wid p.rax) ?> (gte pav (met 0 meg)) ^- @ @@ -2728,18 +2727,18 @@ (can 0 [p.rax dez] [pav qoy] ~) :: :: ++pull:crua:crypto ++ pull :: - |=(a=@ (~(exp fo mos) 3 a)) + |=(a/@ (~(exp fo mos) 3 a)) :: :: ++push:crua:crypto ++ push :: - |=(a=@ (~(exp fo mos) 5 a)) + |=(a/@ (~(exp fo mos) 5 a)) :: :: ++pump:crua:crypto ++ pump :: - |= a=@ ^- @ + |= a/@ ^- @ ?~ pon !! (out.s.u.pon (exp.s.u.pon p.r.u.pon (sit.s.u.pon a))) :: :: ++punt:crua:crypto ++ punt :: - |= a=@ ^- @ + |= a/@ ^- @ ?~ pon !! (out.s.u.pon (exp.s.u.pon q.r.u.pon (sit.s.u.pon a))) -- :: @@ -2749,7 +2748,7 @@ => |% :: :: ++haul:as:crua: ++ haul :: - |= a=pass + |= a/pass =+ [mag=(end 3 1 a) bod=(rsh 3 1 a)] ?> =('a' mag) ..as(mos bod, pon ~) @@ -2758,14 +2757,14 @@ |% :: :: ++seal:as:crua: ++ seal :: - |= [a=pass b=@ c=@] + |= {a/pass b/@ c/@} ^- @ => .(c (sign b c)) =+ her=(haul a) =+ det=(lte (add 256 (met 0 c)) mx.her) =+ lip=?:(det c 0) =- (add ?:(p.mav 0 1) (lsh 0 1 q.mav)) - ^= mav ^- [p=? q=@] + ^= mav ^- {p/? q/@} :- det =+ dog=(pad mx.her [256 b] lip) =+ hog=(push.her dog) @@ -2773,9 +2772,9 @@ ?:(det hog (jam hog ben)) :: :: ++sign:as:crua: ++ sign :: - |= [a=@ b=@] ^- @ + |= {a/@ b/@} ^- @ =- (add ?:(p.mav 0 1) (lsh 0 1 q.mav)) - ^= mav ^- [p=? q=@] + ^= mav ^- {p/? q/@} =+ det=(lte (add 128 (met 0 b)) mx) :- det =+ hec=(shaf (mix %agis a) b) @@ -2784,21 +2783,21 @@ ?:(det hog (jam hog b)) :: :: ++sure:as:crua: ++ sure :: - |= [a=@ b=@] + |= {a/@ b/@} ^- (unit @) =+ [det==(0 (end 0 1 b)) bod=(rsh 0 1 b)] - =+ gox=?:(det [p=bod q=0] ((hard ,[p=@ q=@]) (cue bod))) + =+ gox=?:(det [p=bod q=0] ((hard {p/@ q/@}) (cue bod))) =+ dog=(pull p.gox) =+ pig=(dap mx 128 dog) =+ log=?:(det q.pig q.gox) ?.(=(p.pig (shaf (mix %agis a) log)) ~ [~ log]) :: :: ++tear:as:crua: ++ tear :: - |= [a=pass b=@] - ^- (unit [p=@ q=@]) + |= {a/pass b/@} + ^- (unit {p/@ q/@}) =+ her=(haul a) =+ [det==(0 (end 0 1 b)) bod=(rsh 0 1 b)] - =+ gox=?:(det [p=bod q=0] ((hard ,[p=@ q=@]) (cue bod))) + =+ gox=?:(det [p=bod q=0] ((hard {p/@ q/@}) (cue bod))) =+ dog=(punt p.gox) =+ pig=(dap mx 256 dog) =+ ^= cow @@ -2813,7 +2812,7 @@ -- ::as :: :: ++de:crua:crypto ++ de :: decrypt - |~ [key=@ cep=@] ^- (unit @) + |~ {key/@ cep/@} ^- (unit @) =+ toh=(met 8 cep) ?: (lth toh 2) ~ @@ -2825,10 +2824,10 @@ [~ msg] :: :: ++dy:crua:crypto ++ dy :: need decrypt - |~([a=@ b=@] (need (de a b))) + |~({a/@ b/@} (need (de a b))) :: :: ++en:crua:crypto ++ en :: encrypt - |~ [key=@ msg=@] ^- @ux + |~ {key/@ msg/@} ^- @ux =+ len=(met 8 msg) =+ adj=?:(=(0 len) 1 len) =+ hax=(shax (mix key (shax (mix adj msg)))) @@ -2855,36 +2854,36 @@ => |% :: :: ++elcm:nu:crua: ++ elcm :: - |= [a=@ b=@] + |= {a/@ b/@} (div (mul a b) d:(egcd a b)) :: :: ++eldm:nu:crua: ++ eldm :: - |= [a=@ b=@ c=@] + |= {a/@ b/@ c/@} (~(inv fo (elcm (dec b) (dec c))) a) :: :: ++ersa:nu:crua: ++ ersa :: - |= [a=@ b=@] + |= {a/@ b/@} [a b [(eldm 3 a b) (eldm 5 a b)] (fu a b)] -- :: ^? |% :: :: ++com:nu:crua:crypto ++ com :: - |= a=@ + |= a/@ ^+ ^?(..nu) ..nu(mos a, pon ~) :: :: ++pit:nu:crua:crypto ++ pit :: - |= [a=@ b=@] + |= {a/@ b/@} =+ c=(rsh 0 1 a) =+ [d=(ramp c [3 5 ~] b) e=(ramp c [3 5 ~] +(b))] ^+ ^?(..nu) ..nu(mos (mul d e), pon [~ (ersa d e)]) :: :: ++nol:nu:crua:crypto ++ nol :: - |= a=@ + |= a/@ ^+ ^?(..nu) - =+ b=((hard ,[p=@ q=@]) (cue a)) + =+ b=((hard {p/@ q/@}) (cue a)) ..nu(mos (mul p.b q.b), pon [~ (ersa p.b q.b)]) -- ::nu -- ::crua @@ -2895,7 +2894,7 @@ |% :: :: ++trub:test:crypto ++ trub :: test crub - |= msg=@t + |= msg/@t :: :: make acru cores :: @@ -2928,7 +2927,7 @@ |% :: :: ++drop-list:unity ++ drop-list :: collapse unit list - |* lut=(list (unit)) + |* lut/(list (unit)) ?. |- ^- ? ?~(lut & ?~(i.lut | $(lut t.lut))) ~ @@ -2938,13 +2937,13 @@ [i=u:+.i.lut t=$(lut t.lut)] :: :: ++drop-map:unity ++ drop-map :: collapse unit map - |* lum=(map term (unit)) - ?: (~(rep by lum) |=([[@ a=(unit)] b=_|] |(b ?=(~ a)))) + |* lum/(map term (unit)) + ?: (~(rep by lum) |=({{@ a/(unit)} b/_|} |(b ?=($~ a)))) ~ (some (~(run by lum) need)) :: :: ++drop-pole:unity ++ drop-pole :: unit tuple - |* but=(pole (unit)) + |* but/(pole (unit)) ?~ but !! ?~ +.but u:->.but @@ -2958,12 +2957,12 @@ :: :: ++to-wain:format ++ to-wain :: atom to line list ~% %lore ..is ~ - |= lub=@ - =| tez=(list @t) + |= lub/@ + =| tez/(list @t) |- ^+ tez =+ ^= wor =+ [meg=0 i=0] - |- ^- [meg=@ i=@ end=@f] + |- ^- {meg/@ i/@ end/@f} =+ gam=(cut 3 [i 1] lub) ?: =(0 gam) [meg i %.y] @@ -2976,8 +2975,8 @@ $(lub (rsh 3 +(i.wor) lub), tez [meg.wor tez]) :: :: ++of-wain:format ++ of-wain :: line list to atom - |= tez=(list @t) - =| [our=@ i=@ud] + |= tez/(list @t) + =| {our/@ i/@ud} |- ^- @ ?~ tez our @@ -2988,57 +2987,57 @@ $(i +(i), tez t.tez, our (cat 3 (cat 3 our 10) i.tez)) :: :: ++of-wall:format ++ of-wall :: line list to tape - |= a=wall ^- tape - ?~(a ~ "[i.a]\0a[$(a t.a)]") + |= a/wall ^- tape + ?~(a ~ "{i.a}\0a{$(a t.a)}") :: :: ++en-beam:format ++ en-beam :: beam to path - |= bem=beam + |= bem/beam ^- path [(scot %p p.bem) q.bem (scot r.bem) (flop s.bem)] :: :: ++de-beam:format ++ de-beam :: parse path to beam - |= pax=path + |= pax/path ^- (unit beam) - ?. ?=([* * * *] pax) ~ + ?. ?=({* * * *} pax) ~ %+ biff (slaw %p i.pax) - |= who=ship + |= who/ship %+ biff (slaw %tas i.t.pax) - |= dex=desk + |= dex/desk %+ biff (slay i.t.t.pax) - |= cis=coin - ?. ?=([$$ case] cis) ~ + |= cis/coin + ?. ?=({$$ case} cis) ~ `(unit beam)`[~ [who dex `case`p.cis] (flop t.t.t.pax)] :: :: ++enjs:format ++ enjs ^? :: json encoders |% :: :: ++frond:enjs:format ++ frond :: object from k-v pair - |= [p=@t q=json] + |= {p/@t q/json} ^- json [%o [[p q] ~ ~]] :: :: ++pairs:enjs:format ++ pairs :: object from k-v list - |= a=(list [p=@t q=json]) + |= a/(list {p/@t q/json}) ^- json [%o (~(gas by *(map @t json)) a)] :: :: ++tape:enjs:format ++ tape :: string from tape - |= a=^tape + |= a/^tape ^- json [%s (crip a)] :: :: ++wall:enjs:format ++ wall :: string from wall - |= a=^wall + |= a/^wall ^- json (tape (of-wall a)) :: :: ++ship:enjs:format ++ ship :: string from ship - |= a=^ship + |= a/^ship ^- json (tape (slag 1 (scow %p a))) :: :: ++numb:enjs:format ++ numb :: number from unsigned - |= a=@u + |= a/@u ^- json :- %n ?: =(0 a) '0' @@ -3048,7 +3047,7 @@ ?:(=(0 a) ~ [(add '0' (mod a 10)) $(a (div a 10))]) :: :: ++time:enjs:format ++ time :: ms timestamp - |= a=^time + |= a/^time =- (numb (div (mul - 1.000) ~s1)) (add (div ~s1 2.000) (sub a ~1970.1.1)) -- ::enjs @@ -3060,78 +3059,78 @@ |% :: :: ++ar:dejs:format ++ ar :: array as list - |* wit=fist - |= jon=json ^- (list _(wit *json)) - ?> ?=([%a *] jon) + |* wit/fist + |= jon/json ^- (list _(wit *json)) + ?> ?=({$a *} jon) (turn p.jon wit) :: :: ++at:dejs:format ++ at :: array as tuple - |* wil=(pole fist) - |= jon=json - ?> ?=([%a *] jon) + |* wil/(pole fist) + |= jon/json + ?> ?=({$a *} jon) ((at-raw wil) p.jon) :: :: ++at-raw:dejs:format ++ at-raw :: array as tuple - |* wil=(pole fist) - |= jol=(list json) + |* wil/(pole fist) + |= jol/(list json) ?~ jol !! ?- wil :: mint-vain on empty - :: [wit=* t=*] - [* t=*] + :: {wit/* t/*} + {* t/*} => .(wil [wit ~]=wil) ?~ t.wil ?^(t.jol !! (wit.wil i.jol)) [(wit.wil i.jol) ((at-raw t.wil) t.jol)] == :: :: ++bo:dejs:format ++ bo :: boolean - |=(jon=json ?>(?=([%b *] jon) p.jon)) + |=(jon/json ?>(?=({$b *} jon) p.jon)) :: :: ++bu:dejs:format ++ bu :: boolean not - |=(jon=json ?>(?=([%b *] jon) !p.jon)) + |=(jon/json ?>(?=({$b *} jon) !p.jon)) :: :: ++ci:dejs:format ++ ci :: maybe transform - |* [poq=gate wit=fist] - |= jon=json + |* {poq/gate wit/fist} + |= jon/json (need (poq (wit jon))) :: :: ++cu:dejs:format ++ cu :: transform - |* [poq=gate wit=fist] - |= jon=json + |* {poq/gate wit/fist} + |= jon/json (poq (wit jon)) :: :: ++di:dejs:format ++ di :: millisecond date %+ cu - |= a=@u ^- @da + |= a/@u ^- @da (add ~1970.1.1 (div (mul ~s1 a) 1.000)) ni :: :: ++mu:dejs:format ++ mu :: true unit - |* wit=fist - |= jon=json + |* wit/fist + |= jon/json ?~(jon ~ (some (wit jon))) :: :: ++ne:dejs:format ++ ne :: number as real - |= jon=json + |= jon/json ^- (unit @rd) :: please implement me, it's not that hard! !! :: :: ++ni:dejs:format ++ ni :: number as integer - |= jon=json - ?> ?=([%n *] jon) + |= jon/json + ?> ?=({$n *} jon) (rash p.jon dem) :: :: ++no:dejs:format ++ no :: number as cord - |=(jon=json ?>(?=([%n *] jon) p.jon)) + |=(jon/json ?>(?=({$n *} jon) p.jon)) :: :: ++of:dejs:format ++ of :: object as frond - |* wer=(pole [cord fist]) - |= jon=json - ?> ?=([%o [@ *] ~ ~] jon) + |* wer/(pole {cord fist}) + |= jon/json + ?> ?=({$o {@ *} $~ $~} jon) |- ?- wer :: mint-vain on empty - :: [[key=@t wit=*] t=*] - [[key=@t *] t=*] + :: {{key/@t wit/*} t/*} + {{key/@t *} t/*} => .(wer [[~ wit] ~]=wer) ?: =(key.wer p.n.p.jon) [key.wer ~|(key+key.wer (wit.wer q.n.p.jon))] @@ -3140,65 +3139,65 @@ == :: :: ++ot:dejs:format ++ ot :: object as tuple - |* wer=(pole [cord fist]) - |= jon=json - ?> ?=([%o *] jon) + |* wer/(pole {cord fist}) + |= jon/json + ?> ?=({$o *} jon) ((ot-raw wer) p.jon) :: :: ++ot-raw:dejs:format ++ ot-raw :: object as tuple - |* wer=(pole [cord fist]) - |= jom=(map @t json) + |* wer/(pole {cord fist}) + |= jom/(map @t json) ?- wer :: mint-vain on empty - :: [[key=@t wit=*] t=*] - [[key=@t *] t=*] + :: {{key/@t wit/*} t/*} + {{key/@t *} t/*} => .(wer [[~ wit] ~]=wer) =/ ten ~|(key+key.wer (wit.wer (~(got by jom) key.wer))) ?~(t.wer ten [ten ((ot-raw t.wer) jom)]) == :: :: ++om:dejs:format ++ om :: object as map - |* wit=fist - |= jon=json - ?> ?=([%o *] jon) + |* wit/fist + |= jon/json + ?> ?=({$o *} jon) (~(run by p.jon) wit) :: :: ++op:dejs:format ++ op :: parse keys of map - |* [fel=rule wit=fist] - |= jon=json ^- (map _(wonk *fel) _*wit) + |* {fel/rule wit/fist} + |= jon/json ^- (map _(wonk *fel) _*wit) =/ jom ((om wit) jon) %- malt %+ turn ~(tap by jom) - |* [a=cord b=*] + |* {a/cord b/*} => .(+< [a b]=+<) [(rash a fel) b] :: :: ++pe:dejs:format ++ pe :: prefix - |* [pre=* wit=fist] + |* {pre/* wit/fist} (cu |*(* [pre +<]) wit) :: :: ++sa:dejs:format ++ sa :: string as tape - |=(jon=json ?>(?=([%s *] jon) (trip p.jon))) + |=(jon/json ?>(?=({$s *} jon) (trip p.jon))) :: :: ++so:dejs:format ++ so :: string as cord - |=(jon=json ?>(?=([%s *] jon) p.jon)) + |=(jon/json ?>(?=({$s *} jon) p.jon)) :: :: ++su:dejs:format ++ su :: parse string - |* sab=rule - |= jon=json ^+ (wonk *sab) - ?> ?=([%s *] jon) + |* sab/rule + |= jon/json ^+ (wonk *sab) + ?> ?=({$s *} jon) (rash p.jon sab) :: :: ++ul:dejs:format ++ ul :: null - |=(jon=json ?~(jon ~ !!)) + |=(jon/json ?~(jon ~ !!)) :: ++ za :: full unit pole - |* pod=(pole (unit)) + |* pod/(pole (unit)) ?~ pod & ?~ -.pod | (za +.pod) :: ++ zl :: collapse unit list - |* lut=(list (unit)) + |* lut/(list (unit)) ?. |- ^- ? ?~(lut & ?~(i.lut | $(lut t.lut))) ~ @@ -3208,15 +3207,15 @@ [i=u:+.i.lut t=$(lut t.lut)] :: ++ zp :: unit tuple - |* but=(pole (unit)) + |* but/(pole (unit)) ?~ but !! ?~ +.but u:->.but [u:->.but (zp +.but)] :: ++ zm :: collapse unit map - |* lum=(map term (unit)) - ?: (~(rep by lum) |=([[@ a=(unit)] b=_|] |(b ?=(~ a)))) + |* lum/(map term (unit)) + ?: (~(rep by lum) |=({{@ a/(unit)} b/_|} |(b ?=($~ a)))) ~ (some (~(run by lum) need)) -- ::dejs @@ -3233,79 +3232,79 @@ :: |% ++ ar :: array as list - |* wit=fist - |= jon=json - ?. ?=([%a *] jon) ~ + |* wit/fist + |= jon/json + ?. ?=({$a *} jon) ~ %- zl |- ?~ p.jon ~ [i=(wit i.p.jon) t=$(p.jon t.p.jon)] :: ++ at :: array as tuple - |* wil=(pole fist) - |= jon=json - ?. ?=([%a *] jon) ~ + |* wil/(pole fist) + |= jon/json + ?. ?=({$a *} jon) ~ =+ raw=((at-raw wil) p.jon) ?.((za raw) ~ (some (zp raw))) :: ++ at-raw :: array as tuple - |* wil=(pole fist) - |= jol=(list json) + |* wil/(pole fist) + |= jol/(list json) ?~ wil ~ :- ?~(jol ~ (-.wil i.jol)) ((at-raw +.wil) ?~(jol ~ t.jol)) :: ++ bo :: boolean - |=(jon=json ?.(?=([%b *] jon) ~ [~ u=p.jon])) + |=(jon/json ?.(?=({$b *} jon) ~ [~ u=p.jon])) :: ++ bu :: boolean not - |=(jon=json ?.(?=([%b *] jon) ~ [~ u=!p.jon])) + |=(jon/json ?.(?=({$b *} jon) ~ [~ u=!p.jon])) :: ++ ci :: maybe transform - |* [poq=gate wit=fist] - |= jon=json + |* {poq/gate wit/fist} + |= jon/json (biff (wit jon) poq) :: ++ cu :: transform - |* [poq=gate wit=fist] - |= jon=json + |* {poq/gate wit/fist} + |= jon/json (bind (wit jon) poq) :: ++ da :: UTC date - |= jon=json - ?. ?=([%s *] jon) ~ - (bind (stud:chrono:userlib p.jon) |=(a=date (year a))) + |= jon/json + ?. ?=({$s *} jon) ~ + (bind (stud:chrono:userlib p.jon) |=(a/date (year a))) :: ++ di :: millisecond date %+ cu - |= a=@u ^- @da + |= a/@u ^- @da (add ~1970.1.1 (div (mul ~s1 a) 1.000)) ni :: ++ mu :: true unit - |* wit=fist - |= jon=json + |* wit/fist + |= jon/json ?~(jon (some ~) (bind (wit jon) some)) :: ++ ne :: number as real - |= jon=json + |= jon/json ^- (unit @rd) !! :: ++ ni :: number as integer - |= jon=json - ?. ?=([%n *] jon) ~ + |= jon/json + ?. ?=({$n *} jon) ~ (rush p.jon dem) :: ++ no :: number as cord - |= jon=json - ?. ?=([%n *] jon) ~ + |= jon/json + ?. ?=({$n *} jon) ~ (some p.jon) :: ++ of :: object as frond - |* wer=(pole [cord fist]) - |= jon=json - ?. ?=([%o [@ *] ~ ~] jon) ~ + |* wer/(pole {cord fist}) + |= jon/json + ?. ?=({$o {@ *} $~ $~} jon) ~ |- ?~ wer ~ ?: =(-.-.wer p.n.p.jon) @@ -3313,67 +3312,67 @@ ((of +.wer) jon) :: ++ ot :: object as tuple - |* wer=(pole [cord fist]) - |= jon=json - ?. ?=([%o *] jon) ~ + |* wer/(pole {cord fist}) + |= jon/json + ?. ?=({$o *} jon) ~ =+ raw=((ot-raw wer) p.jon) ?.((za raw) ~ (some (zp raw))) :: ++ ot-raw :: object as tuple - |* wer=(pole [cord fist]) - |= jom=(map @t json) + |* wer/(pole {cord fist}) + |= jom/(map @t json) ?~ wer ~ =+ ten=(~(get by jom) -.-.wer) [?~(ten ~ (+.-.wer u.ten)) ((ot-raw +.wer) jom)] :: ++ om :: object as map - |* wit=fist - |= jon=json - ?. ?=([%o *] jon) ~ + |* wit/fist + |= jon/json + ?. ?=({$o *} jon) ~ (zm (~(run by p.jon) wit)) :: ++ op :: parse keys of map - |* [fel=rule wit=fist] + |* {fel/rule wit/fist} %+ cu - |= a/(list (pair _(wonk *fel) _(need *wit))) + |= a/(list _[(wonk *fel) (need *wit)]) (my:nl a) %- ci :_ (om wit) - |= a=(map cord _(need *wit)) + |= a/(map cord _(need *wit)) ^- (unit (list _[(wonk *fel) (need *wit)])) %- zl %+ turn ~(tap by a) - |= [a=cord b=_(need *wit)] + |= {a/cord b/_(need *wit)} =+ nit=(rush a fel) ?~ nit ~ (some [u.nit b]) :: ++ pe :: prefix - |* [pre=* wit=fist] + |* {pre/* wit/fist} (cu |*(* [pre +<]) wit) :: ++ sa :: string as tape - |= jon=json - ?.(?=([%s *] jon) ~ (some (trip p.jon))) + |= jon/json + ?.(?=({$s *} jon) ~ (some (trip p.jon))) :: ++ so :: string as cord - |= jon=json - ?.(?=([%s *] jon) ~ (some p.jon)) + |= jon/json + ?.(?=({$s *} jon) ~ (some p.jon)) :: ++ su :: parse string - |* sab=rule - |= jon=json - ?. ?=([%s *] jon) ~ + |* sab/rule + |= jon/json + ?. ?=({$s *} jon) ~ (rush p.jon sab) :: - ++ ul |=(jon=json ?~(jon (some ~) ~)) :: null + ++ ul |=(jon/json ?~(jon (some ~) ~)) :: null ++ za :: full unit pole - |* pod=(pole (unit)) + |* pod/(pole (unit)) ?~ pod & ?~ -.pod | (za +.pod) :: ++ zl :: collapse unit list - |* lut=(list (unit)) + |* lut/(list (unit)) ?. |- ^- ? ?~(lut & ?~(i.lut | $(lut t.lut))) ~ @@ -3383,15 +3382,15 @@ [i=u:+.i.lut t=$(lut t.lut)] :: ++ zp :: unit tuple - |* but=(pole (unit)) + |* but/(pole (unit)) ?~ but !! ?~ +.but u:->.but [u:->.but (zp +.but)] :: ++ zm :: collapse unit map - |* lum=(map term (unit)) - ?: (~(rep by lum) |=([[@ a=(unit)] b=_|] |(b ?=(~ a)))) + |* lum/(map term (unit)) + ?: (~(rep by lum) |=({{@ a/(unit)} b/_|} |(b ?=($~ a)))) ~ (some (~(run by lum) need)) -- ::dejs-soft @@ -3405,7 +3404,7 @@ |% :: :: ++berk:differ ++ berk :: invert diff patch - |* bur=(urge) + |* bur/(urge) |- ^+ bur ?~ bur ~ :_ $(bur t.bur) @@ -3416,7 +3415,7 @@ :: :: ++loss:differ ++ loss :: longest subsequence ~% %loss ..is ~ - |* [hel=(list) hev=(list)] + |* {hel/(list) hev/(list)} |- ^+ hev =+ ^= sev =+ [inx=0 sev=*(map _i.-.hev (list @ud))] @@ -3428,7 +3427,7 @@ inx +(inx) sev (~(put by sev) i.hev [inx ?~(guy ~ u.guy)]) == - =| gox=[p=@ud q=(map @ud [p=@ud q=_hev])] + =| gox/{p/@ud q/(map @ud {p/@ud q/_hev})} =< abet =< main |% @@ -3439,19 +3438,19 @@ (flop q:(need (~(get by q.gox) (dec p.gox)))) :: :: ++hink:loss:differ ++ hink :: extend fits top - |= [inx=@ud goy=@ud] ^- ? + |= {inx/@ud goy/@ud} ^- ? ?| =(p.gox inx) (lth goy p:(need (~(get by q.gox) inx))) == :: :: ++lonk:loss:differ ++ lonk :: extend fits bottom - |= [inx=@ud goy=@ud] ^- ? + |= {inx/@ud goy/@ud} ^- ? ?| =(0 inx) (gth goy p:(need (~(get by q.gox) (dec inx)))) == :: :: ++luna:loss:differ ++ luna :: extend - |= [inx=@ud goy=@ud] + |= {inx/@ud goy/@ud} ^+ +> %_ +>.$ gox @@ -3463,12 +3462,12 @@ == :: :: ++merg:loss:differ ++ merg :: merge all matches - |= gay=(list @ud) + |= gay/(list @ud) ^+ +> =+ ^= zes - =+ [inx=0 zes=*(list [p=@ud q=@ud])] + =+ [inx=0 zes=*(list {p/@ud q/@ud})] |- ^+ zes - ?: |(?=(~ gay) (gth inx p.gox)) zes + ?: |(?=($~ gay) (gth inx p.gox)) zes ?. (lonk inx i.gay) $(gay t.gay) ?. (hink inx i.gay) $(inx +(inx)) $(inx +(inx), gay t.gay, zes [[inx i.gay] zes]) @@ -3484,7 +3483,7 @@ -- :: :: :: ++lurk:differ ++ lurk :: apply list patch - |* [hel=(list) rug=(urge)] + |* {hel/(list) rug/(urge)} ^+ hel =+ war=`_hel`~ |- ^+ hel @@ -3509,9 +3508,9 @@ == :: :: ++lusk:differ ++ lusk :: lcs to list patch - |* [hel=(list) hev=(list) lcs=(list)] + |* {hel/(list) hev/(list) lcs/(list)} =+ ^= rag - ^- [$%([$& p=@ud] [$| p=_lcs q=_lcs])] + ^- {$%({$& p/@ud} {$| p/_lcs q/_lcs})} [%& 0] => .(rag [p=rag q=*(list _rag)]) =< abet =< main @@ -3522,7 +3521,7 @@ (flop q.rag) :: :: ++done:lusk:differ ++ done :: - |= new=_p.rag + |= new/_p.rag ^+ rag ?- -.p.rag $| ?- -.new @@ -3539,7 +3538,7 @@ |- ^+ + ?~ hel ?~ hev - ?>(?=(~ lcs) +) + ?>(?=($~ lcs) +) $(hev t.hev, rag (done %| ~ [i.hev ~])) ?~ hev $(hel t.hel, rag (done %| [i.hel ~] ~)) @@ -3567,28 +3566,28 @@ |% :: :: ++as-octs:mimes:html ++ as-octs :: atom to octstream - |= tam=@ ^- octs + |= tam/@ ^- octs [(met 3 tam) tam] :: :: ++as-octt:mimes:html ++ as-octt :: tape to octstream - |= tep=tape ^- octs + |= tep/tape ^- octs (as-octs (rap 3 tep)) :: :: ++en-mite:mimes:html ++ en-mite :: mime type to text - |= myn=mite + |= myn/mite %- crip |- ^- tape ?~ myn ~ ?: =(~ t.myn) (trip i.myn) - (weld (trip i.myn) `tape`['=' $(myn t.myn)]) + (weld (trip i.myn) `tape`['/' $(myn t.myn)]) :: :: ++en-base64:mimes: ++ en-base64 :: encode base64 - |= tig=@ + |= tig/@ ^- tape =+ poc=(~(dif fo 3) 0 (met 3 tig)) =+ pad=(lsh 3 poc (swp 3 tig)) =+ ^= cha - 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+=' + 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' =+ ^= sif |- ^- tape ?~ pad @@ -3598,28 +3597,28 @@ (weld (flop (slag poc sif)) (reap poc '=')) :: :: ++de-base64:mimes: ++ de-base64 :: decode base64 - =- |=(a=cord (rash a fel)) - =< fel=(cook |~(a=@ `@t`(swp 3 a)) (bass 64 .)) + =- |=(a/cord (rash a fel)) + =< fel=(cook |~(a/@ `@t`(swp 3 a)) (bass 64 .)) =- (cook welp ;~(plug (plus siw) (stun 0^2 (cold %0 tis)))) ^= siw ;~ pose - (cook |=(a=@ (sub a 'A')) (shim 'A' 'Z')) - (cook |=(a=@ (sub a 'G')) (shim 'a' 'z')) - (cook |=(a=@ (add a 4)) (shim '0' '9')) + (cook |=(a/@ (sub a 'A')) (shim 'A' 'Z')) + (cook |=(a/@ (sub a 'G')) (shim 'a' 'z')) + (cook |=(a/@ (add a 4)) (shim '0' '9')) (cold 62 (just '+')) - (cold 63 (just '=')) + (cold 63 (just '/')) == -- ::mimes :: :: ++en-json:html ++ en-json :: print json - |^ |=(val=json (apex val "")) + |^ |=(val/json (apex val "")) :: :: ++apex:en-json:html ++ apex - |= [val=json rez=tape] + |= {val/json rez/tape} ^- tape ?~ val (weld "null" rez) ?- -.val - %a + $a :- '[' =. rez [']' rez] !. @@ -3628,9 +3627,9 @@ ?~ t.p.val ^$(val i.p.val) ^$(val i.p.val, rez [',' $(p.val t.p.val)]) :: - %b (weld ?:(p.val "true" "false") rez) - %n (weld (trip p.val) rez) - %s + $b (weld ?:(p.val "true" "false") rez) + $n (weld (trip p.val) rez) + $s :- '"' =. rez ['"' rez] =+ viz=(trip p.val) @@ -3638,13 +3637,13 @@ |- ^- tape ?~ viz rez =+ hed=(jesc i.viz) - ?: ?=([@ ~] hed) + ?: ?=({@ $~} hed) [i.hed $(viz t.viz)] (weld hed $(viz t.viz)) :: - %o - :- '[' - =. rez [']' rez] + $o + :- '{' + =. rez ['}' rez] =+ viz=~(tap by p.val) ?~ viz rez !. @@ -3655,8 +3654,8 @@ == :: :: ++jesc:en-json:html ++ jesc :: escaped - =+ utf=|=(a=@ ['\\' 'u' ((x-co 4):co a)]) - |= a=@ ^- tape + =+ utf=|=(a/@ ['\\' 'u' ((x-co 4):co a)]) + |= a/@ ^- tape ?+ a ?:((gth a 0x1f) [a ~] (utf a)) $10 "\\n" $34 "\\\"" @@ -3665,7 +3664,7 @@ -- ::en-json :: :: ++de-json:html ++ de-json :: parse JSON - =< |=(a=cord `(unit json)`(rush a apex)) + =< |=(a/cord `(unit json)`(rush a apex)) |% :: :: ++abox:de-json:html ++ abox :: array @@ -3679,7 +3678,7 @@ (cold ~ (jest 'null')) (stag %b bool) (stag %s stri) - (cook |=(s=tape [%n p=(rap 3 s)]) numb) + (cook |=(s/tape [%n p=(rap 3 s)]) numb) abox obox == @@ -3719,7 +3718,7 @@ ;~(pose ;~(less doq bas prn) esca) :: :: ++mayb:de-json:html ++ mayb :: optional - |*(bus=rule ;~(pose bus (easy ~))) + |*(bus/rule ;~(pose bus (easy ~))) :: :: ++numb:de-json:html ++ numb :: number ;~ (comp twel) @@ -3743,8 +3742,8 @@ ;~(plug ;~(sfix (wish stri) (wish col)) apex) :: :: ++piec:de-json:html ++ piec :: listify - |* bus=rule - (cook |=(a=@ [a ~]) bus) + |* bus/rule + (cook |=(a/@ [a ~]) bus) :: :: ++stri:de-json:html ++ stri :: string (cook crip (ifix [doq doq] (star jcha))) @@ -3756,20 +3755,20 @@ (star (mask [`@`9 `@`10 `@`13 ' ' ~])) :: :: ++twel:de-json:html ++ twel :: tape weld - |=([a=tape b=tape] (weld a b)) + |=({a/tape b/tape} (weld a b)) :: :: ++wish:de-json:html ++ wish :: with whitespace - |*(sef=rule ;~(pfix spac sef)) + |*(sef/rule ;~(pfix spac sef)) -- ::de-json :: :: ++en-xml:html ++ en-xml :: xml printer - =< |=(a=manx `tape`(apex a ~)) + =< |=(a/manx `tape`(apex a ~)) |_ _[unq=`?`| cot=`?`|] :: :: ++apex:en-xml:html ++ apex :: top level - |= [mex=manx rez=tape] + |= {mex/manx rez/tape} ^- tape - ?: ?=([$$ [[$$ *] ~]] g.mex) + ?: ?=({$$ {{$$ *} $~}} g.mex) (escp v.i.a.g.mex rez) =+ man=`mane`n.g.mex =. unq |(unq =(%script man) =(%style man)) @@ -3778,14 +3777,14 @@ :- '<' %+ welp tam =- ?~(att rez [' ' (attr att rez)]) - ^- rez=tape - ?: &(?=(~ c.mex) |(cot (clot man))) - [' ' '=' '>' rez] + ^- rez/tape + ?: &(?=($~ c.mex) |(cot (clot man))) + [' ' '/' '>' rez] :- '>' - (many c.mex :(weld "<=" tam ">" rez)) + (many c.mex :(weld "" rez)) :: :: ++attr:en-xml:html ++ attr :: attributes to tape - |= [tat=mart rez=tape] + |= {tat/mart rez/tape} ^- tape ?~ tat rez =. rez $(tat t.tat) @@ -3796,7 +3795,7 @@ == :: :: ++escp:en-xml:html ++ escp :: escape for xml - |= [tex=tape rez=tape] + |= {tex/tape rez/tape} ?: unq (weld tex rez) =+ xet=`tape`(flop tex) @@ -3816,13 +3815,13 @@ == :: :: ++many:en-xml:html ++ many :: nodelist to tape - |= [lix=(list manx) rez=tape] + |= {lix/(list manx) rez/tape} |- ^- tape ?~ lix rez (apex i.lix $(lix t.lix)) :: :: ++name:en-xml:html ++ name :: name to tape - |= man=mane ^- tape + |= man/mane ^- tape ?@ man (trip man) (weld (trip -.man) `tape`[':' (trip +.man)]) :: :: ++clot:en-xml:html @@ -3835,15 +3834,15 @@ -- ::en-xml :: :: ++de-xml:html ++ de-xml :: xml parser - =< |=(a=cord (rush a apex)) - |_ ent=_`(map term @t)`[[%apos '\''] ~ ~] + =< |=(a/cord (rush a apex)) + |_ ent/_`(map term @t)`[[%apos '\''] ~ ~] :: :: ++apex:de-xml:html ++ apex :: top level =+ spa=;~(pose comt whit) %+ knee *manx |. ~+ %+ ifix [(star spa) (star spa)] ;~ pose - %+ sear |=([a=marx b=marl c=mane] ?.(=(c n.a) ~ (some [a b]))) + %+ sear |=({a/marx b/marl c/mane} ?.(=(c n.a) ~ (some [a b]))) ;~(plug head many tail) empt == @@ -3861,7 +3860,7 @@ == :: :: ++chrd:de-xml:html ++ chrd :: character data - %+ cook |=(a=tape ^-(mars ;/(a))) + %+ cook |=(a/tape ^-(mars ;/(a))) (plus ;~(less doq ;~(pose (just `@`10) escp))) :: :: ++comt:de-xml:html ++ comt :: comments @@ -3881,14 +3880,14 @@ =+ def=^+(ent (my:nl [%gt '>'] [%lt '<'] [%amp '&'] [%quot '"'] ~)) %+ sear ~(get by (~(uni by def) ent)) (cook crip ;~(plug alf (stun 1^31 aln))) - %+ cook |=(a=@c ?:((gth a 0x10.ffff) '�' (tuft a))) + %+ cook |=(a/@c ?:((gth a 0x10.ffff) '�' (tuft a))) =< ;~(pfix hax ;~(pose - +)) :- (bass 10 (stun 1^8 dit)) (bass 16 ;~(pfix (mask "xX") (stun 1^8 hit))) == :: :: ++empt:de-xml:html ++ empt :: self-closing tag - %+ ifix [gal (jest '=>')] + %+ ifix [gal (jest '/>')] ;~(plug ;~(plug name attr) (cold ~ (star whit))) :: :: ++head:de-xml:html ++ head :: opening tag @@ -3907,19 +3906,19 @@ ;~(pose ;~(plug ;~(sfix chx col) chx) chx) :: :: ++tail:de-xml:html ++ tail :: closing tag - (ifix [(jest '<=') gar] name) + (ifix [(jest ' |=(a=@ ((sand %tas) (crip (flop (trip a))))) + =+ ^- raf/(like term) + => |=(a/@ ((sand %tas) (crip (flop (trip a))))) (;~(sfix (sear . sym) dot) [1^1 (flop (trip i.rax))]) ?~ q.raf [~ [i.rax ~]] - =+ `[ext=term [@ @] fyl=tape]`u.q.raf + =+ `{ext/term {@ @} fyl/tape}`u.q.raf :- `ext ?:(=(~ fyl) ~ [(crip (flop fyl)) ~]) :: :: ++apat:de-purl:html @@ -4025,12 +4024,12 @@ (ifix [fas ;~(pose fas (easy ~))] (more fas smeg)) :: :: ++aurf:de-purl:html ++ aurf :: 2396 with fragment - %+ cook |~(a=purf a) + %+ cook |~(a/purf a) ;~(plug auri (punt ;~(pfix hax (cook crip (star pque))))) :: :: ++auri:de-purl:html ++ auri :: 2396 URL %+ cook - |= a=purl + |= a/purl ?.(?=(hoke r.p.a) a a(p.p &)) ;~ plug ;~(plug htts thor) @@ -4039,8 +4038,8 @@ :: :: ++auru:de-purl:html ++ auru :: 2396 with maybe user %+ cook - |= $: a=[p=? q=(unit user) r=[(unit @ud) host]] - b=[pork quay] + |= $: a/{p/? q/(unit user) r/{(unit @ud) host}} + b/{pork quay} == ^- (pair (unit user) purl) [q.a [[p.a r.a] b]] @@ -4060,9 +4059,9 @@ :: :: ++dlab:de-purl:html ++ dlab :: 2396 domainlabel %+ sear - |= a=@ta + |= a/@ta ?.(=('-' (rsh 3 (dec (met 3 a)) a)) [~ u=a] ~) - %+ cook |=(a=tape (crip (cass a))) + %+ cook |=(a/tape (crip (cass a))) ;~(plug aln (star alp)) :: :: ++fque:de-purl:html ++ fque :: normal query field @@ -4105,7 +4104,7 @@ == :: :: ++scem:de-purl:html ++ scem :: 2396 scheme - %+ cook |=(a=tape (crip (cass a))) + %+ cook |=(a/tape (crip (cass a))) ;~(plug alf (star ;~(pose aln lus hep dot))) :: :: ++smeg:de-purl:html ++ smeg :: 2396 segment @@ -4121,7 +4120,7 @@ (cook crip (plus ptok)) :: :: ++thor:de-purl:html ++ thor :: 2396 host+port - %+ cook |*([* *] [+<+ +<-]) + %+ cook |*({* *} [+<+ +<-]) ;~ plug thos ;~((bend) (easy ~) ;~(pfix col dim:ag)) @@ -4132,7 +4131,7 @@ ;~ pose %+ stag %& %+ sear :: LL parser weak here - |= a=(list @t) + |= a/(list @t) =+ b=(flop a) ?> ?=(^ b) =+ c=(end 3 1 i.b) @@ -4163,20 +4162,20 @@ :: funky query :: %+ cook - |=(a=tape [[%$ (crip a)] ~]) + |=(a/tape [[%$ (crip a)] ~]) (star pque) == :: :: ++zest:de-purl:html ++ zest :: 2616 request-uri ;~ pose - (stag %& (cook |=(a=purl a) auri)) + (stag %& (cook |=(a/purl a) auri)) (stag %| ;~(plug apat yque)) == -- ::de-purl :: MOVEME :: :: ++fuel:html ++ fuel :: parse urbit fcgi - |= [bem=beam ced=noun:cred quy=quer] + |= {bem/beam ced/noun:cred quy/quer} ^- epic =+ qix=|-(`quay`?~(quy quy [[p q]:quy $(quy t.quy)])) [(malt qix) ((hard cred) ced) bem /] @@ -4188,21 +4187,21 @@ |% :: ++ auld :: ++auld:wired - |= sky=roof :: old style namespace + |= sky/roof :: old style namespace ^- slyt - |= [ref=* raw=*] + |= {ref/* raw/*} =+ pux=((soft path) raw) ?~ pux ~ - ?. ?=([@ @ @ @ *] u.pux) ~ + ?. ?=({@ @ @ @ *} u.pux) ~ =+ :* hyr=(slay i.u.pux) fal=(slay i.t.u.pux) dyc=(slay i.t.t.u.pux) ved=(slay i.t.t.t.u.pux) tyl=t.t.t.t.u.pux == - ?. ?=([~ $$ %tas @] hyr) ~ - ?. ?=([~ $$ %p @] fal) ~ - ?. ?=([~ $$ %tas @] dyc) ~ + ?. ?=({$~ $$ $tas @} hyr) ~ + ?. ?=({$~ $$ $p @} fal) ~ + ?. ?=({$~ $$ $tas @} dyc) ~ ?. ?=(^ ved) ~ =+ ron=q.p.u.hyr =+ bed=[[q.p.u.fal q.p.u.dyc (case p.u.ved)] (flop tyl)] @@ -4216,46 +4215,46 @@ :: .= ~[p=~.ack q=~.~sarnel r=~..y] :: (dray ~[p=%tas q=%p r=%f] %ack ~sarnel &) :: - =- |* [a=[@tas (pole @tas)] b=*] ^- (paf a) + =- |* {a/{@tas (pole @tas)} b/*} ^- (paf a) => .(b `,(tup -.a +.a)`b) ?~ +.a [(scot -.a b) ~] [(scot -.a -.b) `,(paf +.a)`(..$ +.a +.b)] - :- paf=|*(a=(pole) ?~(a ,~ ,[,(odo:raid -.a(. %ta)) ,(..$ +.a)])) + :- paf=|*(a/(pole) ?~(a $~ {(odo:raid ,-.a(. %ta)) ,(..$ +.a)})) ^= tup - |* [a=@tas b=(pole @tas)] + |* {a/@tas b/(pole @tas)} =+ c=(odo:raid a) - ?~(b c ,[c ,(..$ -.b +.b)]) + ?~(b c {c (..$ ,-.b ,+.b)}) :: :: ++raid:wired ++ raid :: demand path odors :: :: .= [p=%ack q=~sarnel r=&] - :: (raid =ack=~sarnel+.y p=%tas q=%p r=%f ~) + :: (raid /ack/~sarnel+.y p=%tas q=%p r=%f ~) :: - =- |* [a=path b=[@tas (pole @tas)]] + =- |* {a/path b/{@tas (pole @tas)}} =* fog (odo -.b) ?~ +.b `fog`(slav -.b -.a) [`fog`(slav -.b -.a) (..$ +.a +.b)] ^= odo - |* a=@tas - |= b=* + |* a/@tas + |= b/* =< a(, (. b)) :: preserve face ?+ a @ - %c @c %da @da %dr @dr %f @f %if @if %is @is %p @p - %u @u %uc @uc %ub @ub %ui @ui %ux @ux %uv @uv %uw @uw - %s @s %t @t %ta @ta %tas @tas + $c @c $da @da $dr @dr $f @f $if @if $is @is $p @p + $u @u $uc @uc $ub @ub $ui @ui $ux @ux $uv @uv $uw @uw + $s @s $t @t $ta @ta $tas @tas == :: :: :: ++read:wired :: ++ read :: parse odored path -:: =< |*([a=path b=[@tas (pole @tas)]] ((+> b) a)) -:: |* b=[@tas (pole @tas)] -:: |= a=path +:: =< |*({a/path b/{@tas (pole @tas)}} ((+> b) a)) +:: |* b/{@tas (pole @tas)} +:: |= a/path :: ?~ a ~ :: =+ hed=(slaw -.b i.a) :: =* fog (odo:raid -.b) :: ?~ +.b :: ^- (unit fog) :: ?^(+.a ~ hed) -:: ^- (unit [fog _(need *(..^$ +.b))]) +:: ^- (unit {fog _(need *(..^$ +.b))}) :: (both hed ((..^$ +.b) +.a)) -- ::wired :: :: @@ -4265,7 +4264,7 @@ |% :: :: ++cite:title ++ cite :: render ship - |= who=@p + |= who/@p ^- tape =+ kind=(clan who) =+ name=(scow %p who) @@ -4276,7 +4275,7 @@ name :: :: ++clan:title ++ clan :: ship to rank - |= who=ship ^- rank:ames + |= who/ship ^- rank:ames =+ wid=(met 3 who) ?: (lte wid 1) %czar ?: =(2 wid) %king @@ -4285,11 +4284,11 @@ ?> (lte wid 16) %pawn :: :: ++glam:title ++ glam :: galaxy name - |= zar=@pD ^- tape + |= zar/@pD ^- tape (weld "galaxy " (scow %p zar)) :: :: ++gnom:title ++ gnom :: ship display name - |= [[our=@p now=@da] him=@p] ^- @t + |= {{our/@p now/@da} him/@p} ^- @t =+ yow=(scot %p him) =+ pax=[(scot %p our) %ktts (scot %da now) yow ~] =+ woy=.^(@t %a pax) @@ -4297,19 +4296,19 @@ (rap 3 yow ' ' woy ~) :: :: ++gnow:title ++ gnow :: full display name - |= [who=@p gos=gcos:ames] ^- @t + |= {who/@p gos/gcos:ames} ^- @t ?- -.gos - %czar (rap 3 '|' (rap 3 (glam who)) '|' ~) - %king (rap 3 '_' p.gos '_' ~) - %earl (rap 3 ':' p.gos ':' ~) - %pawn ?~(p.gos %$ (rap 3 '.' u.p.gos '.' ~)) - %duke - ?: ?=(%anon -.p.gos) %$ + $czar (rap 3 '|' (rap 3 (glam who)) '|' ~) + $king (rap 3 '_' p.gos '_' ~) + $earl (rap 3 ':' p.gos ':' ~) + $pawn ?~(p.gos %$ (rap 3 '.' u.p.gos '.' ~)) + $duke + ?: ?=($anon -.p.gos) %$ %+ rap 3 ^- (list @) ?- -.p.gos - %punk ~['"' q.p.gos '"'] - ?(%lord %lady) + $punk ~['"' q.p.gos '"'] + ?($lord $lady) =+ ^= nad =+ nam=`name:ames`s.p.p.gos %+ rap 3 @@ -4324,36 +4323,36 @@ == :: :: ++saxo:title ++ saxo :: autocanon - |= who=ship + |= who/ship ^- (list ship) =+ dad=(sein who) [who ?:(=(who dad) ~ $(who dad))] :: :: ++sein:title ++ sein :: autoboss - |= who=ship ^- ship + |= who/ship ^- ship =+ mir=(clan who) ?- mir - %czar who - %king (end 3 1 who) - %duke (end 4 1 who) - %earl (end 5 1 who) - %pawn ~zod + $czar who + $king (end 3 1 who) + $duke (end 4 1 who) + $earl (end 5 1 who) + $pawn ~zod == :: :: ++team:title - ++ team :: our = our moon - |= [our=@p him=@p] + ++ team :: our / our moon + |= {our/@p him/@p} ?| =(our him) - &(?=(%earl (clan him)) =(our (sein him))) + &(?=($earl (clan him)) =(our (sein him))) == -- ::title :: :: :::: ++milly :: (2k) milliseconds :: :::: ++ milly ^? - |_ now=@da + |_ now/@da :: :: ++around:milly ++ around :: relative msec - |= wen=@da + |= wen/@da ^- @tas ?: =(wen now) %now ?: (gth wen now) @@ -4361,21 +4360,21 @@ (cat 3 '-' $(now wen, wen now)) :: ++ about :: ++about:milly - |= wun=(unit @da) :: unit relative msec + |= wun/(unit @da) :: unit relative msec ^- @tas ?~(wun %no (around u.wun)) :: :: ++mill:milly ++ mill :: msec diff - |= one=@dr + |= one/@dr ^- @tas ?: =(`@`0 one) '0ms' (cat 3 (scot %ud (msec one)) %ms) :: :: ++msec:milly ++ msec :: @dr to @ud ms - |=(a=@dr `@ud`(div a (div ~s1 1.000))) + |=(a/@dr `@ud`(div a (div ~s1 1.000))) :: :: ++mull:milly ++ mull :: unit msec diff - |= une=(unit @dr) + |= une/(unit @dr) ^- @tas ?~(une %no (mill u.une)) -- @@ -4391,7 +4390,7 @@ |% :: :: ++dawn:chrono: ++ dawn :: Jan 1 weekday - |= yer=@ud + |= yer/@ud =+ yet=(sub yer 1) %- mod :_ 7 ;: add @@ -4402,14 +4401,14 @@ == :: :: ++daws:chrono: ++ daws :: date weekday - |= yed=date + |= yed/date %- mod :_ 7 %+ add (dawn y.yed) (sub (yawn [y.yed m.yed d.t.yed]) (yawn y.yed 1 1)) :: :: ++deal:chrono: ++ deal :: to leap sec time - |= yer=@da + |= yer/@da =+ n=0 =+ yud=(yore yer) |- ^- date @@ -4422,7 +4421,7 @@ $(n +(n)) :: :: ++lead:chrono: ++ lead :: from leap sec time - |= ley=date + |= ley/date =+ ler=(year ley) =+ n=0 |- ^- @da @@ -4438,34 +4437,34 @@ $(n +(n)) :: :: ++dust:chrono: ++ dust :: print UTC format - |= yed=date + |= yed/date ^- tape =+ wey=(daws yed) =/ num (d-co:co 1) :: print as decimal without dots - =/ pik |=([n=@u t=wall] `tape`(scag 3 (snag n t))) + =/ pik |=({n/@u t/wall} `tape`(scag 3 (snag n t))) :: - "[(pik wey wik:yu)], ". - "[(num d.t.yed)] [(pik (dec m.yed) mon:yu)] [(num y.yed)] ". - "[(num h.t.yed)]:[(num m.t.yed)]:[(num s.t.yed)] +0000" + "{(pik wey wik:yu)}, ". + "{(num d.t.yed)} {(pik (dec m.yed) mon:yu)} {(num y.yed)} ". + "{(num h.t.yed)}:{(num m.t.yed)}:{(num s.t.yed)} +0000" :: :: ++stud:chrono: ++ stud :: parse UTC format - =< |= a=cord :: expose parsers + =< |= a/cord :: expose parsers %+ biff (rush a (more sepa elem)) - |= b=(list _(wonk *elem)) ^- (unit date) + |= b/(list _(wonk *elem)) ^- (unit date) =- ?.((za:dejs:format -) ~ (some (zp:dejs:format -))) ^+ =+ [*date u=unit] - *[(u _[a y]) (u _m) (u _d.t) (u _+.t) ~] + *{(u _[a y]) (u _m) (u _d.t) (u _+.t) $~} :~ - |-(?~(b ~ ?.(?=(%y -.i.b) $(b t.b) `+.i.b))) - |-(?~(b ~ ?.(?=(%m -.i.b) $(b t.b) `+.i.b))) - |-(?~(b ~ ?.(?=(%d -.i.b) $(b t.b) `+.i.b))) - |-(?~(b ~ ?.(?=(%t -.i.b) $(b t.b) `+.i.b))) + |-(?~(b ~ ?.(?=($y -.i.b) $(b t.b) `+.i.b))) + |-(?~(b ~ ?.(?=($m -.i.b) $(b t.b) `+.i.b))) + |-(?~(b ~ ?.(?=($d -.i.b) $(b t.b) `+.i.b))) + |-(?~(b ~ ?.(?=($t -.i.b) $(b t.b) `+.i.b))) == |% :: :: ++snug:stud:chrono: ++ snug :: position in list - |= a=(list tape) - |= b=tape + |= a/(list tape) + |= b/tape =+ [pos=1 len=(lent b)] |- ^- (unit @u) ?~ a ~ @@ -4492,7 +4491,7 @@ (bass 10 (stun 1^2 dit)) :: :: ++t:stud:chrono: ++ t :: hours:minutes:secs - %+ cook |=([h=@u @ m=@u @ s=@u] ~[h m s]) + %+ cook |=({h/@u @ m/@u @ s/@u} ~[h m s]) ;~(plug d col d col d) :: :: XX day of week is currently unchecked, and @@ -4509,7 +4508,7 @@ -- :: :: :: ++unt:chrono:userlib ++ unt :: Urbit to Unix time - |= a=@ + |= a/@ (div (sub a ~1970.1.1) ~s1) :: :: ++yu:chrono:userlib ++ yu :: UTC format constants @@ -4562,32 +4561,32 @@ |% :: :: ++feel:space:userlib ++ feel :: simple file write - |= [pax=path val=cage] + |= {pax/path val/cage} ^- miso =+ dir=.^(arch %cy pax) ?~ fil.dir [%ins val] [%mut val] :: :: ++file:space:userlib ++ file :: simple file load - |= pax=path + |= pax/path ^- (unit) =+ dir=.^(arch %cy pax) ?~(fil.dir ~ [~ .^(* %cx pax)]) :: :: ++foal:space:userlib ++ foal :: high-level write - |= [pax=path val=cage] + |= {pax/path val/cage} ^- toro - ?> ?=([* * * *] pax) + ?> ?=({* * * *} pax) [i.t.pax [%& [[[t.t.t.pax (feel pax val)] ~]]]] :: :: ++fray:space:userlib ++ fray :: high-level delete - |= pax=path + |= pax/path ^- toro - ?> ?=([* * * *] pax) + ?> ?=({* * * *} pax) [i.t.pax [%& [[[t.t.t.pax [%del ~]] ~]]]] :: :: ++furl:space:userlib ++ furl :: unify changes - |= [one=toro two=toro] + |= {one/toro two/toro} ^- toro ~| %furl ?> ?& =(p.one p.two) :: same path @@ -4603,11 +4602,11 @@ :: :: ++lune:unix:userlib ++ lune :: cord by unix line ~% %lune ..is ~ - |= txt=@t + |= txt/@t ?~ txt ^- (list @t) ~ =+ [byt=(rip 3 txt) len=(met 3 txt)] - =| [lin=(list @t) off=@] + =| {lin/(list @t) off/@} ^- (list @t) %- flop |- ^+ lin @@ -4626,24 +4625,24 @@ :: :: ++nule:unix:userlib ++ nule :: lines to unix cord ~% %nule ..is ~ - |= lin=(list @t) + |= lin/(list @t) ^- @t %+ can 3 %+ turn lin - |= t=@t + |= t/@t [+((met 3 t)) (cat 3 t 10)] -- :: :: :::: ++scanf:userlib :: (2uF) exterpolation :: :::: ++ scanf - =< |* [tape (pole _;/(*[$^(rule tape)]))] :: formatted scan + =< |* {tape (pole _;/(*{$^(rule tape)}))} :: formatted scan => .(+< [a b]=+<) (scan a (parsf b)) |% :: :: ++parsf:scanf: ++ parsf :: make parser from: - |* a=(pole _;/(*[$^(rule tape)])) :: ;"chars[rule]chars" + |* a/(pole _;/(*{$^(rule tape)})) :: ;"chars{rule}chars" =- (cook - (boil (norm a))) |* (list) ?~ +< ~ @@ -4658,14 +4657,14 @@ |* (list (each rule tape)) ?~ +< (easy ~) ?: ?=($| -.i) ;~(pfix (jest (crip p.i)) $(+< t)) - %+ cook |*([* *] [i t]=+<) + %+ cook |*({* *} [i t]=+<) ;~(plug p.i $(+< t)) :: - :: .= (norm [;"[n], [n]"]:n=dim:ag) ~[[& dim] [| ", "] [& dim]]:ag + :: .= (norm [;"{n}, {n}"]:n=dim:ag) ~[[& dim] [| ", "] [& dim]]:ag :: :: :: ++norm:scanf:userlib ++ norm :: - |* (pole _;/(*[$^(rule tape)])) + |* (pole _;/(*{$^(rule tape)})) ?~ +< ~ => .(+< [i=+<- t=+<+]) :_ t=$(+< t) @@ -4684,21 +4683,21 @@ |% :: :: ++pale:pubsub: ++ pale :: filter peers - |= [hid=bowl fun=$-(sink ?)] + |= {hid/bowl fun/$-(sink ?)} (skim ~(tap by sup.hid) fun) :: :: ++prix:pubsub: ++ prix :: filter gate - |= pax=path |= sink ^- ? + |= pax/path |= sink ^- ? ?~ pax & ?~ r.+< | &(=(i.pax i.r.+<) $(pax t.pax, r.+< t.r.+<)) :: :: ++prey:pubsub: ++ prey :: prefix - |=([pax=path hid=bowl] (pale hid (prix pax))) + |=({pax/path hid/bowl} (pale hid (prix pax))) -- ::pubsub -- :: ++ zuse %309 :: hoon+zuse kelvin -+= gift-arvo :: out result <-$ +++ gift-arvo :: out result <-$ $? gift:able:ames gift:able:behn gift:able:clay @@ -4707,7 +4706,7 @@ gift:able:ford gift:able:gall == -+= task-arvo :: in request ->$ +++ task-arvo :: in request ->$ $? task:able:ames task:able:clay task:able:behn @@ -4716,39 +4715,39 @@ task:able:ford task:able:gall == -+= note-arvo :: out request $-> - $? [@tas %meta vase] - $% [%a task:able:ames] - [%b task:able:behn] - [%c task:able:clay] - [%d task:able:dill] - [%e task:able:eyre] - [%f task:able:ford] - [%g task:able:gall] +++ note-arvo :: out request $-> + $? {@tas $meta vase} + $% {$a task:able:ames} + {$b task:able:behn} + {$c task:able:clay} + {$d task:able:dill} + {$e task:able:eyre} + {$f task:able:ford} + {$g task:able:gall} == == -+= sign-arvo :: in result $<- - $% [%a gift:able:ames] - [%b gift:able:behn] - [%c gift:able:clay] - [%d gift:able:dill] - [%e gift:able:eyre] - [%f gift:able:ford] - [%g gift:able:gall] - [%j gift:able:jael] +++ sign-arvo :: in result $<- + $% {$a gift:able:ames} + {$b gift:able:behn} + {$c gift:able:clay} + {$d gift:able:dill} + {$e gift:able:eyre} + {$f gift:able:ford} + {$g gift:able:gall} + {$j gift:able:jael} == :: -+= unix-task :: input from unix - $% [%belt p=belt:dill] :: dill: keyboard - [%blew p=blew:dill] :: dill: configure - [%boat ~] :: clay: reboot - [%born ~] :: eyre: new process - [%hail ~] :: dill: refresh - [%hear p=lane:ames q=@] :: ames: input packet - [%hook ~] :: dill: hangup - [%into p=desk q=? r=mode:clay] :: clay: external edit - [%they p=@ud q=httr:eyre] :: eyre: in response - [%this p=? q=clip:eyre r=httq:eyre] :: eyre: in request - [%thud ~] :: eyre: in cancel - [%wake ~] :: behn: wakeup +++ unix-task :: input from unix + $% {$belt p/belt:dill} :: dill: keyboard + {$blew p/blew:dill} :: dill: configure + {$boat $~} :: clay: reboot + {$born $~} :: eyre: new process + {$hail $~} :: dill: refresh + {$hear p/lane:ames q/@} :: ames: input packet + {$hook $~} :: dill: hangup + {$into p/desk q/? r/mode:clay} :: clay: external edit + {$they p/@ud q/httr:eyre} :: eyre: in response + {$this p/? q/clip:eyre r/httq:eyre} :: eyre: in request + {$thud $~} :: eyre: in cancel + {$wake $~} :: behn: wakeup == -- ::