collections now compiles
authorStefan Israelsson Tampe <stefan.itampe@gmail.com>
Tue, 20 Mar 2018 14:06:43 +0000 (15:06 +0100)
committerStefan Israelsson Tampe <stefan.itampe@gmail.com>
Tue, 20 Mar 2018 14:06:43 +0000 (15:06 +0100)
modules/language/python/compile.scm
modules/language/python/exceptions.scm
modules/language/python/module.scm
modules/language/python/module/collections.scm
modules/language/python/module/operator.scm
modules/oop/pf-objects.scm

index b287e4b1e1f16e9d258e352cd12e8f9a3e7c6fe4..3e7a95a2cc7b407e5a6c12436fae5a2219953d84 100644 (file)
@@ -14,6 +14,7 @@
   #:use-module (language python bytes)
   #:use-module (language python number)
   #:use-module (language python def)
+  #:use-module (language python module)
   #:use-module ((language python with) #:select ())
   #:use-module (ice-9 pretty-print)
   #:export (comp))
@@ -27,7 +28,6 @@
 (define-inlinable (F   x) `(@@ (language python for)     ,x))
 (define-inlinable (E   x) `(@@ (language python exceptions) ,x))
 (define-inlinable (L   x) `(@@ (language python list)    ,x))
-(define-inlinable (A   x) `(@@ (language python array)   ,x))
 (define-inlinable (S   x) `(@@ (language python string)  ,x))
 (define-inlinable (B   x) `(@@ (language python bytes)   ,x))
 (define-inlinable (Se  x) `(@@ (language python set)     ,x))
                                              
   
   ((_ (#:name ((ids ...) . as)) ...)
-   (pk x)
    `(begin
       ,@(map
         (lambda (ids as)            
index 9c7565860389700f74e41686091f6d2b496f7caf..0b91293a17ff6d35ebb147f1bc7b029a12ca5c18 100644 (file)
@@ -6,24 +6,25 @@
                           IndexError KeyError AttributeError
                           SyntaxError SystemException
                           OSError ProcessLookupError PermissionError
-                          None))
+                          None NotImplemented NotImplementedError))
 
 (define-syntax-rule (aif it p x y) (let ((it p)) (if it x y)))
 
-(define StopIteration      'StopIteration)
-(define GeneratorExit      'GeneratorExit)
-(define SystemException    'SystemException)
-(define RuntimeError       'RuntimeError)
-(define IndexError         'IndexError)
-(define ValueError         'ValueError)
-(define None               'None)
-(define KeyError           'KeyError)
-(define TypeError          'TypeError)
-(define AttributeError     'AttributeError)
-(define SyntaxError        'SyntaxError)
-(define OSError            'OSError)
-(define ProcessLookupError 'ProcessLookupError)
-(define PermissionError    'PermissionError)
+(define StopIteration       'StopIteration)
+(define GeneratorExit       'GeneratorExit)
+(define SystemException     'SystemException)
+(define RuntimeError        'RuntimeError)
+(define IndexError          'IndexError)
+(define ValueError          'ValueError)
+(define None                'None)
+(define KeyError            'KeyError)
+(define TypeError           'TypeError)
+(define AttributeError      'AttributeError)
+(define SyntaxError         'SyntaxError)
+(define OSError             'OSError)
+(define ProcessLookupError  'ProcessLookupError)
+(define PermissionError     'PermissionError)
+(define NotImplementedError 'NotImplementedError)
 
 (define-python-class Exception ()
   (define __init__
@@ -42,6 +43,7 @@
                    (ref self '__name__))))))
 
 
+(define NotImplemented (list 'NotImplemented))
 
 
             
index 5da5992c4a0e03fdc97f6668a0c2d6a86cd52a10..9884c2b466aa9c91efa14b7ce8841120400bc973 100644 (file)
 
 (define-syntax-rule (aif it p x y) (let ((it p)) (if it x y)))
 
+(define-syntax-rule (in-scheme x)
+  (let ((lan (current-language)))
+    (dynamic-wind
+       (lambda () (current-language 'scheme))
+       (lambda () x)
+       (lambda () (current-language lan)))))
+
 (define (private mod)
   ((ref mod '__setprivate__) #t))
 (define (public mod)
            (set self '__dict__ self)
            (set self '__name__ (string-join
                                 (map symbol->string (reverse nm)) "."))
-           (let ((_module (resolve-module (reverse l))))
+           (let ((_module (in-scheme (resolve-module (reverse l)))))
              (set self '_export (module-public-interface _module))
              (set self '_module _module)
              (hash-set! _modules l self))))))
   
   (define __iter__
     (lambda (self)
-      (define m (_m obj))
+      (define m (_m self))
       ((make-generator ()
        (lambda (yield)
         (define l '())
           (if (pair? l)
               (begin
                 (apply yield (car l))
-                (lp (cdr l)))))           
-        (hash-for-each yield (slot-ref self 'h))))))))
+                (lp (cdr l)))))))))))
 
 
 
index 601ce7e11a630935e1fbabe1694724dd6597d2cc..c4d5d2a324890b38d841ef28ba65fad2f0bccda0 100644 (file)
@@ -1,35 +1,40 @@
 (define-module (language python module collections)
+  #:use-module (ice-9 control)
   #:use-module (oop pf-objects)
+  #:use-module (oop goops)
   #:use-module (language python module collections abc)
   #:use-module (language python module heapq)
   #:use-module (language python for)
+  #:use-module (language python try)
   #:use-module (language python yield)
   #:use-module (language python def)
   #:use-module (language python list)
   #:use-module (language python string)
   #:use-module (language python dict)
+  #:use-module (language python def)
+  #:use-module (language python set)
+  #:use-module (language python range)
   #:use-module (language python exceptions)
   #:use-module ((language python module python)
-               #:select ((map . pymap)))
-  #:export (abc OrderedDict ChainMap Counter UserDict UserString UserList))
+               #:select ((map . pymap) isinstance reversed classmethod iter
+                         any repr property super sorted))
 
-(define-python-class class-from-dict ()
-  (define __init__
-    (lambda (self d)
-      (set self '__dict__ d))))
+  #:use-module ((language python module operator)
+               #:select (itemgetter))
+  
+  #:re-export (Container Hashable Iterable Iterator Reversable Generator
+                        Sized Callable Collection Sequence MutableSequence
+                        ByteString Set MutableSet Mapping MutableMapping
+                        MappingView ItemsView KeysView ValuesView)
 
-(define abc
-  (class-from-dict
-   (resolve-module (module-public-interface
-                   '(language python module collections abc)))))
+  #:export (OrderedDict ChainMap Counter UserDict UserString UserList))
 
 (define-python-class _OrderedDictKeysView (KeysView)
   (define __reversed__
     (lambda (self)
       ((make-generator ()
          (lambda (yield)
-          (for ((k v : (reversed (reg self '_mapping))))
+          (for ((k v : (reversed (ref self '_mapping)))) ()
                (yield k))))))))
 
 (define-python-class _OrderedDictValuesView (ValuesView)
@@ -37,7 +42,7 @@
     (lambda (self)
       ((make-generator ()
          (lambda (yield)
-          (for ((k v : (reversed (reg self '_mapping))))
+          (for ((k v : (reversed (ref self '_mapping)))) ()
                (yield v))))))))
 
 (define-python-class _OrderedDictItemsView (ItemsView)
     (lambda (self)
       ((make-generator ()
          (lambda (yield)
-          (for ((k v : (reversed (reg self '_mapping))))
+          (for ((k v : (reversed (ref self '_mapping)))) ()
                (yield (list k v)))))))))
 
 (define-inlinable (link) (vector 0 0 0))
-(define-inlinable (get-prev l)    (vector-ref  l 0))
-(define-inlinable (get-next l)    (vector-ref  l 1))
-(define-inlinable (get-key  l)    (vector-ref  l 2))
+(define-inlinable (get-prev  l  ) (vector-ref  l 0))
+(define-inlinable (get-last  l  ) (vector-ref  l 0))
+(define-inlinable (get-first l  ) (vector-ref  l 1))
+(define-inlinable (get-next  l  ) (vector-ref  l 1))
+(define-inlinable (get-key   l  ) (vector-ref  l 2))
 (define-inlinable (set-prev! l v) (vector-set! l 0 v))
 (define-inlinable (set-next! l v) (vector-set! l 1 v))
 (define-inlinable (set-key!  l v) (vector-set! l 2 v))
 
-(define proxy (list 'mu))
-
-(define <dict> (cons <py-hashtable> '_))
-(define dict-set!   (resolve-method-c pylist-set!    <dict>))
-(define dict-ref    (resolve-method-c pylist-ref     <dict>))
-(define dict-del!   (resolve-method-c pylist-delete! <dict>))
-(define dict-pop!   (resolve-method-c pylist-pop!    <dict>))
-(define dict-clear! (resolve-method-c pylist-clear!  <dict>))
+(define <dict> `(,<py-hashtable> . _))
+(define dict-set!   (resolve-method-g pylist-set!    <dict>))
+(define dict-ref    (resolve-method-g pylist-ref     <dict>))
+(define dict-del!   (resolve-method-g pylist-delete! <dict>))
+(define dict-pop!   (resolve-method-g pylist-pop!    <dict>))
+(define dict-clear! (resolve-method-g py-clear       <dict>))
 
 (define-python-class OrderedDict (dict)
   (define __init__
@@ -71,7 +76,7 @@
         (if (> (len args)  1)
             (raise TypeError
                    (format #f
-                           "expected at most 1 arguments, got %d"
+                           "expected at most 1 arguments, got ~a"
                            (len args))))
        
         (try
         (py-apply py-update self (* args) (** kwds))))
 
   (define __setitem__
-    (lambda* (self key value #:key
-                  (dict_setitem dict-set!)
-                  (proxy        #f)
-                  (link         link))
+    (lam (self key value
+              (= dict_setitem dict-set!)
+              (= proxy        #f)
+              (= link         link))    
      (if (in key self)
         (let* ((link (link))
                (root (ref self '__root))
           (dict_setitem self key value)))))
 
   (define __delitem__
-    (lambda* (self key #:key
-                  (dict_delitem dict-set!)
-                  (dict_delitem dict-del!))
+    (lam (self key (= dict_delitem dict-del!))
       (let ((link (pylist-pop! (ref self '__map) key))
            (link_prev (get-prev link))
            (link_next (get-next link)))
        (set-prev! link None))))
   
   (define __iter__
-    (lambda* (self #:key (get-next get-next))
+    (lam (self (= get-next get-next))
       ((make-generator ()
         (lambda (yield)
          (let ((root (ref self '__root)))
         (dict-clear! self))))
 
   (define popitem
-    (lambda* (self #:key (last #t))
+    (lam (self (= last #t))
       (if (= (len self) 0)
          (raise KeyError "dictionary is empty"))
       (let ((root (ref self '__root))) 
                  (dict-pop! self key))))))
   
   (define move_to_end
-    (lambda* (self key #:key (last #t))
+    (lam (self key (= last #t))
       (let* ((link (pylist-ref (ref self '__map) key))
             (prev (get-prev link))
             (next (get-next link)))
   (define __marker (object))
 
   (define pop
-    (lambda* (self key #:key (default __marker))
+    (lam (self key (= default __marker))
       (if (in key self)
          (let ((result (dict-ref self key)))
            (__delitem__ self key)
              default))))
 
   (define setdefault
-    (lambda* (self key #:key (default None))
+    (lam (self key (= default None))
        (if (in key self)
           (dict-ref self key)
           (begin
 
   (define fromkeys
     (classmethod 
-     (lambda* (cls iterable #key (value None))
-      (let ((self (cls)))
-       (for ((key : iterable)) ()
-            (__setitem__ self key value))
-       self))))
+     (lam (cls iterable (= value None))
+         (let ((self (cls)))
+           (for ((key : iterable)) ()
+                (__setitem__ self key value))
+           self))))
   
   (define __eq__
     (lambda (self other)
       (if (isinstance other OrderedDict)
-         (and ((dict-equal? self other)
-              (all (map _equal self other)))
-         ((ref dict '__eq__) self other))))
+         (and (for ((k1 v1 : self) (k2 v2 : other)) ()
+                   (if (not (equal? k1 k2))
+                       (break #f))
+                   #:final #t)
+              (equal? (ref self '_mapping) (ref other '_mapping)))
+         (equal? (ref self '_mapping) other)))))
+              
+
 
 
 (define (u self)
-  (let ((s (set)))
-    (apply (ref s 'union) (ref self 'maps)))
-  s)
+  (let ((s (py-set)))
+    (apply (ref s 'union) (ref self 'maps))
+    s))
 
 (define-python-class ChainMap (MutableMapping)
   (define __init__
   (define __len__
     (lambda (self)
       (len (u self))))
-
+  
 
   (define __iter__
     (lambda (self)
       (iter (u self))))
 
   (define __contains__
-    (lambda (self, key)
-      (for ((m : (ref self 'maps)))
+    (lambda (self key)
+      (for ((m : (ref self 'maps))) ()
           (if (in key m)
               (break #t))
           #:final #f)))
 
   (define __repr__
     (lambda (self)
-      (format #f "~a(~a,~{,~a~})"
-             (ref (ref self '__class__) '__name__)
-             (map (lambda (x) (repr x)) (ref self 'maps)))))
+      (let ((l (map (lambda (x) (repr x)) (ref self 'maps))))
+       (format #f "~a(~a,~{,~a~})"
+               (ref (ref self '__class__) '__name__)
+               (car l)
+               (cdr l)))))
 
   (define fromkeys
     (class-method
     
 
   (define __delitem__
-    (lambda (self, key)
+    (lambda (self key)
       (try
-       (lambda () (pylist-del! (car (ref self 'maps))))
-       #:except KeyError =>
-       (lambda x
-        (raise KeyError
-               (format #f "Key not found in the first mapping: ~a" key))))))
+       (lambda () (pylist-delete! (car (ref self 'maps))))
+       (#:except KeyError =>
+        (lambda x
+          (raise KeyError
+                 (format #f "Key not found in the first mapping: ~a" key)))))))
 
   (define popitem
     (lambda (self)
       (try
        (lambda () (popitem (car (ref self 'maps))))     
-       #:except KeyError =>
-       (lambda x
-        (raise KeyError "No keys found in the first mapping")))))
+       (#:except KeyError =>
+        (lambda x
+         (raise KeyError "No keys found in the first mapping"))))))
 
   (define pop
     (lambda (self key . args)
       (try
-       (lambda () (apply py-pop (car (ref self 'maps)) args))
-       #:except KeyError =>
-       (lambda ()
+       (lambda () (apply pylist-pop! (car (ref self 'maps)) args))
+       (#:except KeyError =>
+       (lambda x
         (raise KeyError
-               (format #f "Key not found in the first mapping: ~ a" key))))))
+               (format #f "Key not found in the first mapping: ~ a" key)))))))
 
   (define clear
     (lambda (self)
             (raise TypeError
                   (format
                    #f
-                   "expected at most 1 arguments, got ~ a"
+                   "expected at most 1 arguments, got ~a"
                    (length  args))))
         ((ref (super Counter self) '__init__))
         (py-apply py-update self (* args) (** kwds))))
     (lambda (self key) 0))
 
   (define most_common
-    (lambda* (self #:key (n None)):
+    (lambda* (self #:key (n None))
        (if (eq? n None)
-            (sorted ((ref self 'items) #:key (_itemgetter 1) #:reverse #t))
-           (nlargest n (py-items self) #:key (_itemgetter 1)))))
+            (sorted ((ref self 'items) #:key (itemgetter 1) #:reverse #t))
+           (nlargest n (py-items self) #:key (itemgetter 1)))))
 
   (define elements
     (lambda (self)
       ((make-generator ()
         (for ((k v : self)) ()
              (if (and (number? v) (integer? v) (> v 0))
-                 (for ((i : range(v))) ()
+                 (for ((i : (range v))) ()
                       (yield k))))))))
 
   (define fromkeys
     (lam (self (* args) (** kwds))
         (if (> (len args) 1)
             (raise TypeError
-                   (format #f "expected at most 1 arguments, got %d"
+                   (format #f "expected at most 1 arguments, got ~a"
                            (len args))))
-        
-        (let ((iterable (pylist-get args o None)))
-         (if (not (eq? iterable None))
-             (if (is-a? iterable <py-dict>)
-                 (for ((elem count : iterable)) ()
-                      (pylist-set! self elem
-                                   (+ count (pylist-get self elem 0))))
-                 (for ((k : iterable)) ()
-                      (pylist-set! self elem
-                                   (+ 1 (pylist-get self elem 0)))))))
+
+        (if (= (len args) 1)
+            (let ((iterable (iter (car args))))
+              (if (not (eq? iterable None))
+                  (if (isinstance iterable <py-hashtable>)
+                      (for ((elem count : iterable)) ()
+                           (pylist-set! self elem
+                                        (+ count (py-get self elem 0))))
+                      (for ((k : iterable)) ()
+                           (pylist-set! self k
+                                        (+ 1 (py-get self k 0))))))))
         
-       (for ((k v : kwds)) ()
-            (pylist-set! self k
-                         (+ count (pylist-get self k 0))))))
+        (for ((k count : kwds)) ()
+             (pylist-set! self k
+                          (+ count (py-get self k 0))))))
   (define subtracts
     (lam (self (* args) (** kwds))
         (if (> (len args) 1)
             (raise TypeError
-                   (format #f "expected at most 1 arguments, got %d"
+                   (format #f "expected at most 1 arguments, got ~a"
                            (len args))))
 
-        (let ((iterable (pylist-get args 0 None)))
+        (let ((iterable (py-get args 0 None)))
           (if (not (eq? iterable None))
-              (if (is-a? iterable <py-dict>)
+              (if (isinstance iterable <py-hashtable>)
                   (for ((elem count : iterable)) ()
                        (pylist-set! self elem
-                                    (- (pylist-get self elem 0) count)))
+                                    (- (py-get self elem 0) count)))
                   (for ((elem : iterable)) ()
                        (pylist-set! self elem
-                                    (- (pylist-get self elem 0) 1))))))
+                                    (- (py-get self elem 0) 1))))))
                
        (for ((k v : kwds)) ()
             (pylist-set! self k
-                         (- (pylist-get self k 0) v)))))
+                         (- (py-get self k 0) v)))))
 
   (define __delitem__
     (lambda (self k)
                   (if (> newcount 0)
                       (pylist-set! result elem newcount))))
            
-           (for ((elem count : other))
+           (for ((elem count : other)) ()
                 (if (and (not (in elem self))
                          (> count 0))
                     (pylist-set! result elem count)))
            
-           return))))
+           result))))
 
   (define __sub__
     (lambda (self other)
                   (if (> newcount 0)
                       (pylist-set! result elem newcount))))
            
-           (for ((elem count : other))
+           (for ((elem count : other)) ()
                 (if (and (not (in elem self))
                          (> count 0))
                     (pylist-set! result elem (- count))))
            
-           return))))
+           result))))
 
   (define __or__
     (lambda (self other)
                          (> count 0))
                     (pylist-set! result elem count)))
            
-           return))))
+           result))))
 
   (define __and__
     (lambda (self other)
                 (let ((newcount (min count (pylist-ref other elem))))
                   (if (> newcount 0)
                       (pylist-set! result elem newcount))))        
-           return))))
+           result))))
 
   (define __pos__
     (lambda (self)
       (let ((result (Counter)))       
-        (for ((elem count : self))
+        (for ((elem count : self)) ()
             (if (> count 0)
                 (pylist-set! result elem count)))
         result)))
   (define _keep_positive
     (lambda (self)
       (define ks
-       (for ((k v : self)) (l '())
+       (for ((k v : self)) ((l '()))
             (if (<= v 0)
                 (cons k l)
                 l)))
       self))
 
   (define __iadd__
-    (lambda (self, other)
-      (for ((elem count : other))
+    (lambda (self other)
+      (for ((elem count : other)) ()
           (pylist-set! self elem
-                       (+ (pylist-get self elem 0) count)))
+                       (+ (py-get self elem 0) count)))
         ((ref self '_keep_positive))))
 
   (define __isub__
-    (lambda (self, other)
-      (for ((elem count : other))
+    (lambda (self other)
+      (for ((elem count : other)) ()
           (pylist-set! self elem
-                       (- (pylist-get self elem 0) count)))
+                       (- (py-get self elem 0) count)))
       ((ref self '_keep_positive))))
 
   (define __ior__
-    (lambda (self, other)
-      (for ((elem count : other))
+    (lambda (self other)
+      (for ((elem count : other)) ()
           (pylist-set! self elem
-                       (max (pylist-get self elem 0) count)))
+                       (max (py-get self elem 0) count)))
       ((ref self '_keep_positive))))
 
   (define __iand__
-    (lambda (self, other)
-      (for ((elem count : other))
+    (lambda (self other)
+      (for ((elem count : other)) ()
           (pylist-set! self elem
-                       (min (pylist-get self elem 0) count)))
+                       (min (py-get self elem 0) count)))
       ((ref self '_keep_positive)))))
 
 (define-python-class UserDict   (dict))
-(define-python-class UserString (py-string))
+(define-python-class UserString (pystring))
 (define-python-class UserList   (py-list))  
 
 
index a22fde4d133c42a0b39ed877ff8d7e690a3c3d68..e506817be02cd61baefd59fa19c7b1fc9978b2cc 100644 (file)
@@ -34,7 +34,7 @@
        (cons (cons k v) l)
        #:final (reverse l)))
 
-(define (asssoc->hash a)
+(define (assoc->hash a)
   (let ((h (make-hash-table)))
     (let lp ((a a))
       (if (pair? a)
                (car as)
                (cdr as))))))
 
-(name-object attrgetter)
-
 (define-python-class itemgetter ()
   (define __init__
     (lambda (self  item . items)
                (ref (ref self '__class__) '__name__)
                (car args) (cdr args))))))
 
-(name-object itemgetter)
-
-
-
 (define-python-class methodcaller ()
   (define __init__
     (lam (self (* args) (** kwargs))
     (lambda (self)
       (list
        (lambda (o name args a)
-        (let ((kwargs (assoc->hash kwargs)))
+        (let ((kwargs (assoc->hash a)))
           (py-apply (ref methodcaller '__init__) o name (* args) (** kwargs))))
        (list
        (ref self '_name)
        (ref self '_args)
-       (hash->assoc (ref self '_kwargs)))))))
+       (hash->assoc (ref self '_kwargs))))))
   
   (define __call__
     (lambda (self obj)
                      #:final (reverse l)))
       (format #f "~a(~a~{,~a~})" cln (car v2) (cdr v2)))))
 
-(name-object methodcaller)
-  
-
 ;; In-place Operations
 (define iadd py-iadd)
 (define iand py-ilogand)
index 0f583268231d45b0fa8fed4462de89b1edaa3b07..36338659918efc30f98c19b3a57d7c089f1b67cb 100644 (file)
@@ -14,7 +14,7 @@
                 py-super-mac py-super py-equal? 
                 *class* *self* pyobject? pytype?
                 type object pylist-set! pylist-ref tr
-               resolve-method rawref rawset
+               resolve-method-g rawref rawset
                 ))
 
 #|
@@ -73,7 +73,7 @@ explicitly tell it to not update etc.
          (((p . ps) . (pp . pps))
           (if (eq? pp '_)
               (mmatch ps pps)
-              (if (is-a? p pp)
+              (if (or (eq? p pp) (is-a? p pp))
                   (cons p (mmatch ps pps))
                   #f)))
          ((() . ())