Path: utzoo!utgpu!news-server.csri.toronto.edu!cs.utexas.edu!sdd.hp.com!mips!cs.uoregon.edu!ogicse!hsdndev!dartvax!mars!nic!claven!mike
From: mike@claven.cambridge.ibm.com (Mike Wojcik)
Newsgroups: comp.lang.scheme
Subject: Re: lambda*, where is it now ... ?
Message-ID: <1991Jun13.205955.24463@claven.cambridge.ibm.com>
Date: 13 Jun 91 20:59:55 GMT
References: <676362044.6@egsgate.FidoNet.Org>
Reply-To: mike@claven.cambridge.ibm.com (Mike Wojcik)
Distribution: na
Organization: IBM Technical Computing Systems, Cambridge, MA
Lines: 56

When I was taking my (undergraduate) Analysis of Programming Languages class,
the instructor (a grad student) implemented lambda* in both PCScheme and some
Scheme variant on the Suns.  I was partially successful at implementing it
myself.  Unfortunately, I don't have his version, but my experiments were
along the line of

--- cut here ---

;;; lambda*:  a generator of self-currying procedures
;;; eg. (define f (lambda* (x y) (+ x y))) creates a procedure f w/ the
;;; following properties:
;;;    (f) == f
;;;    (f p1 p2) == (+ p1 p2)
;;;    (f p1) == (lambda* (y) (+ p1 y))  [i.e. another self-currying proc.]
(extend-syntax (lambda*)
  [(lambda* (p1 p2) exp)                ;base case -- 2 parameters
   (with ([f-func (gensym)]
          [g-func (gensym)]
          [f-parms (gensym)]
          [g-parms (gensym)])
     (letrec ([f-func
       (lambda f-parms
         (case (length f-parms)
           [0 f-func]                   ;(f) -> f
           [1 (letrec ([g-func          ;(f p1) -> a new lambda* procedure
             (lambda g-parms
               (case (length g-parms)
                 [0 g-func]
                 [1 ((lambda (p2) ((lambda (p1) exp) (car f-parms)))
                   (car g-parms))]      ;((f p1) p2) -> application
                 [else (error 'g "too many parameters")]))])
             g-func)]
           [2 ((lambda (p2) ((lambda (p1) exp) (car f-parms))) (cadr f-parms))]
           [else (error 'f "too many parameters")]))])
        f-func))]
  [(lambda* (p1 p2 p3 ...) exp)         ;extended case: recurse on lambda*
                                        ;  model until only 2 formal param-
                                        ;  eters; resulting proc. will apply
                                        ;  actual params. to nested lambda*'s
                                        ;  until they reach the f/g case
   (with ([e-func (gensym)]
          [e-parms (gensym)])
     (letrec ([e-func
       (lambda e-parms
         (case (length e-parms)
           [0 e-func]
           [else (apply (lambda* (p2 p3 ...) ((lambda (p1) exp) (car e-parms)))
             (cdr e-parms))]))])
       e-func))])

--- end cut ---

Mike Wojcik
-- 
Michael Wojcik
I do not represent IBM, or DEC, or Sun, or HP, or . . .