better guilemod
authorStefan Israelsson Tampe <stefan.itampe@gmail.com>
Thu, 6 Dec 2018 19:41:22 +0000 (20:41 +0100)
committerStefan Israelsson Tampe <stefan.itampe@gmail.com>
Thu, 6 Dec 2018 19:41:22 +0000 (20:41 +0100)
modules/language/python/compile.scm
modules/language/python/def.scm
modules/language/python/guilemod.scm
modules/language/python/module.scm
modules/language/python/module/f.py
modules/language/python/string.scm

index e291e34..06e529b 100644 (file)
       (fold f (f (car l) init) (cdr l))
       init))
 
-(define do-pr #f)
+(define do-pr #t)
 
 (define (pr . x)
   (if do-pr
    `(,(G 'begin) ,(exp vs a) ,(exp vs (cons #:comma l)))))
   
  (#:import
-  ((_ (#:from (() . nm) . #f))
+  ((_ (#:from (() () . nm) . #f))
    (let* ((xl (map (lambda (nm) (exp vs nm)) nm))
           (l  `(language python module ,@xl)))
 
        (if (eq? ? #t) (for-each dont-warn (get-exported-symbols l)))       
        `(,(C 'use) ,? ,l ,l))))
   
-  ((_ (#:from (() . nm)  l))
+  ((_ (#:from (() () . nm)  l))
    ;; Make sure to load the module in
    (let* ((xl  (map (lambda (nm) (exp vs nm)) nm))
           (ll `(language python module ,@xl)))
       
       ((_ v (#:apply x ...) . l)
        #'(ref-x (py-apply v x ...) . l))
-      
-      ((_ v (#:apply x ...) . l)
-       #'(ref-x (py-apply v x ...) . l))
-      
+            
       ((_ v (#:vecref x) . l)
        #'(ref-x (pylist-ref v x) . l))
       
index 25edc7e..7e97d22 100644 (file)
@@ -1,4 +1,5 @@
 (define-module (language python def)
+  #:use-module (ice-9 pretty-print)
   #:use-module (oop pf-objects)
   #:use-module (language python for)
   #:use-module (language python exceptions)
                            ((k ...) (map car kv))
                            ((s ...) (map ->kw (map car kv)))
                            ((v ...) (map cdr kv)))
-             #`(object-method
-                (lambda* (#,@as . l)                     
-                 (call-with-values (lambda () (get-akw l))
-                   (lambda (ww* kw)
-                     (let*-values (((ww* k) (take-1 #,(null? ww-) ww* kw s v))
+               #`(object-method
+                  (lambda* (#,@as . l)                     
+                    (call-with-values (lambda () (get-akw l))
+                      (lambda (ww* kw)
+                        (let*-values (((ww* k) (take-1 #,(null? ww-) ww*
+                                                       kw s v))
                                ...)
-                       (let ((ww ww*)
-                             (kw (pytonize kw)))
-                         (let () code ...))))))))))))))
+                          (let ((ww ww*)
+                                (kw (pytonize kw)))
+                            (let () code ...))))))))))))))
 
 (define-syntax-rule (def (f . args) code ...) (define f (lam args code ...)))
 
index 1e3351e..c8dc413 100644 (file)
@@ -1,6 +1,8 @@
 (define-module (language python guilemod)
   #:export ())
 
+(define-syntax-rule (aif it p . l) (let ((it p)) (if it . l)))
+
 (define-syntax-rule (mk-commands path mod-C define-C define-exp-C define-set-C)
   (begin
     (define mod-C (resolve-module 'path))
 (define pload
   (let ((guile-load (@ (guile) primitive-load-path)))
     (lambda (p . q)
-      (let ((tag (make-prompt-tag)))
-        (call-with-prompt
-         tag
-         (lambda ()
-           (guile-load p (lambda () (abort-to-prompt tag))))
-         (lambda (k)
-           (let lp ((l *extension-dispatches*))
-             (if (pair? l)
-                 (let lp2 ((u (caar l)))
-                   (if (pair? u)
-                       (let ((tag (make-prompt-tag)))
-                         (call-with-prompt
-                         tag
-                          (lambda ()
-                            (guile-load (string-append p "." (car u))
-                                        (lambda () (abort-to-prompt tag))))
-                          (lambda (k) (lp2 (cdr u)))))
-                       (lp (cdr l))))))
-           (if (pair? q)
-               ((car q))
-               (error (string-append "no code for path " p)))))))))
+      (let lp ((l *extension-dispatches*))
+        (if (pair? l)
+            (let lp2 ((u (caar l)))
+              (if (pair? u)
+                  (aif it (%search-load-path (string-append p "." (car u)))
+                       (apply guile-load it q)
+                       (lp2 (cdr u)))
+                  (lp (cdr l))))
+            (apply guile-load p q))))))
 
 
 (define-set-G primitive-load-path pload)
index d239baf..5e04fda 100644 (file)
@@ -82,7 +82,6 @@
     (define __init__
       (case-lambda
         ((self pre l nm)
-         (pk 1)
          (match l
            ((name)
             (rawset self '_path (reverse (cons name pre)))           
        
         
         ((self l nm)
-         (pk 2)
          (_cont self #f l #f nm #f))
 
         ((self l)
-         (pk 3)
          (if (pair? l)
              (if (and (> (length l) 3)
                       (equal? (list (list-ref l 0)
index 6de30e7..ea0d50f 100644 (file)
@@ -1,45 +1,6 @@
 module(f)
 
-from enum import Enum, unique, auto, IntEnum
+def g(x):
+    return x
 
-class Color (Enum):
-    RED   = 1
-    GREEN = 2
-    BLUE  = 3
-
-class Shape(Enum):
-    SQUARE  = 2
-    DIAMOND = 1
-    CIRCLE  = 3
-    ALIAS_FOR_SQUARE = 2
-    
-class Color2 (Enum):
-    RED   = auto()
-    GREEN = auto()
-    BLUE  = auto()
-
-@unique
-class Misstake(Enum):
-    ONE   = 1
-    TWO   = 2
-    THREE = 3
-    FOUR  = 4
-    
-class AutoName(Enum):
-    def _generate_next_value_(name, start, count, last_values):
-        return name
-    
-
-class Ordinal(AutoName):
-    NORTH = auto()
-    SOUTH = auto()
-    EAST = auto()
-    WEST = auto()
-
-class Num(IntEnum):
-    One   = 1
-    Two   = 2
-    Three = 3
-    
-    
-__all__ = ['Color','Shape','Color2','Misstake','Ordinal','Num']
+__all__ = ['g']
index 864a7a1..b3708b5 100644 (file)
     (case-lambda
       ((self)
        "")
-      ((self s . l)  
+      ((self s . l)
+       (pk s)
        (cond
         ((is-a? s <py-string>)
          (slot-ref s 'str))