itertools fully debugged
authorStefan Israelsson Tampe <stefan.itampe@gmail.com>
Fri, 30 Mar 2018 19:09:59 +0000 (21:09 +0200)
committerStefan Israelsson Tampe <stefan.itampe@gmail.com>
Fri, 30 Mar 2018 19:09:59 +0000 (21:09 +0200)
modules/language/python/module.scm
modules/language/python/module/itertools.scm

index 0a4ae2ea74a666a2718130a339b2e9e428984b9a..2940a9a17acff8449e9afff10370a526126c4f26 100644 (file)
       (if (rawref self '_module)
          (let ((k (_k k))
                (m (_m self)))
-           (let ((x (pk (module-ref m k e))))
+           (let ((x (module-ref m k e)))
              (if (eq? e x)
                  (fail)
                  x)))
index c32f99cf5277fdb5c68f6db65d57cc43884c6f0f..76794595902fc4aba6e3061ea27535e25c33d186 100644 (file)
                  combination_with_replacement))
 
 (define count
-  (make-generator ll
-    (lambda* (yield start #:optional (step 1))
-      (let lp ((i start))
-       (yield i)
-       (lp (+ i step))))))
+  (lambda* (start #:optional (step 1))
+    ((make-generator ()
+     (lambda (yield)
+       (let lp ((i start))
+         (yield i)
+         (lp (+ i step))))))))
 
 (define cycle
   (make-generator (p)
        (lp)))))
 
 (define repeat
-  (make-generator
-   (lambda* (yield e #:optional (n -1))
-     (let lp ((i 0))
-       (if (not (= i n))
-          (begin
-            (yield e)
-            (lp (+ i 1))))))))
+  (lambda* (e #:optional (n -1))
+    ((make-generator ()
+     (lambda (yield)                
+       (let lp ((i 0))
+         (if (not (= i n))
+             (begin
+               (yield e)
+               (lp (+ i 1))))))))))
 
 (define accumulate
-  (make-generator ll
-   (lambda* (yield p #:optional (f +))
-     (for ((x : p)) ((s 0) (first? #t))
-         (if first?
-             (begin
-               (yield x)
-               (values x #f))
-             (let ((s (f x s)))
-               (yield s)
-               (values s #f)))))))
-
+  (lambda* (p #:optional (f +))
+    ((make-generator ()
+     (lambda (yield)                
+       (for ((x : p)) ((s 0) (first? #t))
+            (if first?
+                (begin
+                  (yield x)
+                  (values x #f))
+                (let ((s (f x s)))
+                  (yield s)
+                  (values s #f)))))))))
+  
 (define-python-class chain ()
   (define __call__
-    (make-generator ll
-     (lambda (yield . l)
-       (let lp ((l l))
-        (if (pair? l)
-            (begin
-              (for ((x : (car l))) ()
-                   (yield x))
-              (lp (cdr l))))))))
+    (lambda (self . l)
+      ((make-generator ()
+       (lambda (yield)
+         (let lp ((l l))
+          (if (pair? l)
+               (begin
+                 (for ((x : (car l))) ()
+                      (yield x))
+                 (lp (cdr l))))))))))
 
   (define from_iterable
     (make-generator (i)
 
 (define none (list 'none))
 (define groupby
-  (make-generator l
-   (lambda* (yield seq #:optional (key (lambda (x) x)))
-     (for ((x : seq)) ((k none) (l '()))
-         (if (eq? k none)
-             (values (key x) (list x))
-             (let ((kk (key x)))
-               (if (equal? k kk)
-                   (values k (cons x l))
-                   (begin
-                     (yield k (reverse l))
-                     (values kk (list x))))))
-         #:final
-         (if (not (eq? k none))
-             (yield l (reverse l)))))))
-     
+  (lambda* (seq #:optional (key (lambda (x) x)))
+    ((make-generator ()
+     (lambda (yield)                
+       (for ((x : seq)) ((k none) (l '()))
+            (if (eq? k none)
+                (values (key x) (list x))
+                (let ((kk (key x)))
+                  (if (equal? k kk)
+                      (values k (cons x l))
+                      (begin
+                        (yield k (reverse l))
+                        (values kk (list x))))))
+            #:final
+            (if (not (eq? k none))
+                (yield k (reverse l)))))))))
+  
      
 (define isslice
-  (make-generator l
-   (lambda* (yield seq #:optional (start 0) (stop -1) (step 1))
-     (for ((x : seq) (i : (count 0))) ()
-         (if (= i stop) (break))
-         (if (and (>= i start)
-                  (= (modulo (- i start) step) 0))
-             (yield x))))))
+  (lambda* (seq #:optional (start 0) (stop -1) (step 1))
+    ((make-generator ()
+     (lambda (yield)
+       (for ((x : seq) (i : (count 0))) ()
+            (if (= i stop) (break))
+            (if (and (>= i start)
+                     (= (modulo (- i start) step) 0))
+                (yield x))))))))
 
 (define starmap
-  (make-generator
+  (make-generator (f seq)
    (lambda (yield f seq)
      (for ((x : seq)) () (yield (f x))))))
 
               (list it))))))
           
 (define zip_longest
-  (make-generator
-   (lam (yield (* l) (= fillvalue None))
+  (lam ((* l) (= fillvalue None))
+    ((make-generator
+      (lambda (yield)
        (define mkit
-         (make-generator (it)
-          (lambda (yield it)
-            (for ((x : it)) ()
-                 (yield (cons 1 x))
-            (let lp ()
-              (yield (cons 0 0))
-              (lp))))))
+          (lambda (it)
+          ((make-generator ()
+            (lambda (yield)
+              (for ((x : it)) ()
+                    (yield (cons 1 x)))
+               (let lp ()
+                 (yield (cons 0 0))
+                 (lp)))))))
        
        (for ((x : (apply zip (map mkit l)))) ()
             (if (= (apply + (map car x)) 0)
                 (break)
-                (yield (map (lambda (x) (if (= (car x) 0) fillvalue (cdr x)))
-                            x)))))))
+                (yield (map (lambda (y) (if (= (car y) 0) fillvalue (cdr y)))
+                            x)))))))))
        
   
 (def (product (* iterables) (= repeat 1))
      ((make-generator ()
       (lambda (yield)       
-       (let* ((iterables (map iter iterables))
-              (it0       (car iterables)))
-         (try
-          (lambda ()
-            (let lp ((it0 it0) (l (cdr iterables)) (rl (list it0)) (res '()))
-              (let ((x (next it0)))                    
-                (if (pair? l)
-                    (let ((it1.it2 (tee (car l))))
-                      (try
-                       (lambda ()
-                         (lp (cdr it1.it2) (cdr l)
-                             (cons (car it1.it2) rl)
-                             (cons x res)))
-                       (#:except StopIteration =>
-                                 (lambda x
-                                   (lp it0 l rl res)))))
-                    (begin
-                      (yield (reverse (cons x res)))
-                      (raise StopIteration))))))
-          (#:except StopIteration => values)))))))
-                       
+       (let* ((iterables (let lp ((i 1) (l (map iter iterables)))
+                            (if (= i repeat)
+                                l
+                                (let* ((t (map tee  l))
+                                       (h (map car  t))
+                                       (r (map cadr t)))
+                                  (append h (lp (+ i 1) r)))))))
+          (let lp ((l iterables) (ret '()))
+            (if (pair? l)
+                (let ((x.y (tee (car l))))
+                  (for ((x : (car x.y))) ((l (cdr l)))
+                       (lp l (cons x ret))
+                       #:final (cons (cadr x.y) l)))
+                (yield (reverse ret)))))))))
+                       
 (def (permutation it (= r None))
      ((make-generator ()
       (lambda (yield)