progressively imporoving the conformance with python3
[software/python-on-guile.git] / modules / language / python / module / python.scm
index 69e02b048ad6b7c030af50b128beb2697e9e8a56..ef42cc6a63ec00612376a2574c8773ac80e66b48 100644 (file)
@@ -4,8 +4,11 @@
   #:use-module (ice-9 readline)
   #:use-module ((oop pf-objects) #:select
                 (<p> <property> class-method static-method ref
-                     py-super-mac type object pylist-ref))
+                     py-super-mac type object pylist-ref define-python-class
+                    object-method))
   #:use-module (language python exceptions       )
+  #:use-module ((language python module string   ) #:select ())
+  #:use-module ((language python module io       ) #:select (open))
   #:use-module (language python def              )
   #:use-module (language python for              )
   #:use-module (language python try              )
   #:use-module (language python range            )
   #:use-module (language python tuple            )
   #:use-module (language python eval             )
+  #:use-module (language python bool             )
 
-  #:replace (list abs min max hash round format)
+  #:replace (list abs min max hash round format map)
   
   #:re-export (StopIteration GeneratorExit RuntimeError
                              Exception ValueError TypeError
                              IndexError KeyError AttributeError
                              send sendException next
                              GeneratorExit sendClose RuntimeError
-                             SyntaxError
+                             SyntaxError bool
                              len dir next dict None property range
                              tuple bytes bytearray eval locals globals
-                             compile exec type object
+                             compile exec type object open
                              )
   
   #:export (print repr complex float int str
                   set all any bin callable reversed
-                  chr classmethod staticmethod
-                  divmod enumerate filter 
-                  getattr hasattr hex isinstance issubclass
-                  iter map sum id input oct ord pow super
-                  sorted zip))
+                  chr classmethod staticmethod objectmethod
+                  divmod enumerate filter
+                  getattr hasattr setattr hex isinstance issubclass
+                  iter sum id input oct ord pow super
+                  sorted zip
+                 ClassMethod StaticMethod Funcobj))
 
 (define-syntax-rule (aif it p x y) (let ((it p)) (if it x y)))
 
 
 (define chr integer->char)
 
+(define objectmethod object-method)
 (define classmethod  class-method)
 (define staticmethod static-method)
 
 (define (enumerate l)
-  (make-generator enumerate
-     (lambda (yield)
+  ((make-generator ()
+    (lambda (yield)
        (for ((x : l)) ((i 0))
             (yield i x)
-           (+ i 1)))))
+           (+ i 1))))))
 
 (define (filter f l)
-  (make-generator enumerate
-    (lambda (yield)
-      (for ((x : l)) ()
-           (if (f x)
-               (yield x))))))
+  ((make-generator ()
+     (lambda (yield)
+       (for ((x : l)) ()
+            (if (f x)
+                (yield x)))))))
 
 (define miss ((@ (guile) list) 'miss))
 
 (define* (getattr a b #:optional (k miss))
-  (let ((r (ref a (symbol->string b) k)))
+  (let ((r (ref a (if (string? b) (string->symbol b) b) k)))
     (if (eq? r miss)
         (raise AttributeError "object/class ~a is missing attribute ~a" a b)
         r)))
 
+(define (setattr a k v)
+  (set a (if (string? k) (string->symbol k) k) v))
+
 (define (hasattr a b)
   (let ((r (ref a (symbol->string b) miss)))
     (not (eq? r miss))))
 
+(define-method (issubclass x y) #f)
 (define-method (issubclass (sub <p>) (cls <p>))
   (aif it (ref cls '__subclasscheck__)
-       (it sub)
-       (is-a? (ref sub '__goops__) (ref cls '__goops__))))
+       (it cls sub)
+       (if (eq? sub cls)
+          #t
+          (is-a? (ref sub '__goops__) (ref cls '__goops__)))))
+
+(define-method (isinstance x y)
+  (if (null? y)
+      #f
+      (if (pair? y)
+         (or (isinstance x (car y))
+             (isinstance x (cdr y)))
+         (is-a? x y))))
+
+(define-method (isinstance (i <integer>) y)
+  (if (issubclass y int)
+      #t
+      (if (pair? y)
+         (or (isinstance i (car y))
+             (isinstance i (cdr y)))
+         (is-a? i y))))
+
+(define-method (isinstance (i <real>) y)
+  (if (issubclass y float)
+      #t
+      (if (pair? y)
+         (or (isinstance i (car y))
+             (isinstance i (cdr y)))
+         (is-a? i y))))
 
+(define-method (isinstance (i <pair>) y)
+  (if (issubclass y tuple)
+      #t
+      (if (pair? y)
+         (or (isinstance i (car y))
+             (isinstance i (cdr y)))
+         (is-a? i y))))
+
+(define-method (isinstance (i <string>) y)
+  (if (issubclass y str)
+      #t
+      (if (pair? y)
+         (or (isinstance i (car y))
+             (isinstance i (cdr y)))
+         (is-a? i y))))
+
+(define-method (isinstance (i <bytevector>) y)
+  (if (issubclass y bytes)
+      #t
+      (if (pair? y)
+         (or (isinstance i (car y))
+             (isinstance i (cdr y)))
+         (is-a? i y))))
+
+
+(define-method (isinstance o (cl <p>))
+  (cond
+   ((eq? cl py-list)
+    (is-a? o <py-list>))
+   (else #f)))
+  
 (define-method (isinstance (o <p>) (cl <p>))
-  (aif it (ref cl '__instancecheck__)
-       (it o)
-       (if (pair? cl)
-           (or
-            (isinstance o (car cl))
-            (isinstance o (cdr cl)))
-           (is-a? (ref (ref o '__class__) '__goops__) cl))))
+  (cond
+   ((ref cl '__instancecheck__) =>
+    (lambda (it)
+      (it o)))
+   ((pair? cl)
+    (or
+     (isinstance o (car cl))
+     (isinstance o (cdr cl))))
+   (else
+    (is-a? o (ref cl '__goops__)))))
+              
+              
 
 (define iter
   (case-lambda
     (syntax-case x ()
       ((map f a ...)
        (with-syntax (((x ...) (generate-temporaries #'(a ...))))
-         #'(make-generator map
-             (lambda (yield)
-               (for ((x : a) ...) () (yield (f x ...))))))))))
+        #'(for ((x : a) ...) ((l '()))
+           (cons (f x ...) l)
+           #:final (py-list (reverse l))))))))
                     
 (define* (sum i #:optional (start 0))
   (for ((x : i)) ((s start))
 (define (id x) (object-address x))
 
 (define (input str)
-  (format #t str)
+  ((@ (guile) format) #t str)
   (readline))
 
 (define (idx x) x)
      (let lp ((l l))
        (match l
          ((it)
-          (for ((x : it)) ((s default) (b default))
+          (for ((x : it)) ((s miss) (b miss))
                (if (eq? s miss)
                    (values (key x) x)
                    (let ((k (key x)))
                          (values s b))))
                #:final
                (if (eq? b miss)
-                   (raise ValueError "min does not work for zero length list")
+                  (if (eq? default miss)
+                      (raise ValueError
+                             "min does not work for zero length list")
+                      default)
                    b)))
          (_ (lp ((@ (guile) list) l))))))
 
      (let lp ((l l))
        (match l
          ((it)
-          (for ((x : it)) ((s default) (b default))
-               (if (eq? default miss)
+          (for ((x : it)) ((s miss) (b miss))
+               (if (eq? s miss)
                    (values (key x) x)
                    (let ((k (key x)))
                      (if (> k s)
                          (values s b))))
                #:final
                (if (eq? b miss)
-                   (raise ValueError "min does not work for zero length list")
+                  (if (eq? default miss)
+                      (raise ValueError
+                             "min does not work for zero length list")
+                      default)
                    b)))
          (_ (lp ((@ (guile) list) l))))))
 
                 (begin
                   (yield (reverse r))
                   (lp))))))))))
-  
+
+(define-python-class ClassMethod  ())
+(define-python-class StaticMethod ())
+(define-python-class Funcobj      ())
+     
+           
+