Generalize △ to exhibit zip behavior

It appears that △ and ▽ are closely related to the usual `zip` and
`unzip` operations in functional languages and represent a boundary
condition in their semantics.

Therefore, it's better to remove the tentative new `zip` core form in
favor of generalizing the existing △ form (and in the future,
likewise, also generalizing ▽).

This does entail a small backwards incompatibility, as `(△ flo)`
formerly accepted a single list and any number of additional values
that would be passed to each invocation of flo along with each element
of the list. That behavior is intuitively very similar to the "zip"
behavior, except that we now (more properly, it would seem) simply
expect these additional values to be present in separate input lists,
and these values may _happen_ to all be the same at each index.

Author: countvajhula

qi-doc/scribblings/forms.scrbl

@@ -150,20 +150,27 @@ The full surface syntax of Qi is given below. Note that this expands to a @secli
   @defform[#:link-target? #f
            (sep flo)]
 )]{
-  Separate the input list into its component values. This is the inverse of @racket[▽].
+  For a single input list, separate it into its component values after first applying @racket[flo], if provided. This is the inverse of @racket[▽].
 
-  When used in parametrized form with a presupplied @racket[flo], this @tech{flow} accepts any number of inputs, where the first is expected to be the list to be unraveled. In this form, the flow separates the list into its component values and passes each through @racket[flo] along with the remaining input values.
+  When given multiple input lists, this resembles the standard "zip" operation in functional programming languages. Specifically: combine corresponding members of each input list using @racket[flo], producing these results directly as @seclink["values-model" #:doc '(lib "scribblings/reference/reference.scrbl")]{values}. If no @racket[flo] is specified, default to @racket[values], so that the behavior is to simply separate all input lists into values, in order of appearance, by index. A common choice of @racket[flo] here is @racket[list], yielding the usual "zip."
+
+  If the input lists aren't all of the same size, the operation is truncated when the shortest list is exhausted.
+
+  In the common case where @racket[flo] is @code{1 × 1} (i.e., where it accepts one input and produces one output), and where the input lists are all of the same size, the number of outputs will be the same as the length of each input list. But as @seclink["What_is_a_Flow_"]{flows can produce any number of values}, this is not necessarily the case in general.
 
   @racket[△] and @racket[▽] often allow you to use functions directly where you might otherwise need to use an indirection like @racket[apply] or @racket[list].
 
 @examples[
     #:eval eval-for-docs
     ((☯ (~> △ +)) (list 1 2 3 4))
     ((☯ (~> △ (>< sqr) ▽)) (list 1 2 3 4))
-    ((☯ (~> (△ +) ▽)) (list 1 2 3) 10)
+    ((☯ (~> (△ +) ▽)) (list 1 2 3) (list 10 10 10))
     (struct kitten (name age) #:transparent)
     ((☯ (~> (△ kitten) ▽))
-     (list "Ferdinand" "Imp" "Zacky") 0)
+     (list "Ferdinand" "Imp" "Zacky") (list 0 0 0))
+    ((☯ (△ list)) '(a b c) '(1 2 3))
+    ((☯ (△ +)) (list 1 2 3) (list 1 2 3))
+    ((☯ (△ (~> (-< _ _) ▽))) (list 1 2 3))
   ]
 }
 
@@ -485,24 +492,6 @@ Note that the symbol form uses Unicode @code{0x2225} corresponding to LaTeX's @c
   ]
 }
 
-@deftogether[(
-@defform[(zip flo)]
-@defidform[#:link-target? #f zip]
-)]{
-  Combine corresponding members of each input list using @racket[flo], producing these results directly as @seclink["values-model" #:doc '(lib "scribblings/reference/reference.scrbl")]{values}.
-
-  If the lists aren't all of the same size, the operation is truncated when the shortest list is exhausted. If no @racket[flo] is specified, it defaults to @racket[list].
-
-  In the common case where @racket[flo] is @code{1 × 1} (i.e., where it accepts one input and produces one output), and where the input lists are all of the same size, the number of outputs will be the same as the length of each input list. But as @seclink["What_is_a_Flow_"]{flows can produce any number of values}, this is not necessarily the case in general.
-
-@examples[
-    #:eval eval-for-docs
-    ((☯ zip) '(a b c) '(1 2 3))
-    ((☯ (zip +)) (list 1 2 3) (list 1 2 3))
-    ((☯ (zip (~> (-< _ _) ▽))) (list 1 2 3))
-  ]
-}
-
 @deftogether[(
 @defidform[fanout]
 @defform[#:link-target? #f

qi-doc/scribblings/list-operations.scrbl

@@ -74,7 +74,7 @@ Deforestable version of @racket[filter] from @racketmodname[racket/base].
   #:contracts
   ((proc (-> any/c any/c)))]{
 
-Deforestable version of @racket[map] from @racketmodname[racket/base]. Note that, unlike the Racket version, this accepts only one argument. For the "zip"-like behavior with multiple list inputs, see @racket[zip].
+Deforestable version of @racket[map] from @racketmodname[racket/base]. Note that, unlike the Racket version, this accepts only one argument. For the "zip"-like behavior with multiple list inputs, see @racket[△].
 
 }
 

qi-doc/scribblings/principles.scrbl

@@ -88,6 +88,7 @@ When reading languages like English, we understand what we read in terms of word
 @;clarify arity of adaptation; and scribble mathify some of these things (and review/distinguish from code); and add diagrams - look at the prolog bookmark for the fold diagram
 @itemlist[
    @item{@racket[(~> △ (>< f) ...)] -- "sep-amp". A standard mapping over values extracted from a list.}
+   @item{@racket[(△ ▽)] -- "zip". A standard way to collect corresponding elements of lists.}
    @item{@racket[(~> (-< _ f ...) ...)] -- "augment". The tee junction may augment the flow in any order -- the signature of this phrase is the presence of a @racket[_] in the tee junction.}
    @item{@racket[(~> (-< f ...) g)] -- "diamond composition". This is one way to adapt a flow @racket[f] of arity @${k} to a flow @racket[g] of arity @${m}, that is, by branching the @${k} inputs into @${m} copies of @racket[f] (assuming @racket[f] produces one output). It is the same as the "composition operator" used in defining @hyperlink["https://en.wikipedia.org/wiki/Primitive_recursive_function"]{primitive recursive functions}.}
    @item{@racket[(group 1 car-flo cdr-flo)] -- "pare". This is analogous to "car and cdr" style destructuring with lists, but for segregating values instead. Note that while it is analogous, this isn't "destructuring," since the values taken together @seclink["Values_are_Not_Collections"]{do not form a data structure}.}
@@ -152,6 +153,7 @@ Qi flow expressions expand to a small core language which is then @seclink["It_s
 [floe _
       (gen expr ...)
       sep
+      (sep floe)
       collect
       (esc expr)
       (clos floe)
@@ -171,8 +173,6 @@ Qi flow expressions expand to a small core language which is then @seclink["It_s
       (relay floe ...)
       tee
       (tee floe ...)
-      zip
-      (zip floe)
       fanout
       (fanout nat)
       feedback

qi-doc/scribblings/using-qi.scrbl

@@ -350,7 +350,7 @@ For such cases, by means of a @racket[divert] (or its alias, @racket[%]) clause
       [begin? (~> (== begin-actions _) eval-sequence)]
       [cond? (~> (== cond->if _) eval)]
       [application? (~> (-< (~> (== operator _) eval)
-                            (~> (== operands _) (△ eval))) apply)]
+                            (~> (== operands (as env)) (>< (eval env)))) apply)]
       [else (error "Unknown expression type -- EVAL" 1>)])
 }
 

qi-lib/flow/core/compiler/1000-qi0.rkt

@@ -59,7 +59,6 @@
     ;; map and filter
     [e:amp-form (amp-parser #'e)] ; NOTE: technically not core
     [e:pass-form (pass-parser #'e)] ; NOTE: technically not core
-    [e:zip-form (zip-parser #'e)]
     ;; prisms
     [e:sep-form (sep-parser #'e)]
     [(~or* (~datum ▽) (~datum collect))
@@ -167,15 +166,17 @@ already handled during expansion by Syntax Spec.
 
   (define (sep-parser stx)
     (syntax-parse stx
-      [_:id
-       #'(qi0->racket (if (esc list?)
-                          (#%fine-template (apply values _))
-                          (#%fine-template (raise-argument-error '△
-                                                                 "list?"
-                                                                 _))))]
-      [(_ onex:clause)
-       #'(λ (v . vs)
-           ((qi0->racket (~> △ (>< (#%fine-template (apply (qi0->racket onex) _ vs))))) v))]))
+      [(_ op:clause)
+       #'(zip-with (qi0->racket op))]
+      [_:id #'(λ args
+                (if (singleton? args)
+                    (let ([v (first args)])
+                      (if (list? v)
+                          (apply values v)  ; fast path to the basic △ behavior
+                          (raise-argument-error '△
+                                                "list?"
+                                                v)))
+                    (apply (qi0->racket (△ _)) args)))]))
 
   (define (select-parser stx)
     (syntax-parse stx
@@ -337,12 +338,6 @@ already handled during expansion by Syntax Spec.
       [(_ onex:clause)
        #'(curry map-values (qi0->racket onex))]))
 
-  (define (zip-parser stx)
-    (syntax-parse stx
-      [(_ op:clause)
-       #'(zip-with (qi0->racket op))]
-      [_:id #'(qi0->racket (zip (esc list)))]))
-
   (define (pass-parser stx)
     (syntax-parse stx
       [_:id

qi-lib/flow/core/runtime.rkt

@@ -17,6 +17,7 @@
          feedback-times
          feedback-while
          kw-helper
+         singleton?
          zip-with)
 
 (require racket/match
@@ -171,25 +172,36 @@
 
 (define for-all andmap)
 
+(define (singleton? seq)
+  ;; cheap check to see if a list is of length 1,
+  ;; instead of traversing to compute the length
+  (and (not (empty? seq))
+       (empty? (rest seq))))
+
 (define (~zip-with op seqs truncate)
-  (if (empty? seqs)
-      null
-      (if (exists empty? seqs)
-       (if (for-all empty? seqs)
-           null
-           (if truncate
-               null
-               (apply raise-arity-error
-                      'zip-with
-                      0
-                      (first (filter (negate empty?) seqs)))))
-       (let ([vs (map first seqs)])
-         (append (values->list (apply op vs))
-                 (~zip-with op (map rest seqs) truncate))))))
+  (if (exists empty? seqs)
+      (if (for-all empty? seqs)
+          null
+          (if truncate
+              null
+              (apply raise-arity-error
+                     'zip-with
+                     0
+                     (first (filter (negate empty?) seqs)))))
+      (let ([vs (map first seqs)])
+        (append (values->list (apply op vs))
+                (~zip-with op (map rest seqs) truncate)))))
 
 (define (zip-with op)
   (λ seqs
-    (apply values (apply ~zip-with (list op seqs #true)))))
+    (if (empty? seqs)
+        (values)
+        (let ([v (first seqs)])
+          (if (list? v)
+              (apply values (apply ~zip-with (list op seqs #true)))
+              (raise-argument-error 'zip-with
+                                    "list?"
+                                    v))))))
 
 ;; from mischief/function - requiring it runs aground
 ;; of some "name is protected" error while building docs, not sure why;

qi-lib/flow/core/syntax.rkt

@@ -14,7 +14,6 @@
          fanout-form
          if-form
          pass-form
-         zip-form
          fold-left-form
          fold-right-form
          loop-form
@@ -113,12 +112,6 @@ See comments in flow.rkt for more details.
   (pattern
    ((~datum pass) arg ...)))
 
-(define-syntax-class zip-form
-  (pattern
-   (~datum zip))
-  (pattern
-   ((~datum zip) arg)))
-
 (define-syntax-class fold-left-form
   (pattern
    (~datum >>))

qi-lib/flow/extended/expander.rkt

@@ -102,8 +102,6 @@ core language's use of #%app, etc.).
              (report-syntax-error this-syntax
                "(>< flo)"
                "amp expects a single flow specification, but it received many."))
-    (zip op:closed-floe)
-    zip
     pass
     (pass f:closed-floe)
     sep

qi-lib/flow/extended/util.rkt

@@ -16,7 +16,6 @@
                       amp
                       tee
                       relay
-                      zip
                       gen
                       pass
                       sep
@@ -54,9 +53,6 @@
     [(relay
       expr ...)
      #`(== #,@(map prettify-flow-syntax (syntax->list #'(expr ...))))]
-    [(zip
-      expr ...)
-     #`(zip #,@(map prettify-flow-syntax (syntax->list #'(expr ...))))]
     [(gen
       expr ...)
      #`(gen #,@(map prettify-flow-syntax (syntax->list #'(expr ...))))]

qi-sdk/benchmarks/local/benchmarks.rkt

@@ -183,7 +183,7 @@ for the forms are run.
 
   (define (~zip . vs)
     (apply
-     (☯ (zip +))
+     (☯ (△ +))
      vs))
 
   (define (run)

qi-test/tests/expander.rkt

@@ -104,9 +104,9 @@
                             ((#%host-expression f)
                              (#%host-expression 1)
                              __))))
-    (test-expand "zip"
-                 #'(zip (>< f))
-                 #'(zip (amp (esc (#%host-expression f)))))
+    (test-expand "sep"
+                 #'(sep (>< f))
+                 #'(sep (amp (esc (#%host-expression f)))))
     (test-expand "#%deforestable"
                  #'(#%deforestable name info (floe 0) (expr 0))
                  #'(#%deforestable name
@@ -128,7 +128,6 @@
                                  (relay (esc (#%host-expression f)) (esc (#%host-expression g)))
                                  (tee (esc (#%host-expression f)) (esc (#%host-expression g)))
                                  (thread (esc (#%host-expression f)) (esc (#%host-expression g)))
-                                 (zip (esc (#%host-expression f)))
                                  (gen (#%host-expression 2) (#%host-expression 3))
                                  (pass (esc (#%host-expression f)))
                                  (sep (esc (#%host-expression g)))
@@ -162,7 +161,6 @@
                          (== f g)
                          (-< f g)
                          (~> f g)
-                         (zip f)
                          (gen 2 3)
                          (pass f)
                          (sep g)