module.zp

(define *modules* (make-hash))

(define-syntax import
  (syntax-rules ()
    ((import name)
      (let ((_name (if (symbol? 'name) (symbol->string 'name) name)))
        (if (not (in? _name #\:))
          (if (hash:contains? *modules* _name)
            (*modules* _name)
            :no)
          (let* ((fullname (string:split _name #\:))
                 (_module (car fullname))
                 (function (cadr fullname)))
            (if (hash:contains? *modules* _module)
              (if (hash:contains? (*modules* _module) function)
                  ((*modules* _module) function)
                  :no)
              :no)))))))

(define-syntax import-all
  (syntax-rules ()
    ((import-all name to env)
      (if (hash:contains? *modules* name)
        (hash:kv-map
          (lambda (kv)
            (eval `(define ,(string->symbol (++ to ":" (head kv))) (quote ,(cadr kv))) env))
          (*modules* name))
        :no))
    ((import-all name to)
      (let ((env (current-env)))
        (import-all name to env)))
    ((import-all name)
      (import-all name name))))

(define-syntax module
  (syntax-rules (export loads)
    ((module name)
     (set! *modules* (make-hash *modules* (make-hash name #{}))))
    ((module name (export exports ...) (loads files ...) x ...)
     ((lambda ()
      (let ((env (current-env)))
        (begin
          (map
            (lambda (file) (load file env))
            'files)
          (module name (export exports ...) x ...))))))
    ((module name (export exports ...) x ...)
      (letrec* (x ...)
        (hash:set! *modules* name
          (make-hash
            (map
              (lambda (el) "build the module map"
                (if (atom? (car el)) 
                  (cons (string:tail (symbol->string (car el))) (cdr el))
                  el))
              (list exports ...))))))))

(define-syntax module-extend
  (syntax-rules (export loads)
    ((module name (export exports ...) (loads files ...) x ...)
     ((lambda ()
      (let ((env (current-env)))
        (begin
          (map
            (lambda (file) (load file env))
            'files)
          (module-extend name (export exports ...) x ...))))))
    ((module-extend name (export exports ...) x ...)
      (letrec* (x ...)
        (begin
          (import-all name)
          (hash:update! *modules* name
            (lambda (h)
              (make-hash h
                (make-hash
                  (map 
                    (lambda (el)
                      (if (atom? (car el)) 
                        (cons (string:tail (symbol->string (car el))) (cdr el))
                        el))
                    (list exports ...)))))))))))