iterators refactorings
authorStefan Israelsson Tampe <stefan.itampe@gmail.com>
Mon, 9 Oct 2017 21:10:27 +0000 (23:10 +0200)
committerStefan Israelsson Tampe <stefan.itampe@gmail.com>
Mon, 9 Oct 2017 21:10:27 +0000 (23:10 +0200)
modules/language/python/for.scm
modules/language/python/list.scm
modules/language/python/module/python.scm
modules/language/python/number.scm
modules/language/python/range.scm
modules/language/python/string.scm
modules/language/python/tuple.scm

index cbbbbeac1d3f029d4017aec79d62c8f028167d95..587b30e345bca2d5726eae7bd787165df1116047 100644 (file)
         (k (lambda () 'None))
         (s))))
 
+(define-method (wrap-in (o <yield>))
+  (let ((out (make <yield>)))
+    (slot-set! out 'k (slot-ref o 'k))
+    (slot-set! out 's (slot-ref o 's))
+    out))
 
 (define-method (next (l <p>))
   ((ref l '__next__)))
    (else
     x)))
 
-
 #;
 (pk
  (for c ((x : (gen '(1 2 3)))) ((s 0))
index b0111c17472c81cc514c66c83f09aa3ce76291a8..e9c301c521ee7a56cb1d30623eca62162ae37455 100644 (file)
 
 (define-method (write (o <py-list>) . l)
   (define port (if (null? l) #t (car l)))
-
     (let* ((l (to-list o)))      
     (if (null? l)
         (format port "[]")
 
 (define-class <py-seq-iter>  () o i n d)
 (define-class <py-list-iter> (<py-list>) i d)
-(define-class <string-iter> () str i d)
 
-;;WRAP-IN
-(define-method (wrap-in (s <string>))
-  (let ((out (make <string-iter>)))
-    (slot-set! out 'str s)
-    (slot-set! out 'i   0)
-    (slot-set! out 'd   1)
-    out))
+(define-method (write (o <py-list-iter>) . l)
+  (define port (if (null? l) #t (car l)))
+  (for ((x : o)) ((l '()))
+       (cons x l)
+       #:final
+       (let ((l (reverse l)))
+         (if (null? l)
+             (format port "iter[]")
+             (format port "iter[~a~{, ~a~}]" (car l) (cdr l))))))
 
+(define-method (write (o <py-seq-iter>) . l)
+  (define port (if (null? l) #t (car l)))
+  (for ((x : o)) ((l '()))
+       (cons x l)
+       #:final
+       (let ((l (reverse l)))
+         (if (null? l)
+             (format port "iter[]")
+             (format port "iter[~a~{, ~a~}]" (car l) (cdr l))))))
+
+
+;;WRAP-IN
 (define-method (wrap-in (o <py-list>))
   (let ((out (make <py-list-iter>)))
     (slot-set! out 'n   (slot-ref o 'n  ))
   (let ((out (make <py-list-iter>)))
     (slot-set! out 'i   (- (slot-ref o 'n) 1))
     (slot-set! out 'vec (slot-ref o 'vec))
-    (slot-set! out 'n   0)
-    (slot-set! out 'd   -1)
-    out))
-
-(define-method (py-reversed (s <string>))
-  (let ((out (make <string-iter>)))
-    (slot-set! out 'str s)
-    (slot-set! out 'i   0)
+    (slot-set! out 'n   (slot-ref o 'n))
     (slot-set! out 'd   -1)
     out))
 
 (define-method (py-reversed (o <p>))
   (aif it (ref o '__reversed__)
-       it
+       (it)
        (let ((a (ref o '__getitem__))
              (n (ref o '__len__)))
          (if (and a n)
 
 (define-method (wrap-in (o <p>))
   (aif it (ref o '__iter__)
-       it
+       (it)
        (let ((a (ref o '__getitem__)))
          (if a
              (let ((ret (make <py-seq-iter>)))
              (next-method)))))
 
 
-(define-method (wrap-in (o <py-list-iter>)) o)
-(define-method (wrap-in (o <string-iter> )) o)
+(define-method (wrap-in (o <py-list-iter>))
+  (let ((out (make <py-list-iter>)))
+    (slot-set! out 'vec (slot-ref o 'vec))
+    (slot-set! out 'i   (slot-ref o 'i))
+    (slot-set! out 'n   (slot-ref o 'n))
+    (slot-set! out 'd   (slot-ref o 'd))
+    out))
+
+(define-method (wrap-in (o <py-seq-iter>))
+  (let ((out (make <py-seq-iter>)))
+    (slot-set! out 'o (slot-ref o 'o))
+    (slot-set! out 'i (slot-ref o 'i))
+    (slot-set! out 'n (slot-ref o 'n))
+    (slot-set! out 'd (slot-ref o 'd))
+    out))
+
+
+        
 (define-method (wrap-in (o <py-seq-iter> )) o)
 
 ;;NEXT
       (slot-set! o 'i (+ i d))
       r)))
         
-(define-method (next (o <string-iter>))
-  (let ((i   (slot-ref o 'i  ))
-        (d   (slot-ref o 'd))
-        (str (slot-ref o 'str)))
-    (if (> d 0)
-        (if (< i (string-length str))
-            (let ((ret (string-ref str i)))
-              (slot-set! o 'i (+ i d))
-              (list->string (scm-list ret)))
-            (throw StopIteration))
-        (if (>= i 0)
-            (let ((ret (string-ref str i)))
-              (slot-set! o 'i (+ i d))
-              (list->string (scm-list ret)))
-            (throw StopIteration)))))
-
 (define-method (next (o <py-list-iter>))
   (let ((i   (slot-ref o 'i  ))
         (d   (slot-ref o 'd))
               (slot-set! o 'i (+ i 1))
               ret)
             (throw StopIteration))
-        (if (>= i n)
+        (if (>= i 0)
             (let ((ret (vector-ref vec i)))
               (slot-set! o 'i (- i 1))
               ret)
index 0dab70937347bf7c256a8583809e3fe1dbc67132..ef3b190dad465a06cd22bad5a974e3f3b7fa2cdb 100644 (file)
   #:use-module (language python range            )
   #:use-module (language python tuple            )
 
-  #:replace (list abs min max hash)
+  #:replace (list abs min max hash round)
   #:re-export (Exception StopIteration send sendException next
                          GeneratorExit sendClose RuntimeError
                          len dir next dict None property range
                          tuple
                         )
-  #:export (print repr complex float int round
+  #:export (print repr complex float int
                   set all any bin callable reversed
                   chr classmethod staticmethod
                   divmod enumerate filter format
                   getattr hasattr hex isinstance
-                  iter map sum id input oct ord pow super))
+                  iter map sum id input oct ord pow super
+                  sorted))
 
 (define-syntax-rule (aif it p x y) (let ((it p)) (if it x y)))
 
 (define max  py-max)
 (define list pylist)
 (define reversed py-reversed)
+(define (key-id x) x)
+(define* (sorted it #:key (key key-id) (reverse #f))
+  (define l (to-pylist '()))
+  (for ((x : it)) () (pylist-append! l x))
+  (pylist-sort! l #:key key #:reverse reverse)
+  l)
+
+  
+
+  
index 45a3cf4e3b4486028ccf534c9c8a6053a1697800..d0218d360c91c1e583d211b23c0c81127b39d903 100644 (file)
 (define-method (py-floor (o1 <integer>)) o1)
 (define-method (py-floor (o1 <number> )) )
 (define-method (py-trunc (o1 <integer>)) (exact->inexact o1))
-(define-method (py-trunc (o1 <number> )) o1)
+(define-method (py-trunc (o1 <number> ))
+  (floor o1))
 
 (define-syntax-rule (u0 f)
   (begin
     l))
 
 (define* (py-round x #:optional (digits 0))
-  (let* ((f (expt 1.0 digits))
-         (a (if (< x 0) -0.5 0.5))
-         (x (py-trunc (+ a (* x f)))))
-    (/ x f)))
+  (let* ((f (expt 10.0 digits)))
+    (if (equal? digits 0)
+        (round x)
+        (/ (round (* x f)) f))))
          
 (define-method (py-bin (o <integer>))
   (number->string o 2))
index 154e6159ac35eb2c11e52706adafbf940defb351..45a10696018e88a044aa1c781a2474a585181813 100644 (file)
          (set self '_c k)))))))
 
   (define __iter__
-    (make-generator range
+    (make-generator (self)
       (lambda (yield self)
         (let* ((a  (ref self '_a))
                (b  (ref self '_b))
                (c  (ref self '_c))
-               (op (if (> c 0) < >)))
-          (let lp ((i a))
+               (aa (if (> c 0) a (- a 1)))
+               (op (if (> c 0) < >=)))
+          (let lp ((i aa))
             (if (op i b)
                 (begin
                   (yield i)
                   (lp (+ i c)))))))))
 
+  (define __reversed__
+    (lambda (self)
+      (__getslice__ self None None -1)))
+
   (define __repr__
     (lambda (self)
       (format #f "range(~a,~a,~a)"
index 589f1e731cfb5a63b37678ad3c9784786b00f1d7..d8f4da71bbce9983927ae4499b2d8510d1be28c8 100644 (file)
@@ -5,6 +5,7 @@
   #:use-module (ice-9 match)
   #:use-module (language python list)
   #:use-module (language python exceptions)
+  #:use-module (language python for)
   #:use-module (parser stis-parser)
   #:export (py-format py-capitalize py-center py-endswith
                       py-expandtabs py-find py-rfind
 (define-method (equal? x (o <py-string>))
   (equal? (slot-ref o 'str) x))
 
+(define-class <string-iter> (<py-string>) str i d)
+
+(define-method (write (o <string-iter>) . l)
+  (define port (if (null? l) #t (car l)))
+  (for ((x : o)) ((l '()))
+       (cons (string-ref x 0) l)
+       #:final
+       (format port "iter(~s)" (list->string (reverse l)))))
+
+(define-method (wrap-in (o <string-iter> ))
+  (let ((out (make <string-iter>)))
+    (slot-set! out 'str (slot-ref o 'str))
+    (slot-set! out 'i   (slot-ref o 'i))
+    (slot-set! out 'd   (slot-ref o 'd))
+    out))
+
+(define-method (wrap-in (s <string>))
+  (let ((out (make <string-iter>)))
+    (slot-set! out 'str s)
+    (slot-set! out 'i   0)
+    (slot-set! out 'd   1)
+    out))
+
+(define-method (py-reversed (s <string>))
+  (let ((out (make <string-iter>)))
+    (slot-set! out 'str s)
+    (slot-set! out 'i   (- (string-length s) 1))
+    (slot-set! out 'd   -1)
+    out))
+
+(define-method (next (o <string-iter>))
+  (let ((i   (slot-ref o 'i  ))
+        (d   (slot-ref o 'd))
+        (str (slot-ref o 'str)))
+    (if (> d 0)
+        (if (< i (string-length str))
+            (let ((ret (string-ref str i)))
+              (slot-set! o 'i (+ i d))
+              (list->string (list ret)))
+            (throw StopIteration))
+        (if (>= i 0)
+            (let ((ret (string-ref str i)))
+              (slot-set! o 'i (+ i d))
+              (list->string (list ret)))
+            (throw StopIteration)))))
+
 (define (pystring-listing)
   (let ((l (to-pylist
             (map symbol->string
index 9675a27e39ecae6d0ea4790146ba7ca1be2f6a4a..87a6ed0599143497caa4fea1e11cf9eef06bc8d3 100644 (file)
 (define-method (py-class (o <py-tuple>) tuple))
 (define-method (equal? (o1 <py-tuple>) o2) (equal? (slot-ref o1 'l) o2))
 (define-method (equal? o1 (o2 <py-tuple>)) (equal? o1 (slot-ref o2 'l)))
+(define-method (wrap-in (o <py-tuple>))
+  (wrap-in (slot-ref o 'l)))
 
 (define-python-class tuple (<py-tuple>)
   (define __init__
     (case-lambda
-     ((self)
-      (slot-set! self 'l '()))
-     ((self it)
-      (slot-set! self 'l
-                (for ((x : it)) ((l '()))
-                     (cons x l)
-                     #:final
-                     (reverse l))))))
+      ((self)
+       (slot-set! self 'l '()))
+      ((self it)
+       (slot-set! self 'l
+                  (for ((x : it)) ((l '()))
+                       (cons x l)
+                       #:final
+                       (reverse l))))))
   (define __repr__
     (lambda (self) (format #f "~a" (slot-ref self 'l)))))