tuple
authorStefan Israelsson Tampe <stefan.itampe@gmail.com>
Fri, 6 Oct 2017 13:31:14 +0000 (15:31 +0200)
committerStefan Israelsson Tampe <stefan.itampe@gmail.com>
Fri, 6 Oct 2017 13:31:14 +0000 (15:31 +0200)
modules/language/python/list.scm
modules/language/python/module/python.scm
modules/language/python/string.scm

index 5b4daf0f162eb13b45817a7122ac44b2b5939e6c..36d15e9c90d06c8981dd3dc96ffcc3d87a42d9b2 100644 (file)
@@ -1,8 +1,10 @@
 (define-module (language python list)
   #:use-module (ice-9 match)
+  #:use-module (ice-9 control)
   #:use-module (oop pf-objects)
   #:use-module (oop goops)
   #:use-module (language python hash)
+  #:use-module (language python tuple)
   #:use-module (language python exceptions)
   #:use-module (language python yield)
   #:use-module (language python for)
@@ -21,7 +23,7 @@
 
 (define-syntax-rule (aif it p x y) (let ((it p)) (if it x y)))
 
-(define-class <py-list> () vec n)
+(define-class <py-list>  () vec n)
 
 (define-method (pylist-delete! (o <py-list>) k)
   (let* ((n (slot-ref o 'n))
@@ -60,8 +62,7 @@
        (next-method)))
 
 
-(define-method (to-list (x <pair>))
-  x)
+(defpair (to-list x) x)
 
 (define-method (to-list (x <yield>))
   (define l '())
@@ -84,7 +85,7 @@
 (define-method (to-pylist (l <py-list>))
   l)
 
-(define-method (to-pylist (l <pair>))
+(defpair (to-pylist l)
   (let* ((n   (length l))
          (vec (make-vector (* 2 n)))
          (o   (make <py-list>)))
       (vector-ref (slot-ref o 'vec) n)
       (raise IndexError)))
 
-(define-method (pylist-ref (o <pair>) n)
-  (define n (if (< n 0) (+ (length o) n)))
-  (list-ref o n))
+(defpair (pylist-ref o n)
+  (list-ref o (if (< n 0) (+ (length o) n) n)))
 
 (define-method (pylist-ref (o <vector>) n)
   (vector-ref o n))
       (vector-set! (slot-ref o 'vec) n val)
       (raise IndexError)))
 
-(define-method (pylist-set! (o <pair>) n val)
+(defpair (pylist-set! o n val)
   (list-set! o n val))
 
-(define-method (pylist-set! (o <vector>) n val)
+(defpair (pylist-set! o 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)))))
 
-(define-method (pylist-slice (o <pair>) n1 n2 n3)
+(defpair (pylist-slice o n1 n2 n3)
   (to-list
    (pylist-slice (to-pylist o) n1 n2 n3)))
 
 (define-method (+ (o1 <pair>) (o2 <pair>))
   (append o1 o2))
 
+(define-method (+ (o1 <py-tuple>) o2)
+  (+ (slot-ref o1 'l) o2))
+
+(define-method (+ o2 (o1 <py-tuple>))
+  (+ o2 (slot-ref o1 'l)))
+
 (define-method (+ (o1 <string>) (o2 <string>))
   (string-append o1 o2))
 
                 (lp1 (+ i 1) j)))))
     vec2))
 
-(define-method (* (x <integer>) (l <pair>)) (* l x))
+(define-method (* (x <integer> ) (l <pair>)) (* l x))
+(define-method (* (x <py-tuple>) l) (* (slot-ref x 'l) l))
+(define-method (* l (x <py-tuple>)) (* l (slot-ref x 'l)))
 (define-method (* (l <pair>) (x <integer>))
   (let lp1 ((i 0))
     (if (< i x)
               (lp (+ i 1) sum      ))
           sum))))
 
-(define-method (pylist-count (l <pair>) q)
+(defpair (pylist-count l q)
     (let lp ((l l) (sum 0))
       (if (pair? l)
           (if (eq? (car l) q)
                   (raise ValueError "could not find value in index fkn")))
             (raise IndexError "index out of scop in index fkn"))))))
 
-(define-method (pylist-index (o <pair>) val . l)
+(defpair (pylist-index o val . l)
   (let* ((n   (length o))
          (f   (lambda (m) (if (< m 0) (+ m n) m))))
     (call-with-values
 
 #:len
 
-(define-method (len (l <pair>  ))  (length l))
+(defpair (len l)  (length l))
 (define-method (len (v <vector>))  (vector-length v))
 (define-method (len (s <string>))  (string-length s))
 (define-method (len (o <py-list>)) (slot-ref o 'n))
        (it)
        (next-method)))
 
-(define-method (in x (l <pair>))   (member x l))
+(define-method (in x (l <py-tuple>)) (member x (slot-ref l 'l)))
+(define-method (in x (l <pair>))     (member x l))
 (define-method (in x (l <vector>))
   (define n (vector-length l))
   (let lp ((i 0))
             (lp (+ i 1)))
         #f)))
 
-(define-method (in x (s <string>))
-  (let ((n (string-length s))
-        (x (if (string? x) (string-ref x 0) x)))
-    (let lp ((i 0))
-      (if (< i n)
-          (if (equal? x (string-ref s i))
-              #t
-              (lp (+ i 1)))
-          #f))))
+(define-method (in (x <string>) (s <string>))
+  (string-contains s x))
+
+(define-method (in (x <char>) (s <string>))
+  (let/ec ret
+    (string-for-each
+     (lambda (ch)
+       (if (eq? ch x)
+          (ret #t)))
+     s))
+  #f)
 
 (define-method (in x (o <py-list>))
   (define l (slot-ref o 'vec))
        (it x)
        (next-method)))
 
-(define-syntax-rule (defgen (op o1 o2) code ...)
+(define-syntax-rule (defgen (op r s o1 o2) code ...)
   (begin
     (define-method (op (o1 <py-list>) (o2 <py-list>)) code ...)
     (define-method (op (o1 <pair>)   (o2 <pair>  )) code ...)
+    (define-method (op (o1 <py-tuple>) o2)
+      (op (slot-ref o1 'l) o2))
+    (define-method (op o2 (o1 <py-tuple>))
+      (op o2 (slot-ref o1 'l)))
     (define-method (op (o1 <vector>) (o2 <vector>)) code ...)
     (define-method (op (o1 <p>)      o2)
       (aif it (ref o1 'r)
            (it o2)
+           (next-method)))
+    (define-method (op o1 (o2 <p>))
+      (aif it (ref o2 's)
+           (it o1)
            (next-method)))))
 
-(defgen (< o1 o2)
+(defgen (< __le__ __gt__ o1 o2)
   (let ((n1 (len o1))
         (n2 (len o2)))
     (for ((x1 : o1) (x2 : o2)) ()
       #:final
       (< n1 n2))))
 
-(defgen (<= o1 o2)
+(defgen (<= __lt__ __ge__ o1 o2)
   (let ((n1 (len o1))
         (n2 (len o2)))
     (for ((x1 : o1) (x2 : o2)) ()
       #:final
       (<= n1 n2))))
 
-(defgen (> o1 o2)
+(defgen (> __ge__ __lt__ o1 o2)
   (let ((n1 (len o1))
         (n2 (len o2)))
     (for ((x1 : o1) (x2 : o2)) ()
       #:final
       (> n1 n2))))
 
-(defgen (>= o1 o2)
+(defgen (>= __gt__ __le__ o1 o2)
   (let ((n1 (len o1))
         (n2 (len o2)))
     (for ((x1 : o1) (x2 : o2)) ()
index fd411e96a7bb1fefd8a2514236f9c72b94ec2966..c391907af88b4506c59c0e73c844b48f2c9255ac 100644 (file)
   #:use-module (language python hash             )
   #:use-module (language python property         )
   #:use-module (language python range            )
+  #:use-module (language python tuple            )
 
-  #:replace (list abs min max)
+  #:replace (list abs min max hash)
   #:re-export (Exception StopIteration send sendException next
                          GeneratorExit sendClose RuntimeError
-                         len dir next dict None property range)
+                         len dir next dict None property range
+                        tuple)
   #:export (print repr complex float int round
                   set all any bin callable
                   chr classmethod staticmethod
                   divmod enumerate filter format
-                  getattr hasattr hash hex isinstance
+                  getattr hasattr hex isinstance
                   iter map sum id input oct ord pow super))
 
 (define-syntax-rule (aif it p x y) (let ((it p)) (if it x y)))
index 6ac8874a27bb896c1a533b9d354126d2a05ff5af..589f1e731cfb5a63b37678ad3c9784786b00f1d7 100644 (file)
     (pylist-sort! l)
     l))
 
+