reversed
authorStefan Israelsson Tampe <stefan.itampe@gmail.com>
Mon, 9 Oct 2017 19:40:34 +0000 (21:40 +0200)
committerStefan Israelsson Tampe <stefan.itampe@gmail.com>
Mon, 9 Oct 2017 19:40:34 +0000 (21:40 +0200)
modules/language/python/for.scm
modules/language/python/list.scm
modules/language/python/module/python.scm

index f9cdd1e28054ea29a2d382cbc4a01949be2e0e40..cbbbbeac1d3f029d4017aec79d62c8f028167d95 100644 (file)
 (define-method (next (l <p>))
   ((ref l '__next__)))
 
-(define-method (wrap-in  (x <p>))
-  (aif it (ref x '__iter__ #f)
-       (it)
-       x))
-
 (define-method (wrap-in x)
   (cond
    ((pair? x)
index 36d15e9c90d06c8981dd3dc96ffcc3d87a42d9b2..b0111c17472c81cc514c66c83f09aa3ce76291a8 100644 (file)
@@ -16,8 +16,8 @@
             pylist-pop! pylist-count pylist-extend! len in
             pylist-insert! pylist-remove! pylist-sort!
             pylist-index pylist-null pylist-delete!
-            pylist pylist-listing
-            py-all py-any))
+            pylist pylist-listing py-reversed
+            py-all py-any py-reversed))
 
 (define scm-list list)
 
@@ -40,7 +40,6 @@
     (slot-set! o 'vec (make-vector 0))
     (slot-set! o 'n   0)
     o))
-        
 
 (define-method (py-hash (o <py-list>))
   (let ((n (min complexity (slot-ref o 'n)))
 (defpair (pylist-set! o n val)
   (list-set! o n val))
 
-(defpair (pylist-set! o n val)
+(define-method (pylist-set! (o <vector>) n val)
   (vector-set! o n val))
 
 (define-method (pylist-set! (o <p>) n val)
         (to-list
          (pylist-slice (to-pylist o) n1 n2 n3)))))
 
+
 (defpair (pylist-slice o n1 n2 n3)
   (to-list
    (pylist-slice (to-pylist o) n1 n2 n3)))
 (define-method (equal? o1             (o2 <py-list>)) #f)
 
 
-(define-class <py-list-iter> (<py-list>) i)
-(define-class <string-iter> () str i)
+(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 (wrap-in (o <py-list>))
     (slot-set! out 'n   (slot-ref o 'n  ))
     (slot-set! out 'vec (slot-ref o 'vec))
     (slot-set! out 'i   0)
+    (slot-set! out 'd   1)
+    out))
+
+(define-method (py-reversed (o <py-list>))
+  (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 'd   -1)
+    out))
+
+(define-method (py-reversed (o <p>))
+  (aif it (ref o '__reversed__)
+       it
+       (let ((a (ref o '__getitem__))
+             (n (ref o '__len__)))
+         (if (and a n)
+             (let ((ret (make <py-seq-iter>)))
+               (slot-set! ret 'o a)
+               (slot-set! ret 'i (n))
+               (slot-set! ret 'n -1)
+               (slot-set! ret 'd -1))
+             (next-method)))))
+
+(define-method (wrap-in (o <p>))
+  (aif it (ref o '__iter__)
+       it
+       (let ((a (ref o '__getitem__)))
+         (if a
+             (let ((ret (make <py-seq-iter>)))
+               (slot-set! ret 'o a)
+               (slot-set! ret 'i 0)
+               (slot-set! ret 'n -1)
+               (slot-set! ret 'd 1))
+             (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-seq-iter> )) o)
+
 ;;NEXT
+(define-method (next (o <py-seq-iter>))
+  (let ((i (slot-ref o 'i))
+        (d (slot-ref o 'd))
+        (a (slot-ref o 'a)))
+    (let ((r (a i)))
+      (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 (< i (string-length str))
-        (let ((ret (string-ref str i)))
-          (slot-set! o 'i (+ i 1))
-          (list->string (scm-list ret)))
-        (throw StopIteration))))
+    (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))
         (n   (slot-ref o 'n  ))
         (vec (slot-ref o 'vec)))
-    (if (< i n)
-        (let ((ret (vector-ref vec i)))
-          (slot-set! o 'i (+ i 1))
-          ret)
-        (throw StopIteration))))
+    (if (> d 0)
+        (if (< i n)
+            (let ((ret (vector-ref vec i)))
+              (slot-set! o 'i (+ i 1))
+              ret)
+            (throw StopIteration))
+        (if (>= i n)
+            (let ((ret (vector-ref vec i)))
+              (slot-set! o 'i (- i 1))
+              ret)
+            (throw StopIteration)))))
   
 ;;INSERT
 (define-method (pylist-insert! (o <py-list>) i val)
        (next-method)))
 
 
-#:len
+;; len
+
 
 (defpair (len l)  (length l))
 (define-method (len (v <vector>))  (vector-length v))
index c391907af88b4506c59c0e73c844b48f2c9255ac..0dab70937347bf7c256a8583809e3fe1dbc67132 100644 (file)
   #:re-export (Exception StopIteration send sendException next
                          GeneratorExit sendClose RuntimeError
                          len dir next dict None property range
-                        tuple)
+                         tuple
+                        )
   #:export (print repr complex float int round
-                  set all any bin callable
+                  set all any bin callable reversed
                   chr classmethod staticmethod
                   divmod enumerate filter format
                   getattr hasattr hex isinstance
 (define min  py-min)
 (define max  py-max)
 (define list pylist)
+(define reversed py-reversed)