mirror of
https://git.savannah.gnu.org/git/guile.git
synced 2025-04-30 11:50:28 +02:00
60d852248f
Before, the optional args in a lambda-case could be #f or a list of symbols. However the list of symbols is entirely sufficient; no optional args means a null list. Change everywhere that produces lambda-case, matches on lambda-case, and reads deserialized lambda-case.
124 lines
4.9 KiB
Scheme
124 lines
4.9 KiB
Scheme
;;; Expand case-lambda and lambda* into simple dispatchers
|
|
;;; Copyright (C) 2024 Free Software Foundation, Inc.
|
|
;;;
|
|
;;; This library is free software: you can redistribute it and/or modify
|
|
;;; it under the terms of the GNU Lesser General Public License as
|
|
;;; published by the Free Software Foundation, either version 3 of the
|
|
;;; License, or (at your option) any later version.
|
|
;;;
|
|
;;; This library is distributed in the hope that it will be useful, but
|
|
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
;;; Lesser General Public License for more details.
|
|
;;;
|
|
;;; You should have received a copy of the GNU Lesser General Public
|
|
;;; License along with this program. If not, see
|
|
;;; <http://www.gnu.org/licenses/>.
|
|
|
|
;;; Commentary:
|
|
;;;
|
|
;;; We can partition lambdas into simple and complex. A simple lambda
|
|
;;; has just one clause and no optional, rest, or keyword arguments.
|
|
;;; Any other lambda is complex. This pass aims to facilitate reduction
|
|
;;; of complex lambdas to simple lambdas. It does so by eta-expanding
|
|
;;; lexically-bound complex lambdas into simple dispatchers that
|
|
;;; tail-call simple lambda body procedures. This will allow peval to
|
|
;;; elide the complex lambdas in many cases.
|
|
;;;
|
|
;;; Code:
|
|
|
|
(define-module (language tree-il demux-lambda)
|
|
#:use-module (srfi srfi-1)
|
|
#:use-module (ice-9 match)
|
|
#:use-module (language tree-il)
|
|
#:export (demux-lambda))
|
|
|
|
(define (make-binding name sym val) (vector name sym val))
|
|
|
|
(define (demux-clause func-name clause)
|
|
(match clause
|
|
(#f (values '() clause))
|
|
(($ <lambda-case> src req opt rest kw inits gensyms body alternate)
|
|
(call-with-values (lambda () (demux-clause func-name alternate))
|
|
(lambda (bindings alternate)
|
|
(define simple-req
|
|
(append req opt (if rest (list rest) '())
|
|
(match kw
|
|
((aok? (kw name sym) ...) name)
|
|
(#f '()))))
|
|
(define simple-clause
|
|
(make-lambda-case src simple-req '() #f #f '() gensyms body #f))
|
|
(define simple-func (make-lambda src '() simple-clause))
|
|
(define simple-sym (gensym "demuxed"))
|
|
(define simple-binding
|
|
(make-binding func-name simple-sym simple-func))
|
|
|
|
(define renamed-syms
|
|
(map (lambda (_) (gensym "demux")) gensyms))
|
|
(define rename-sym
|
|
(let ((renamed (map cons gensyms renamed-syms)))
|
|
(lambda (sym) (or (assq-ref renamed sym) sym))))
|
|
(define renamed-kw
|
|
(match kw
|
|
((aok? (kw name sym) ...)
|
|
(cons aok? (map list kw name (map rename-sym sym))))
|
|
(#f #f)))
|
|
(define renamed-inits
|
|
(map (lambda (init)
|
|
(post-order
|
|
(lambda (exp)
|
|
(match exp
|
|
(($ <lexical-ref> src name sym)
|
|
(make-lexical-ref src name (rename-sym sym)))
|
|
(($ <lexical-set> src name sym exp)
|
|
(make-lexical-set src name (rename-sym sym) exp))
|
|
(_ exp)))
|
|
init))
|
|
inits))
|
|
(define dispatch-call
|
|
(make-call src (make-lexical-ref src func-name simple-sym)
|
|
(map (lambda (name sym)
|
|
(make-lexical-ref src name sym))
|
|
simple-req renamed-syms)))
|
|
(define dispatch-clause
|
|
(make-lambda-case src req opt rest renamed-kw renamed-inits
|
|
renamed-syms dispatch-call alternate))
|
|
|
|
(values (cons simple-binding bindings)
|
|
dispatch-clause))))))
|
|
|
|
(define (demux-lambda exp)
|
|
(define (complex-lambda? val)
|
|
(match val
|
|
(($ <lambda> src meta
|
|
($ <lambda-case> src req opt rest kw inits gensyms body alternate))
|
|
(or (pair? opt) rest (pair? kw) alternate))
|
|
(_ #f)))
|
|
|
|
(define (demux-binding name gensym val)
|
|
(if (complex-lambda? val)
|
|
(match val
|
|
(($ <lambda> src meta clause)
|
|
(call-with-values (lambda () (demux-clause name clause))
|
|
(lambda (extra-bindings clause)
|
|
(let ((val (make-lambda src meta clause)))
|
|
(append extra-bindings
|
|
(list (make-binding name gensym val))))))))
|
|
(list (make-binding name gensym val))))
|
|
|
|
(define (demux-lexically-bound-complex-lambdas exp)
|
|
(match exp
|
|
(($ <letrec> src in-order? names gensyms vals body)
|
|
(match (append-map demux-binding names gensyms vals)
|
|
((#(name gensym val) ...)
|
|
(make-letrec src in-order? name gensym val body))))
|
|
|
|
(($ <let> src names gensyms vals body)
|
|
(if (or-map lambda? vals)
|
|
(demux-lexically-bound-complex-lambdas
|
|
(make-letrec src #f names gensyms vals body))
|
|
exp))
|
|
|
|
(_ exp)))
|
|
|
|
(post-order demux-lexically-bound-complex-lambdas exp))
|