Fcalva/cyclone
1
0
Fork 0
mirror of https://github.com/justinethier/cyclone.git synced 2025-05-25 04:55:04 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Syntax-rules stub

Browse source
This commit is contained in:
Justin Ethier 2016-02-13 02:24:05 -05:00
parent 8c91762b1e
commit f448245253
1 changed files with 241 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

242
scheme/base.sld
View file

@ -1,6 +1,8 @@
(define-library (scheme base) (define-library (scheme base)
;; In the future, may include this here: (include "../srfi/9.scm") ;; In the future, may include this here: (include "../srfi/9.scm")
(export (export
; cons-source
; syntax-rules
; TODO: need filter for the next two. also, they really belong in SRFI-1, not here ; TODO: need filter for the next two. also, they really belong in SRFI-1, not here
;delete ;delete
;delete-duplicates ;delete-duplicates
@ -189,7 +191,6 @@
; textual-port? ; textual-port?
; ;
; ;; syntax-rules ; ;; syntax-rules
; syntax-rules
; parameterize ; parameterize
; define-values ; define-values
; guard ; guard
@ -1041,4 +1042,243 @@
data, data,
k, k,
(p->mode == 0 && p->fp != NULL) ? boolean_t : boolean_f); ") (p->mode == 0 && p->fp != NULL) ? boolean_t : boolean_f); ")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; syntax-rules
;(define identifier? symbol?)
;(define (identifier->symbol obj) obj)
;(define (find-tail pred ls)
; (and (pair? ls) (if (pred (car ls)) ls (find-tail pred (cdr ls)))))
;
;(define (find pred ls)
; (cond ((find-tail pred ls) => car) (else #f)))
;(define (cons-source kar kdr source)
; (cons kar kdr))
;
;(define-syntax syntax-rules
; (er-macro-transformer
; (lambda (expr rename compare)
; (let ((ellipsis-specified? (identifier? (cadr expr)))
; (count 0)
; (_er-macro-transformer (rename 'er-macro-transformer))
; (_lambda (rename 'lambda)) (_let (rename 'let))
; (_begin (rename 'begin)) (_if (rename 'if))
; (_and (rename 'and)) (_or (rename 'or))
; (_eq? (rename 'eq?)) (_equal? (rename 'equal?))
; (_car (rename 'car)) (_cdr (rename 'cdr))
; (_cons (rename 'cons)) (_pair? (rename 'pair?))
; (_null? (rename 'null?)) (_expr (rename 'expr))
; (_rename (rename 'rename)) (_compare (rename 'compare))
; (_quote (rename 'quote)) (_apply (rename 'apply))
; ;(_quote (rename 'syntax-quote)) (_apply (rename 'apply))
; (_append (rename 'append)) (_map (rename 'map))
; (_vector? (rename 'vector?)) (_list? (rename 'list?))
; (_len (rename'len)) (_length (rename 'length))
; (_- (rename '-)) (_>= (rename '>=)) (_error (rename 'error))
; (_ls (rename 'ls)) (_res (rename 'res)) (_i (rename 'i))
; (_reverse (rename 'reverse))
; (_vector->list (rename 'vector->list))
; (_list->vector (rename 'list->vector))
; (_cons3 (rename 'cons-source)))
; (define ellipsis (rename (if ellipsis-specified? (cadr expr) '...)))
; (define lits (if ellipsis-specified? (car (cddr expr)) (cadr expr)))
; (define forms (if ellipsis-specified? (cdr (cddr expr)) (cddr expr)))
; (define (next-symbol s)
; (set! count (+ count 1))
; (rename (string->symbol (string-append s (number->string count)))))
; (define (expand-pattern pat tmpl)
; (let lp ((p (cdr pat))
; (x (list _cdr _expr))
; (dim 0)
; (vars '())
; (k (lambda (vars)
; (list _cons (expand-template tmpl vars) #f))))
; (let ((v (next-symbol "v.")))
; (list
; _let (list (list v x))
; (cond
; ((identifier? p)
; (if (any (lambda (l) (compare p l)) lits)
; (list _and
; (list _compare v (list _rename (list _quote p)))
; (k vars))
; (list _let (list (list p v)) (k (cons (cons p dim) vars)))))
; ((ellipsis? p)
; (cond
; ((not (null? (cdr (cdr p))))
; (cond
; ((any (lambda (x) (and (identifier? x) (compare x ellipsis)))
; (cddr p))
; (error "multiple ellipses" p))
; (else
; (let ((len (length (cdr (cdr p))))
; (_lp (next-symbol "lp.")))
; `(,_let ((,_len (,_length ,v)))
; (,_and (,_>= ,_len ,len)
; (,_let ,_lp ((,_ls ,v)
; (,_i (,_- ,_len ,len))
; (,_res (,_quote ())))
; (,_if (,_>= 0 ,_i)
; ,(lp `(,(cddr p)
; (,(car p) ,(car (cdr p))))
; `(,_cons ,_ls
; (,_cons (,_reverse ,_res)
; (,_quote ())))
; dim
; vars
; k)
; (,_lp (,_cdr ,_ls)
; (,_- ,_i 1)
; (,_cons3 (,_car ,_ls)
; ,_res
; ,_ls))))))))))
; ((identifier? (car p))
; (list _and (list _list? v)
; (list _let (list (list (car p) v))
; (k (cons (cons (car p) (+ 1 dim)) vars)))))
; (else
; (let* ((w (next-symbol "w."))
; (_lp (next-symbol "lp."))
; (new-vars (all-vars (car p) (+ dim 1)))
; (ls-vars (map (lambda (x)
; (next-symbol
; (string-append
; (symbol->string
; (identifier->symbol (car x)))
; "-ls")))
; new-vars))
; (once
; (lp (car p) (list _car w) (+ dim 1) '()
; (lambda (_)
; (cons
; _lp
; (cons
; (list _cdr w)
; (map (lambda (x l)
; (list _cons (car x) l))
; new-vars
; ls-vars)))))))
; (list
; _let
; _lp (cons (list w v)
; (map (lambda (x) (list x (list _quote '()))) ls-vars))
; (list _if (list _null? w)
; (list _let (map (lambda (x l)
; (list (car x) (list _reverse l)))
; new-vars
; ls-vars)
; (k (append new-vars vars)))
; (list _and (list _pair? w) once)))))))
; ((pair? p)
; (list _and (list _pair? v)
; (lp (car p)
; (list _car v)
; dim
; vars
; (lambda (vars)
; (lp (cdr p) (list _cdr v) dim vars k)))))
; ((vector? p)
; (list _and
; (list _vector? v)
; (lp (vector->list p) (list _vector->list v) dim vars k)))
; ((null? p) (list _and (list _null? v) (k vars)))
; (else (list _and (list _equal? v p) (k vars))))))))
; (define (ellipsis-escape? x) (and (pair? x) (compare ellipsis (car x))))
; (define (ellipsis? x)
; (and (pair? x) (pair? (cdr x)) (compare ellipsis (cadr x))))
; (define (ellipsis-depth x)
; (if (ellipsis? x)
; (+ 1 (ellipsis-depth (cdr x)))
; 0))
; (define (ellipsis-tail x)
; (if (ellipsis? x)
; (ellipsis-tail (cdr x))
; (cdr x)))
; (define (all-vars x dim)
; (let lp ((x x) (dim dim) (vars '()))
; (cond ((identifier? x)
; (if (any (lambda (lit) (compare x lit)) lits)
; vars
; (cons (cons x dim) vars)))
; ((ellipsis? x) (lp (car x) (+ dim 1) (lp (cddr x) dim vars)))
; ((pair? x) (lp (car x) dim (lp (cdr x) dim vars)))
; ((vector? x) (lp (vector->list x) dim vars))
; (else vars))))
; (define (free-vars x vars dim)
; (let lp ((x x) (free '()))
; (cond
; ((identifier? x)
; (if (and (not (memq x free))
; (cond ((assq x vars) => (lambda (cell) (>= (cdr cell) dim)))
; (else #f)))
; (cons x free)
; free))
; ((pair? x) (lp (car x) (lp (cdr x) free)))
; ((vector? x) (lp (vector->list x) free))
; (else free))))
; (define (expand-template tmpl vars)
; (let lp ((t tmpl) (dim 0))
; (cond
; ((identifier? t)
; (cond
; ((find (lambda (v) (compare t (car v))) vars)
; => (lambda (cell)
; (if (<= (cdr cell) dim)
; t
; (error "too few ...'s"))))
; (else
; (list _rename (list _quote t)))))
; ((pair? t)
; (cond
; ((ellipsis-escape? t)
; (list _quote
; (if (pair? (cdr t))
; (if (pair? (cddr t)) (cddr t) (cadr t))
; (cdr t))))
; ((ellipsis? t)
; (let* ((depth (ellipsis-depth t))
; (ell-dim (+ dim depth))
; (ell-vars (free-vars (car t) vars ell-dim)))
; (cond
; ((null? ell-vars)
; (error "too many ...'s"))
; ((and (null? (cdr (cdr t))) (identifier? (car t)))
; ;; shortcut for (var ...)
; (lp (car t) ell-dim))
; (else
; (let* ((once (lp (car t) ell-dim))
; (nest (if (and (null? (cdr ell-vars))
; (identifier? once)
; (eq? once (car vars)))
; once ;; shortcut
; (cons _map
; (cons (list _lambda ell-vars once)
; ell-vars))))
; (many (do ((d depth (- d 1))
; (many nest
; (list _apply _append many)))
; ((= d 1) many))))
; (if (null? (ellipsis-tail t))
; many ;; shortcut
; (list _append many (lp (ellipsis-tail t) dim))))))))
; (else (list _cons3 (lp (car t) dim) (lp (cdr t) dim) (list _quote t)))))
; ((vector? t) (list _list->vector (lp (vector->list t) dim)))
; ((null? t) (list _quote '()))
; (else t))))
; (list
; _er-macro-transformer
; (list _lambda (list _expr _rename _compare)
; (list
; _car
; (cons
; _or
; (append
; (map
; (lambda (clause) (expand-pattern (car clause) (cadr clause)))
; forms)
; (list
; (list _cons
; (list _error "no expansion for"
; _expr ; (list (rename 'strip-syntactic-closures) _expr)
; )
; #f)))))))))))
)) ))