iterators refactorings

7 files changed, 133 insertions, 58 deletions

diff --git a/modules/language/python/for.scm b/modules/language/python/for.scm
index cbbbbea..587b30e 100644
--- a/modules/language/python/for.scm
+++ b/modules/language/python/for.scm
@@ -97,6 +97,11 @@
         (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__)))
@@ -117,7 +122,6 @@
    (else
     x)))
 
-
 #;
 (pk
  (for c ((x : (gen '(1 2 3)))) ((s 0))
diff --git a/modules/language/python/list.scm b/modules/language/python/list.scm
index b0111c1..e9c301c 100644
--- a/modules/language/python/list.scm
+++ b/modules/language/python/list.scm
@@ -265,7 +265,6 @@
 
 (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 "[]")
@@ -474,16 +473,29 @@
 
 (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  ))
@@ -496,20 +508,13 @@
   (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)
@@ -522,7 +527,7 @@
 
 (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>)))
@@ -533,8 +538,24 @@
              (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
@@ -546,22 +567,6 @@
       (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))
@@ -573,7 +578,7 @@
               (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)
diff --git a/modules/language/python/module/python.scm b/modules/language/python/module/python.scm
index 0dab709..ef3b190 100644
--- a/modules/language/python/module/python.scm
+++ b/modules/language/python/module/python.scm
@@ -23,18 +23,19 @@
   #: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)))
 
@@ -202,3 +203,13 @@
 (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)
+
+  
+
+  
diff --git a/modules/language/python/number.scm b/modules/language/python/number.scm
index 45a3cf4..d0218d3 100644
--- a/modules/language/python/number.scm
+++ b/modules/language/python/number.scm
@@ -124,7 +124,8 @@
 (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
@@ -369,10 +370,10 @@
     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))
diff --git a/modules/language/python/range.scm b/modules/language/python/range.scm
index 154e615..45a1069 100644
--- a/modules/language/python/range.scm
+++ b/modules/language/python/range.scm
@@ -40,18 +40,23 @@
 	  (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)"
diff --git a/modules/language/python/string.scm b/modules/language/python/string.scm
index 589f1e7..d8f4da7 100644
--- a/modules/language/python/string.scm
+++ b/modules/language/python/string.scm
@@ -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
@@ -517,6 +518,52 @@
 (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
diff --git a/modules/language/python/tuple.scm b/modules/language/python/tuple.scm
index 9675a27..87a6ed0 100644
--- a/modules/language/python/tuple.scm
+++ b/modules/language/python/tuple.scm
@@ -11,18 +11,20 @@
 (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)))))