reverse! count
authorStefan Israelsson Tampe <stefan.itampe@gmail.com>
Mon, 18 Sep 2017 17:13:34 +0000 (19:13 +0200)
committerStefan Israelsson Tampe <stefan.itampe@gmail.com>
Mon, 18 Sep 2017 17:13:34 +0000 (19:13 +0200)
modules/language/python/compile.scm
modules/language/python/list.scm

index 46a9199611e09d90084a2d65ec57be5efd3ec10b..9076e61aefb793f8a392139d1de3f483af16173f 100644 (file)
   (case x
     ;; Lists
     ((append)  (L 'pylist-append!))
-    ((count)   (L 'pylist-count!))
+    ((count)   (L 'pylist-count))
     ((extend)  (L 'pylist-extend!))
     ((index)   (L 'pylist-index))
     ((pop)     (L 'pylist-pop!))
     (() '())
     ((x . l)
      (let ((is-fkn? (match l
+                      ((#f) #t)
                       (((#:arglist . _) . _)
                        #t)
                       (_
            (list e))
           ((x . trailer)
            (let ((is-fkn? (match trailer
+                            ((#f) #t)
                             (((#:arglist . _) . _)
                              #t)
                             (_
index 8b25077fa682f22c99324a86af8d2e7c45993862..ac35e889fa3cafe1d1b4c61283657e51b1c5e537 100644 (file)
@@ -7,10 +7,13 @@
   #:use-module (language python try)
   #:use-module (language python exceptions)
   #:export (to-list pylist-ref pylist-set! pylist-append!
-                    pylist-slice pylist-subset!))
+                    pylist-slice pylist-subset! pylist-reverse!
+                    pylist-pop! pylist-count))
 
 (define-syntax-rule (aif it p x y) (let ((it p)) (if it x y)))
 
+(define-class <py-list> () vec n)
+
 (define-method (to-list x)
   (if (vector? x)
       (vector->list x)
     (lambda x
       (reverse l))))
 
-(define-class <py-list> () vec n)
+(define-method (to-list (x <py-list>))
+  (let ((vec (slot-ref x 'vec))
+        (n   (slot-ref x 'n)))
+    (let lp ((i 0))
+      (if (< i n)
+          (cons (vector-ref vec i) (lp (+ i 1)))
+          '()))))
 
 (define-method (to-pylist (l <py-list>))
   l)
 
+
 (define-method (to-pylist (l <pair>))
   (let* ((n   (length l))
          (vec (make-vector (* 2 n)))
   (raise 'NotSupportedOP '__append__))
 
 (define-method (pylist-append! (o <p>) n . l)
-  (aif it (ref o '__append__)
-       (it n)
-       (aif it (ref o 'append)
-            (apply it n l)
-            (error "no append"))))
-       
+  (aif it (ref o 'append)
+       (apply it n l)
+       (error "no append")))
     
-(define-method (to-list (x <py-list>))
-  (let ((vec (slot-ref x 'vec))
-        (n   (slot-ref x 'n)))
-    (let lp ((i 0))
-      (if (< i n)
-          (cons (vector-ref vec i) (lp (+ i 1)))
-          '()))))
     
 
 (define-method (write (o <py-list>) . l)
     (slot-set! o 'vec vec)
     o))
 
+
 (define-method (+ (o1 <pair>) (o2 <pair>))
   (append o1 o2))
-           
+
+(define-method (+ (o1 <string>) (o2 <string>))
+  (string-append o1 o2))
+
+(define-method (* (o1 <py-list>) (x <integer>))
+  (let* ((vec  (slot-ref o1 'vec))
+         (n    (slot-ref o1 'n))
+         (n2   (* n x))
+         (vec2 (make-vector (* 2 n2)))
+         (o    (make <py-list>)))
+
+    (let lp1 ((i 0) (j 0))
+      (if (< i x)
+          (let lp2 ((j j) (k 0))
+            (if (< k n)
+                (begin
+                  (vector-set! vec2 j (vector-ref vec k))
+                  (lp2 (+ j 1) (+ k 1)))
+                (lp1 (+ i 1) j)))))
     
+    (slot-set! o 'n   n2  )
+    (slot-set! o 'vec vec2)
+    o))
+
+(define-method (* (vec <string>) (x <integer>))
+  (let* ((n    (string-length vec))
+         (n2   (* n x))
+         (vec2 (make-string n2)))
+
+    (let lp1 ((i 0) (j 0))
+      (if (< i x)
+          (let lp2 ((j j) (k 0))
+            (if (< k n)
+                (begin
+                  (string-set! vec2 j (string-ref vec k))
+                  (lp2 (+ j 1) (+ k 1)))
+                (lp1 (+ i 1) j)))))
+    vec2))
+
+(define-method (* (l <pair>) (x <integer>))
+  (let lp1 ((i 0))
+    (if (< i x)
+        (let lp2 ((k l))
+            (if (pair? k)
+                (cons (car k) (lp2 (cdr k)))                      
+                (lp1 (+ i 1))))
+        '())))
+
+
+(define-method (+ (o1 <pair>) (o2 <pair>))
+  (append o1 o2))
+
+(define-method (+ (o1 <string>) (o2 <string>))
+  (string-append o1 o2))
+
+;;REVERSE
+(define-method (pylist-reverse! (o <py-list>))
+  (let* ((N   (slot-ref o 'n))
+         (M   (- N 1))
+         (n   (floor-quotient N 2))
+         (vec (slot-ref o 'vec)))
+    (let lp ((i 0))
+      (if (< i n)
+          (let ((swap (vector-ref vec i))
+                (k (- M i)))
+            (vector-set! vec i (vector-ref vec k))
+            (vector-set! vec k swap))))))
+
+(define-method (pylist-reverse! (o <p>)) ((ref o 'reverse)))
+
+;;POP!
+(define-method (pylist-pop! (o <py-list>))
+  (let* ((n   (slot-ref o 'n))
+         (m   (- n 1))
+         (vec (slot-ref o 'vec)))
+    (if (> n 0)
+        (let ((ret (vector-ref vec m)))
+          (slot-set! o 'n m)
+          (vector-set! vec m #f)
+          ret)
+        (raise IndexError "pop from empty list"))))
+
+(define-method (pylist-pop! (o <p>)) ((ref o 'pop)))
+
+;;COUNT
+(define-method (pylist-count (o <py-list>) q)
+  (let* ((n   (slot-ref o 'n))
+         (vec (slot-ref o 'vec)))
+    (let lp ((i 0) (sum 0))
+      (if (< i n)
+          (if (equal? (vector-ref vec i) q)
+              (lp (+ i 1) (+ sum 1))
+              (lp (+ i 1) sum      ))
+          sum))))
+
+(define-method (pylist-count (s <string>) q)
+  (let* ((n   (string-length s))
+         (q   (if (and (string? q) (= (string-length q) 1))
+                  (string-ref q 0))))
+    (let lp ((i 0) (sum 0))
+      (if (< i n)
+          (if (eq? (string-ref s i) q)
+              (lp (+ i 1) (+ sum 1))
+              (lp (+ i 1) sum      ))
+          sum))))
+
+(define-method (pylist-count (l <pair>) q)
+    (let lp ((l l) (sum 0))
+      (if (pair? l)
+          (if (eq? (car l) q)
+              (lp (cdr l) (+ sum 1))
+              (lp (cdr l) sum      ))
+          sum)))
 
-         
+(define-method (pylist-count (o <p>) q) ((ref o 'count) q))