G/Pea/Peaceness

   1 # I J
   2 # part of ruv, which is assembled on the outside, so:
   3 # me/io global:
   4 $me = 4c&me;
   5 !me and throw "no me";
   6 $io = me.io;
   7 window.io = io;
   8 window.me = me;
   9 me.Peaceness = &acgt{ return [
  10     &{
  11     # wrap calls to me&t so they don't throw if !ready
  12     # will go weird if we're not one Ring deep
  13     me.JRom_asyncQs = &acgtR{
  14         T.asyncQs = [];
  15         return &{
  16             $was = delete T.asyncQs
  17             was.length and return T.cancel = was.map(n=>n.t).join(', ')
  18         }
  19     };
  20
  21     },
  22     # J: w (Peace) with W (R.t)
  23     # unfold a structure from code and data
  24     ['Peace','291',&acgtRs{
  25         #n Sleigh  R %Slei,ting:W,Gens,tingspot
  26         # run field of exclaimation into others!
  27
  28         # A:Peace
  29         # uses A.1-5 for %Peace=1-5
  30         # relies on %Peace all the way down
  31         $p = Ry&up;
  32         $AA = A;
  33         ps&Ace and A = ps&Ace
  34         else
  35         me&ollbs,p,'Ace' and A = me&ollbs,p,'Ace'
  36         # < RbitX might extend to deal b into Ace/**
  37         $Y = Rs&Ace = G&Aye,'Peace';
  38         A = AA;
  39         Yc&Y = A;
  40         # stash the A.I somewhere, our G.t uses:
  41         !ps&Ace and Y.6 = Y.4; Y.7 = Y.5;
  42         !ps&Ace and [2,3,4,5].map(&k{ delete Y[k] })
  43         # A.1=R, usually J
  44         Y.1 = R;
  45         # R's part of the %Peace organism
  46         num(Rs&Peace) and $step = A&Sonly = Rs&Peace
  47         # A.2-5=A, usually J
  48         # < suppose you go A.up to where A.1==A.3 etc
  49         step && step > 1 and Y[step] = Y
  50         me&reaw,R,'Peace,Ace';
  51     },'ift,D,sleeping'],
  52     ['Peace','291',&acgtRs{
  53         $Y = Rs&Ace;
  54         # J 6 pin
  55         $done = me&JRom_asyncQs,R;
  56         me&way,R,'Peace',{R,Y};
  57         # < other pins
  58         done() and return
  59
  60         # default some steps
  61         $step = A&Sonly;
  62         if (step) {
  63             # done ? base types : defaults
  64             # < way might want to around something, etc
  65             $done = ahsk(A&doings,step,'done');
  66             if (step == 9) {
  67                 # 9 5s
  68                 # < see if there's a w:R.t
  69                 #   to use as well as w:Peace
  70                 #    and its meanings for W ball
  71                 $s = Cye([R.t,1,{},{}]);
  72                 # allows the 9/5%task to be ^^%mindused
  73                 # < load minds wanted inside %Gens
  74                 $r = me&personify,R,s,Y,step;
  75             }
  76             if (step == 5) {
  77                 # 5: bits of housing (boh), store <-> self
  78                 #  eg ballRom does JRom/5/3
  79                 !Rs&Gens and throw "5!Gens"
  80                 me&reaw,R,'Gens,self,Here,Zaving';
  81                 delete Rs&ting;
  82
  83                 Rs&Zaving = "mem,W";
  84                 # 5/4 then 5/3
  85                 $four = me.cby(R,"^^^Peace")
  86                     .filter(n=>ns&Peace==4)[0];
  87                 $next = !four ? 4 : 3;
  88                 ah(R,'inheritscif','ball','Peace',next)
  89                 # %Gens is about to %Here = %self)%ball
  90             }
  91             if (step == 4) {
  92                 # in this blob of Peace
  93             }
  94             if (step > 1 && step < 5) {
  95                 !Rs&ball and throw step+"!ball"
  96                 !isC(s) and throw step+"!s"
  97                 # a node sloping 4,(3,2)+
  98                 # spreading 2
  99                 ah(R,'inheritscif','ball','Peace',2)
 100
 101                 if (ss&W || ss&J || ss&R) {
 102                     # switch on layers of person
 103                     s&bgh = '010';
 104                     $r = me&personifyif,R,s,Y,step;
 105                 }
 106             }
 107             if (step == 8) {
 108                 # JRom/osc transaction join
 109                 #  plot out of time together
 110                 !Rs&JRom and throw "8!JRom"
 111             }
 112             if (step == 1) {
 113                 # an edge
 114             }
 115         }
 116
 117     },'ift,D'],
 118     &{
 119     me.personifyif = &acgtRsY,step{
 120         [ss&W,ss&J,ss&R].filter(n=>n).length > 1 and throw "mul"
 121         # we could be on a %Peace=2-4
 122         # R on 3 or 4 (tops of a J) auto
 123         $would = ss&R ? !(step <3) :
 124             # J immediately under 4
 125             Y.up == Y.4;
 126             # or anywhere before another 5? ie one J deep
 127             step <3 && Y.4 && Y.5 == Y.4[5];
 128
 129         !(Rs&play || would) and return
 130         Rs&play && would and return
 131         return me&personify,R,s,Y,step;
 132     };
 133     me.personify = &acgtRsY,step{
 134         $c = {};
 135         # the $s <-> $self
 136         #  outside $s/** may be to inside $self/** related
 137         #   the R|W|J already having a pile here
 138         #    < ein ledger
 139         #   or thing%W:javascript/** compiling thinger
 140         #    < via e to javascript%W
 141         #      does c&W need babbling and s&W not?
 142         #   or simply being more stuff here,
 143         #    which the inside is allowed to use
 144         #  balls for it may happen or dup out
 145         #   if the inside R uses them first
 146         $outsphere = (ss&z||[]).length;
 147
 148         # J into the last J
 149         # < %Zaving %directory=p%Zaving
 150         ss&J and c.directory = Y.5[1];
 151
 152         # < using W to mean thinger (see the $s)
 153         # < $W1/$W2 looks for $W2 and $W1/$W2
 154         ss&W and ''
 155
 156         if (ss&R) {
 157             if (isst(ss&R) && ss&R.substr(0,1) == '+') {
 158                 # modes to enable on R
 159                 # < it might want to be here from the start
 160                 #   rollhauntedb, ghost of a process
 161                 ss&R.split('+').map(&k{
 162                     !k and return
 163                     # ballRom would copy ss&* to rs&*
 164                     R.sc[k] = hak(s.sc,k) ? s.sc[k] : 1
 165                 });
 166                 return 'nothing'
 167             }
 168             # ballRom:
 169             #  makes r%Some%Thing if R=Some+Thing
 170             #   or r%Peace may be all if R=1
 171             #  copies ss&* to rs&*
 172             #  rs&other = s
 173             # R Ret 6
 174             c.Doming = 2;
 175             c.Peace = 6;
 176         }
 177         else {
 178             # W|J JRom 8 Gens 5
 179             c.Doming = 3;
 180             c.JRomc = {Peace:8};
 181             c.Peace = 5;
 182             # ballRom compulsively r%Gens once ^^%Gens
 183             c.Gens = 1;
 184         }
 185
 186         c.Doming <3 and 'Ret'
 187         else {
 188             # Rom may normalise %task
 189             # < JRom should be more normal?
 190             #   this could be the osc identity
 191             #   the G lang for out/in connection
 192             #  so we can leave a mind with one call
 193
 194             c.task = me&Rsc,R,'^^mindused' || 'ruv';
 195             c.JRomc.task = c.task;
 196             me&tsc,'u:'+c.task,0,'y';
 197             # ss&task might be
 198         }
 199         # < let A:Peace out there?
 200         # < e all 4s&things
 201         $r = me&ballRom,R,s,c;
 202         # does only Ret, put in Rc&N
 203         c.Doming <3 and me&zN,r
 204         else {
 205             # < uplink moreso
 206             # < resolve through JRom
 207             #   just for SC steps?
 208             # < collect things, G lang
 209             Rs&Inner = r;
 210         }
 211         return r
 212     }
 213     },
 214 ]};