Further simplifications

library/compiler/generator/generator.factor

@@ -179,12 +179,12 @@ M: #push generate-node
     ] if ;
 
 : adjust-shuffle ( shuffle -- )
-    shuffle-in length neg phantom-d get adjust-phantom ;
+    effect-in length neg phantom-d get adjust-phantom ;
 
 : phantom-shuffle ( shuffle -- )
-    dup shuffle-in 0 additional-vregs 0 ensure-vregs
+    dup effect-in 0 additional-vregs 0 ensure-vregs
     [
-        shuffle-in length phantom-d get phantom-shuffle-input
+        effect-in length phantom-d get phantom-shuffle-input
     ] keep
     [ shuffle* ] keep adjust-shuffle
     phantom-d get phantom-append ;

library/compiler/inference/dataflow.factor

@@ -24,7 +24,7 @@ successor children ;
 M: node equal? eq? ;
 
 : node-shuffle ( node -- shuffle )
-    dup node-in-d swap node-out-d <shuffle> ;
+    dup node-in-d swap node-out-d <effect> ;
 
 : make-node ( param in-d out-d in-r out-r node -- node )
     [ >r f f f f f <node> r> set-delegate ] keep ;

library/compiler/inference/shuffle.factor

@@ -22,22 +22,17 @@ M: integer value-uid ;
 
 M: integer value-recursion drop f ;
 
-TUPLE: shuffle in out ;
-
 : split-shuffle ( stack shuffle -- stack1 stack2 )
-    shuffle-in length swap cut* ;
+    effect-in length swap cut* ;
 
 : load-shuffle ( stack shuffle -- )
-    shuffle-in [ set ] 2each ;
+    effect-in [ set ] 2each ;
 
 : shuffled-values ( shuffle -- values )
-    shuffle-out [ get ] map ;
+    effect-out [ get ] map ;
 
 : shuffle* ( stack shuffle -- stack )
     [ [ load-shuffle ] keep shuffled-values ] with-scope ;
 
 : shuffle ( stack shuffle -- stack )
     [ split-shuffle ] keep shuffle* append ;
-
-M: shuffle clone
-    [ shuffle-in clone ] keep shuffle-out clone <shuffle> ;

library/compiler/inference/stack.factor

@@ -3,13 +3,13 @@ USING: arrays generic kernel math namespaces
 sequences words parser ;
 
 : infer-shuffle-inputs ( shuffle node -- )
-    >r shuffle-in length 0 r> node-inputs ;
+    >r effect-in length 0 r> node-inputs ;
 
 : shuffle-stacks ( shuffle -- )
     meta-d [ swap shuffle ] change ;
 
 : infer-shuffle-outputs ( shuffle node -- )
-    >r shuffle-out length 0 r> node-outputs ;
+    >r effect-out length 0 r> node-outputs ;
 
 : infer-shuffle ( shuffle -- )
     #shuffle dup node,
@@ -17,31 +17,27 @@ sequences words parser ;
     over shuffle-stacks
     infer-shuffle-outputs ;
 
-: shuffle>effect ( shuffle -- effect )
-    dup shuffle-in swap shuffle-out <effect> ;
-
 : define-shuffle ( word shuffle -- )
-    [ "shuffle" set-word-prop ] 2keep
-    [ shuffle>effect "infer-effect" set-word-prop ] 2keep
-    [ , \ infer-shuffle , ] [ ] make "infer" set-word-prop ;
+    [ "infer-effect" set-word-prop ] 2keep
+    [ infer-shuffle ] curry "infer" set-word-prop ;
 
 {
-    { drop  T{ shuffle f 1 {             } } }
-    { 2drop T{ shuffle f 2 {             } } }
-    { 3drop T{ shuffle f 3 {             } } }
-    { dup   T{ shuffle f 1 { 0 0         } } }
-    { 2dup  T{ shuffle f 2 { 0 1 0 1     } } }
-    { 3dup  T{ shuffle f 3 { 0 1 2 0 1 2 } } }
-    { rot   T{ shuffle f 3 { 1 2 0       } } }
-    { -rot  T{ shuffle f 3 { 2 0 1       } } }
-    { dupd  T{ shuffle f 2 { 0 0 1       } } }
-    { swapd T{ shuffle f 3 { 1 0 2       } } }
-    { nip   T{ shuffle f 2 { 1           } } }
-    { 2nip  T{ shuffle f 3 { 2           } } }
-    { tuck  T{ shuffle f 2 { 1 0 1       } } }
-    { over  T{ shuffle f 2 { 0 1 0       } } }
-    { pick  T{ shuffle f 3 { 0 1 2 0     } } }
-    { swap  T{ shuffle f 2 { 1 0         } } }
+    { drop  T{ effect f 1 {             } } }
+    { 2drop T{ effect f 2 {             } } }
+    { 3drop T{ effect f 3 {             } } }
+    { dup   T{ effect f 1 { 0 0         } } }
+    { 2dup  T{ effect f 2 { 0 1 0 1     } } }
+    { 3dup  T{ effect f 3 { 0 1 2 0 1 2 } } }
+    { rot   T{ effect f 3 { 1 2 0       } } }
+    { -rot  T{ effect f 3 { 2 0 1       } } }
+    { dupd  T{ effect f 2 { 0 0 1       } } }
+    { swapd T{ effect f 3 { 1 0 2       } } }
+    { nip   T{ effect f 2 { 1           } } }
+    { 2nip  T{ effect f 3 { 2           } } }
+    { tuck  T{ effect f 2 { 1 0 1       } } }
+    { over  T{ effect f 2 { 0 1 0       } } }
+    { pick  T{ effect f 3 { 0 1 2 0     } } }
+    { swap  T{ effect f 2 { 1 0         } } }
 } [ first2 define-shuffle ] each
 
 \ >r [

library/effects.factor

@@ -46,3 +46,6 @@ C: effect
     dup "declared-effect" word-prop [ ] [
         dup "infer-effect" word-prop [ ] [ drop f ] ?if
     ] ?if ;
+
+M: effect clone
+    [ effect-in clone ] keep effect-out clone <effect> ;

library/ui/tools/dataflow.factor

@@ -23,8 +23,7 @@ C: shuffle-gadget ( node -- gadget )
     dup delegate>gadget ;
 
 : shuffled-offsets ( shuffle -- seq )
-    dup shuffle-in swap shuffle-out
-    [ swap index ] map-with ;
+    dup effect-in swap effect-out [ swap index ] map-with ;
 
 : shuffled-endpoints ( w h seq seq -- seq )
     [ [ 30 * 15 + ] map ] 2apply
@@ -45,7 +44,7 @@ M: shuffle-gadget draw-gadget*
 : node-dim ( n -- dim ) 30 * 10 swap 2array ;
 
 : shuffle-dim ( shuffle -- dim )
-    dup shuffle-in length swap shuffle-out length max
+    dup effect-in length swap effect-out length max
     node-dim ;
 
 M: shuffle-gadget pref-dim*