Higher order modules: a first stab

[Ian Price <ianprice90@googlemail.com>]

Hi guilers,

I've been musing over the concept of higher order modules (modules
parameterized by other modules) in the back of my mind, and am
occasionally making steps towards implementing it in guile. I think that
with guile's first class modules all the machinery is there, it's just a
question of figuring out the best way to do it. The advantage for users
of guile is that it provides a different, and hopefully useful, form of
code reuse.

Here is the first step towards it that I made.

;;; higher order modules for guile

(define-syntax-parameter provide ; an "export" for `module' forms
  (lambda (stx)
    (syntax-violation 'provide "provide used outside a module form" stx)))

(define-syntax module
  (lambda (stx)
    (syntax-case stx ()
      ((module (params ...) body ...)
       (with-syntax (((tmp ...) (generate-temporaries #'(params ...))))
         #'(lambda (tmp ...)
             (define fresh (make-fresh-user-module))
             (module-use! fresh (resolve-interface '(guile)))
             (save-module-excursion
              (lambda ()
                (set-current-module fresh)
                (let ((export-alist '()))
                  (syntax-parameterize ((provide (syntax-rules ()
                                                   ((provide foo bar (... ...))
                                                    (set! export-alist
                                                          (append (list
                                                                   (cons 'foo foo)
                                                                   (cons 'bar bar)
                                                                   (... ...))))))))
                    (define params tmp) ...
                    body ...
                    (map (lambda (pair)
                           (let ((var (car pair))
                                 (val (cdr pair)))
                             (module-define! fresh var val)))
                         export-alist)))))
             fresh))))))

;; example module
(define stream-utils
  (module (stream-car stream-cdr)
    (define (stream-drop s n)
      (if (zero? n)
          s
          (stream-drop (stream-cdr s) (- n 1))))
    (define (stream-take s n)
      (if (zero? n)
          '()
          (cons (stream-car s)
                (stream-take (stream-cdr s) (- n 1)))))
    (provide stream-drop stream-take)))

;; first stream implementation
;; Stream a = Stream b (b -> a) (b -> Stream a)

(import (rnrs records syntactic))

(define-record-type stream
  (fields val this next))

(define (stream-car stream)
  ((stream-this stream) (stream-val stream)))

(define (stream-cdr stream)
  ((stream-next stream) (stream-val stream)))

(define (constant-stream k)
  (define (next k)
    (make-stream k identity next))
  (next k))

(define naturals
  (letrec ((next (lambda (current)
                   (make-stream (+ 1 current) identity next))))
    (next -1)))

(define stream-module (stream-utils stream-car stream-cdr))
(define stream-take (module-ref stream-module 'stream-take))

(stream-take naturals 10) ;;(0 1 2 3 4 5 6 7 8 9)


;; second stream implementation
(use-modules ((ice-9 streams)
              #:renamer (symbol-prefix-proc 's:)))

(define naturals2 (s:make-stream (lambda (x)
                                   (cons x (1+ x)))
                                 0))

(define stream-module2 (stream-utils s:stream-car s:stream-cdr))
(define stream-take2 (module-ref stream-module2 'stream-take))

(stream-take2 naturals2 10)


Currently, parameterized modules are functions that return a
module, and functions are retrieved by module-ref. This is fine for a
proof of concept, but hopefully I'll have something better integrated
soon.

Thanks to wingo for suggesting the current method of providing exports

-- 
Ian Price

"Programming is like pinball. The reward for doing it well is
the opportunity to do it again" - from "The Wizardy Compiled"