useless code + some minor batch API updates

Author: AYadrov

src/core/batch.rkt

@@ -5,23 +5,24 @@
          "../syntax/types.rkt")
 
 (provide progs->batch ; (Listof Expr) -> Batch
-         batch->progs ; Batch -> *(or (Listof Root) (Vectorof Root)) -> (Listof Expr)
+         batch->progs ; Batch -> ?(or (Listof Root) (Vectorof Root)) -> (Listof Expr)
          (struct-out batch)
          (struct-out batchref) ; temporarily for patch.rkt
          (struct-out mutable-batch) ; temporarily for patch.rkt
+         expr-recurse ; Expr -> (Expr -> ?) -> Expr
          batch-length ; Batch -> Integer
          batch-ref ; Batch -> Idx -> Expr
          deref ; Batchref -> Expr
          batch-replace ; Batch -> (Expr<Batchref> -> Expr<Batchref>) -> Batch
          egg-nodes->batch ; Nodes -> Spec-maps -> Batch -> (Listof Batchref)
-         batchref->expr ; Batchref -> Expr
-         batch-remove-zombie ; Batch -> *(Vectorof Root) -> Batch
-         mutable-batch-munge! ; Mutable-batch -> Root
+         debatchref ; Batchref -> Expr
+         batch-remove-zombie ; Batch -> ?(Vectorof Root) -> Batch
+         mutable-batch-munge! ; Mutable-batch -> Expr -> Root
          mutable-batch->batch ; Mutable-batch -> Batch
          make-mutable-batch ; Mutable-batch
-         mutable-batch-devour-batchref! ; Mutable-batch -> Batchref -> Idx
          batch->mutable-batch ; Batch -> Mutable-batch
-         batch-push!) ; Mutable-batch -> Expr -> Idx
+         batch-copy-mutable-nodes! ; Batch -> Mutable-batch -> Void
+         batch-push!) ; Mutable-batch -> Node -> Idx
 
 ;; This function defines the recursive structure of expressions
 (define (expr-recurse expr f)
@@ -64,13 +65,16 @@
                  (batch-restore-index b)
                  (reverse (batch-vars b))))
 
+(define (batch-copy-mutable-nodes! b mb)
+  (set-batch-nodes! b (list->vector (reverse (mutable-batch-nodes mb)))))
+
 (struct batchref (batch idx))
 
 (define (deref x)
   (match-define (batchref b idx) x)
   (expr-recurse (vector-ref (batch-nodes b) idx) (lambda (ref) (batchref b ref))))
 
-(define (batchref->expr x)
+(define (debatchref x)
   (match-define (batchref b idx) x)
   (batch-ref b idx))
 
@@ -96,13 +100,6 @@
     (batch-push! b (expr-recurse prog munge)))
   (munge expr))
 
-(define (mutable-batch-devour-batchref! b ref)
-  (match-define (batchref b* idx) ref)
-  (define nodes* (batch-nodes b*))
-  (define (munge idx)
-    (batch-push! b (expr-recurse (vector-ref nodes* idx) munge)))
-  (munge idx))
-
 (define (batch->progs b [roots (batch-roots b)])
   (define exprs (make-vector (batch-length b)))
   (for ([node (in-vector (batch-nodes b))]

src/core/localize.rkt

@@ -49,7 +49,7 @@
 
   ; run egg
   (define simplified
-    (map batchref->expr
+    (map debatchref
          (map last
               (simplify-batch runner
                               (typed-egg-batch-extractor (if (*egraph-platform-cost*)

src/core/mainloop.rkt

@@ -241,7 +241,7 @@
              [(list 'taylor name var) (list 'taylor loc0 name var)]
              [(list 'rr input proof soundiness) (list 'rr loc0 input proof soundiness)]
              [(list 'simplify input proof soundiness) (list 'simplify loc0 input proof soundiness)]))
-         (define expr* (location-do loc0 (alt-expr orig) (const (batchref->expr (alt-expr altn)))))
+         (define expr* (location-do loc0 (alt-expr orig) (const (debatchref (alt-expr altn)))))
          (alt expr* event* (list (loop (first prevs))) (alt-preprocessing orig))])))
 
   (^patched^ (reap [sow]
@@ -378,7 +378,7 @@
 
      ; run egg
      (define simplified
-       (map batchref->expr
+       (map debatchref
             (map last
                  (simplify-batch runner
                                  (typed-egg-batch-extractor (if (*egraph-platform-cost*)

src/core/patch.rkt

@@ -24,7 +24,7 @@
   (define reprs
     (for/list ([approx (in-list approxs)])
       (define prev (car (alt-prevs approx)))
-      (repr-of (batchref->expr (alt-expr prev)) (*context*))))
+      (repr-of (debatchref (alt-expr prev)) (*context*))))
 
   ; generate real rules
   (define rules (real-rules (*simplify-rules*)))
@@ -63,15 +63,15 @@
             (match-define (cons _ simplified) outputs)
             (define prev (car (alt-prevs altn)))
             (for ([expr (in-list simplified)])
-              (define spec (prog->spec (batchref->expr (alt-expr prev))))
+              (define spec (prog->spec (debatchref (alt-expr prev))))
               (define idx
                 (batch-push! global-batch-mutable
                              (approx (mutable-batch-munge! global-batch-mutable spec)
                                      (batchref-idx expr))))
               (sow (alt (batchref global-batch idx) `(simplify ,runner #f #f) (list altn) '()))))))
 
   ; Commit changes to global-batch
-  (set-batch-nodes! global-batch (list->vector (reverse (mutable-batch-nodes global-batch-mutable))))
+  (batch-copy-mutable-nodes! global-batch global-batch-mutable)
   ; End of global-batch modification
   ; ---------------------------------
 
@@ -93,7 +93,7 @@
 (define (taylor-alts altns global-batch)
   (define exprs
     (for/list ([altn (in-list altns)])
-      (prog->spec (batchref->expr (alt-expr altn)))))
+      (prog->spec (debatchref (alt-expr altn)))))
   (define free-vars (map free-variables exprs))
   (define vars (list->set (append* free-vars)))
 
@@ -121,7 +121,7 @@
             (timeline-stop!))))
 
   ; Commit changes to global-batch
-  (set-batch-nodes! global-batch (list->vector (reverse (mutable-batch-nodes global-batch-mutable))))
+  (batch-copy-mutable-nodes! global-batch global-batch-mutable)
   ; End of global-batch modification
   ; ----------------------------------
   approxs)
@@ -161,7 +161,7 @@
       (,lowering-rules . ((iteration . 1) (scheduler . simple)))))
 
   ; run egg
-  (define exprs (map (compose batchref->expr alt-expr) altns))
+  (define exprs (map (compose debatchref alt-expr) altns))
   (define roots (list->vector (map (compose batchref-idx alt-expr) altns)))
   (define reprs (map (curryr repr-of (*context*)) exprs))
   (timeline-push! 'inputs (map ~a exprs))

src/core/preprocess.rkt

@@ -82,7 +82,7 @@
   (cons start-alt
         (remove-duplicates
          (for/list ([expr (rest simplified)])
-           (alt (batchref->expr expr) `(simplify () ,runner #f #f) (list start-alt) '()))
+           (alt (debatchref expr) `(simplify () ,runner #f #f) (list start-alt) '()))
          alt-equal?)))
 
 ;; See https://pavpanchekha.com/blog/symmetric-expressions.html

src/core/simplify.rkt

@@ -58,7 +58,7 @@
                        (map (lambda (_) 'real) args)
                        `((,(*simplify-rules*) . ((node . ,(*node-limit*)))))))
     (define extractor (typed-egg-batch-extractor default-egg-cost-proc batch))
-    (map (compose batchref->expr last) (simplify-batch runner extractor)))
+    (map (compose debatchref last) (simplify-batch runner extractor)))
 
   (define test-exprs
     '((1 . 1) (0 . 0)