switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
; -*- scheme -*-
|
2008-06-30 21:54:22 -04:00
|
|
|
|
; femtoLisp standard library
|
2009-01-04 21:45:21 -05:00
|
|
|
|
; by Jeff Bezanson (C) 2009
|
2008-08-29 22:56:46 -04:00
|
|
|
|
; Distributed under the BSD License
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(set-constant! 'eq eq?)
|
|
|
|
|
(set-constant! 'eqv eqv?)
|
|
|
|
|
(set-constant! 'equal equal?)
|
|
|
|
|
(set-constant! 'rplaca set-car!)
|
|
|
|
|
(set-constant! 'rplacd set-cdr!)
|
|
|
|
|
(set-constant! 'char? (lambda (x) (eq? (typeof x) 'wchar)))
|
|
|
|
|
|
2008-06-30 21:54:22 -04:00
|
|
|
|
; convert a sequence of body statements to a single expression.
|
|
|
|
|
; this allows define, defun, defmacro, let, etc. to contain multiple
|
|
|
|
|
; body expressions as in Common Lisp.
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(set! f-body (lambda (e)
|
2009-02-08 22:22:31 -05:00
|
|
|
|
(cond ((atom? e) #f)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
((eq (cdr e) ()) (car e))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(#t (cons 'begin e)))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(set-syntax! 'define-macro
|
|
|
|
|
(lambda (form . body)
|
|
|
|
|
(list 'set-syntax! (list 'quote (car form))
|
|
|
|
|
(list 'lambda (cdr form) (f-body body)))))
|
2008-07-14 21:20:52 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define-macro (define form . body)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(if (symbol? form)
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(list 'set! form (car body))
|
|
|
|
|
(list 'set! (car form) (list 'lambda (cdr form) (f-body body)))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
2009-02-09 00:38:40 -05:00
|
|
|
|
(define *output-stream* *stdout*)
|
|
|
|
|
(define *input-stream* *stdin*)
|
|
|
|
|
(define (print . args)
|
|
|
|
|
(apply io.print (cons *output-stream* args)))
|
|
|
|
|
(define (princ . args)
|
|
|
|
|
(apply io.princ (cons *output-stream* args)))
|
2008-09-06 18:19:51 -04:00
|
|
|
|
|
2009-02-09 00:38:40 -05:00
|
|
|
|
(define (set s v) (eval (list 'set! s (list 'quote v))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (map f lst)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(if (atom? lst) lst
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(cons (f (car lst)) (map f (cdr lst)))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
2009-02-09 00:38:40 -05:00
|
|
|
|
(define-macro (label name fn)
|
|
|
|
|
(list (list 'lambda (list name) (list 'set! name fn)) #f))
|
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define-macro (let binds . body)
|
2009-02-05 22:41:24 -05:00
|
|
|
|
((lambda (lname)
|
|
|
|
|
(begin
|
|
|
|
|
(if (symbol? binds)
|
|
|
|
|
(begin (set! lname binds)
|
|
|
|
|
(set! binds (car body))
|
|
|
|
|
(set! body (cdr body))))
|
|
|
|
|
((lambda (thelambda theargs)
|
|
|
|
|
(cons (if lname
|
|
|
|
|
(list 'label lname thelambda)
|
|
|
|
|
thelambda)
|
|
|
|
|
theargs))
|
|
|
|
|
(list 'lambda
|
|
|
|
|
(map (lambda (c) (if (pair? c) (car c) c)) binds)
|
|
|
|
|
(f-body body))
|
|
|
|
|
(map (lambda (c) (if (pair? c) (cadr c) #f)) binds))))
|
|
|
|
|
#f))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (nconc . lsts)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(cond ((null? lsts) ())
|
|
|
|
|
((null? (cdr lsts)) (car lsts))
|
|
|
|
|
((null? (car lsts)) (apply nconc (cdr lsts)))
|
|
|
|
|
(#t (prog1 (car lsts)
|
|
|
|
|
(rplacd (last (car lsts))
|
|
|
|
|
(apply nconc (cdr lsts)))))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (append . lsts)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(cond ((null? lsts) ())
|
|
|
|
|
((null? (cdr lsts)) (car lsts))
|
|
|
|
|
(#t ((label append2 (lambda (l d)
|
|
|
|
|
(if (null? l) d
|
|
|
|
|
(cons (car l)
|
|
|
|
|
(append2 (cdr l) d)))))
|
|
|
|
|
(car lsts) (apply append (cdr lsts))))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (member item lst)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(cond ((atom? lst) #f)
|
|
|
|
|
((equal (car lst) item) lst)
|
|
|
|
|
(#t (member item (cdr lst)))))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (memq item lst)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(cond ((atom? lst) #f)
|
|
|
|
|
((eq (car lst) item) lst)
|
|
|
|
|
(#t (memq item (cdr lst)))))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (memv item lst)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(cond ((atom? lst) #f)
|
|
|
|
|
((eqv (car lst) item) lst)
|
|
|
|
|
(#t (memv item (cdr lst)))))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
|
|
|
|
|
(define (assoc item lst)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(cond ((atom? lst) #f)
|
|
|
|
|
((equal (caar lst) item) (car lst))
|
|
|
|
|
(#t (assoc item (cdr lst)))))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (assv item lst)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(cond ((atom? lst) #f)
|
|
|
|
|
((eqv (caar lst) item) (car lst))
|
|
|
|
|
(#t (assv item (cdr lst)))))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(define (macrocall? e) (and (symbol? (car e))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(symbol-syntax (car e))))
|
|
|
|
|
|
|
|
|
|
(define (function? x)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(or (builtin? x)
|
|
|
|
|
(and (pair? x) (eq (car x) 'lambda))))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define procedure? function?)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (macroexpand-1 e)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(if (atom? e) e
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(let ((f (macrocall? e)))
|
|
|
|
|
(if f (apply f (cdr e))
|
|
|
|
|
e))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
|
|
|
|
; convert to proper list, i.e. remove "dots", and append
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (append.2 l tail)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(cond ((null? l) tail)
|
|
|
|
|
((atom? l) (cons l tail))
|
|
|
|
|
(#t (cons (car l) (append.2 (cdr l) tail)))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
|
|
|
|
(define (cadr x) (car (cdr x)))
|
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
;(set! *special-forms* '(quote cond if and or while lambda trycatch
|
|
|
|
|
; set! begin))
|
2008-07-11 22:58:55 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (macroexpand e)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
((label mexpand
|
|
|
|
|
(lambda (e env f)
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(begin
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(while (and (pair? e)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(not (member (car e) env))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(set! f (macrocall? e)))
|
|
|
|
|
(set! e (apply f (cdr e))))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(cond ((and (pair? e)
|
2008-07-11 22:58:55 -04:00
|
|
|
|
(not (eq (car e) 'quote)))
|
|
|
|
|
(let ((newenv
|
2008-12-23 23:43:36 -05:00
|
|
|
|
(if (and (eq (car e) 'lambda)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(pair? (cdr e)))
|
2008-07-11 22:58:55 -04:00
|
|
|
|
(append.2 (cadr e) env)
|
|
|
|
|
env)))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(map (lambda (x) (mexpand x newenv ())) e)))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
;((and (symbol? e) (constant? e)) (eval e))
|
|
|
|
|
;((and (symbol? e)
|
2008-07-11 22:58:55 -04:00
|
|
|
|
; (not (member e *special-forms*))
|
|
|
|
|
; (not (member e env))) (cons '%top e))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(#t e)))))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
e () ()))
|
|
|
|
|
|
|
|
|
|
(define-macro (define form . body)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(if (symbol? form)
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(list 'set! form (car body))
|
|
|
|
|
(list 'set! (car form)
|
|
|
|
|
(macroexpand (list 'lambda (cdr form) (f-body body))))))
|
|
|
|
|
(define-macro (define-macro form . body)
|
|
|
|
|
(list 'set-syntax! (list 'quote (car form))
|
|
|
|
|
(macroexpand (list 'lambda (cdr form) (f-body body)))))
|
|
|
|
|
(define macroexpand (macroexpand macroexpand))
|
|
|
|
|
|
2009-02-19 17:29:47 -05:00
|
|
|
|
(define (delete-duplicates lst)
|
|
|
|
|
(if (atom? lst)
|
|
|
|
|
lst
|
|
|
|
|
(let ((elt (car lst))
|
|
|
|
|
(tail (cdr lst)))
|
|
|
|
|
(if (member elt tail)
|
|
|
|
|
(delete-duplicates tail)
|
|
|
|
|
(cons elt
|
|
|
|
|
(delete-duplicates tail))))))
|
|
|
|
|
|
|
|
|
|
(define (get-defined-vars- expr)
|
|
|
|
|
(cond ((atom? expr) ())
|
|
|
|
|
((and (eq? (car expr) 'define)
|
|
|
|
|
(pair? (cdr expr)))
|
|
|
|
|
(or (and (symbol? (cadr expr))
|
|
|
|
|
(list (cadr expr)))
|
|
|
|
|
(and (pair? (cadr expr))
|
|
|
|
|
(symbol? (caadr expr))
|
|
|
|
|
(list (caadr expr)))
|
|
|
|
|
()))
|
|
|
|
|
((eq? (car expr) 'begin)
|
|
|
|
|
(apply append (map get-defined-vars- (cdr expr))))
|
|
|
|
|
(else ())))
|
|
|
|
|
(define (get-defined-vars expr)
|
|
|
|
|
(delete-duplicates (get-defined-vars- expr)))
|
|
|
|
|
|
|
|
|
|
; redefine f-body to support internal defines
|
|
|
|
|
(define f-body- f-body)
|
|
|
|
|
(define (f-body e)
|
|
|
|
|
((lambda (B)
|
|
|
|
|
((lambda (V)
|
|
|
|
|
(if (null? V)
|
|
|
|
|
B
|
|
|
|
|
(cons (list 'lambda V B) (map (lambda (x) #f) V))))
|
|
|
|
|
(get-defined-vars B)))
|
|
|
|
|
(f-body- e)))
|
|
|
|
|
|
2009-02-05 22:41:24 -05:00
|
|
|
|
(define = eqv)
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define eql eqv)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(define (/= a b) (not (equal a b)))
|
|
|
|
|
(define != /=)
|
|
|
|
|
(define (> a b) (< b a))
|
|
|
|
|
(define (<= a b) (not (< b a)))
|
|
|
|
|
(define (>= a b) (not (< a b)))
|
|
|
|
|
(define (1+ n) (+ n 1))
|
|
|
|
|
(define (1- n) (- n 1))
|
|
|
|
|
(define (mod x y) (- x (* (/ x y) y)))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(define remainder mod)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(define (abs x) (if (< x 0) (- x) x))
|
2009-02-09 00:38:40 -05:00
|
|
|
|
(define (identity x) x)
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define K prog1) ; K combinator ;)
|
2009-02-18 22:31:40 -05:00
|
|
|
|
(define begin0 prog1)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
|
|
|
|
(define (caar x) (car (car x)))
|
|
|
|
|
(define (cdar x) (cdr (car x)))
|
|
|
|
|
(define (cddr x) (cdr (cdr x)))
|
|
|
|
|
(define (caaar x) (car (car (car x))))
|
|
|
|
|
(define (caadr x) (car (car (cdr x))))
|
|
|
|
|
(define (cadar x) (car (cdr (car x))))
|
|
|
|
|
(define (caddr x) (car (cdr (cdr x))))
|
2008-12-28 03:01:18 -05:00
|
|
|
|
(define (cadddr x) (car (cdr (cdr (cdr x)))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(define (cdaar x) (cdr (car (car x))))
|
|
|
|
|
(define (cdadr x) (cdr (car (cdr x))))
|
|
|
|
|
(define (cddar x) (cdr (cdr (car x))))
|
|
|
|
|
(define (cdddr x) (cdr (cdr (cdr x))))
|
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (every pred lst)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(or (atom? lst)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(and (pred (car lst))
|
|
|
|
|
(every pred (cdr lst)))))
|
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (any pred lst)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(and (pair? lst)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(or (pred (car lst))
|
|
|
|
|
(any pred (cdr lst)))))
|
|
|
|
|
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(define (listp a) (or (null? a) (pair? a)))
|
|
|
|
|
(define (list? a) (or (null? a) (and (pair? a) (list? (cdr a)))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (nthcdr lst n)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(if (<= n 0) lst
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(nthcdr (cdr lst) (- n 1))))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(define list-tail nthcdr)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (list-ref lst n)
|
2009-01-04 21:45:21 -05:00
|
|
|
|
(car (nthcdr lst n)))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (list* . l)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(if (atom? (cdr l))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(car l)
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(cons (car l) (apply list* (cdr l)))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (nlist* . l)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(if (atom? (cdr l))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(car l)
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(rplacd l (apply nlist* (cdr l)))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (lastcdr l)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(if (atom? l) l
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(lastcdr (cdr l))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (last l)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(cond ((atom? l) l)
|
|
|
|
|
((atom? (cdr l)) l)
|
|
|
|
|
(#t (last (cdr l)))))
|
|
|
|
|
(define last-pair last)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (map! f lst)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(prog1 lst
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(while (pair? lst)
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(rplaca lst (f (car lst)))
|
|
|
|
|
(set! lst (cdr lst)))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (mapcar f . lsts)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
((label mapcar-
|
|
|
|
|
(lambda (lsts)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(cond ((null? lsts) (f))
|
|
|
|
|
((atom? (car lsts)) (car lsts))
|
|
|
|
|
(#t (cons (apply f (map car lsts))
|
|
|
|
|
(mapcar- (map cdr lsts)))))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
lsts))
|
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (transpose M) (apply mapcar (cons list M)))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (filter pred lst) (filter- pred lst ()))
|
|
|
|
|
(define (filter- pred lst accum)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(cond ((null? lst) accum)
|
2008-11-05 23:04:04 -05:00
|
|
|
|
((pred (car lst))
|
|
|
|
|
(filter- pred (cdr lst) (cons (car lst) accum)))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(#t
|
2008-11-05 23:04:04 -05:00
|
|
|
|
(filter- pred (cdr lst) accum))))
|
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (separate pred lst) (separate- pred lst () ()))
|
|
|
|
|
(define (separate- pred lst yes no)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(cond ((null? lst) (cons yes no))
|
2008-11-05 23:04:04 -05:00
|
|
|
|
((pred (car lst))
|
|
|
|
|
(separate- pred (cdr lst) (cons (car lst) yes) no))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(#t
|
2008-11-05 23:04:04 -05:00
|
|
|
|
(separate- pred (cdr lst) yes (cons (car lst) no)))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
|
|
|
|
(define (foldr f zero lst)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(if (null? lst) zero
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(f (car lst) (foldr f zero (cdr lst)))))
|
|
|
|
|
|
|
|
|
|
(define (foldl f zero lst)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(if (null? lst) zero
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(foldl f (f (car lst) zero) (cdr lst))))
|
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (reverse lst) (foldl cons () lst))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
|
|
|
|
(define (copy-list l)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(if (atom? l) l
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(cons (car l)
|
|
|
|
|
(copy-list (cdr l)))))
|
|
|
|
|
(define (copy-tree l)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(if (atom? l) l
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(cons (copy-tree (car l))
|
|
|
|
|
(copy-tree (cdr l)))))
|
|
|
|
|
|
|
|
|
|
(define (nreverse l)
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(let ((prev ()))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(while (pair? l)
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(set! l (prog1 (cdr l)
|
|
|
|
|
(rplacd l (prog1 prev
|
|
|
|
|
(set! prev l))))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
prev))
|
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define-macro (let* binds . body)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(cons (list 'lambda (map car binds)
|
2009-02-18 22:31:40 -05:00
|
|
|
|
(f-body
|
|
|
|
|
(nconc (map (lambda (b) (cons 'set! b)) binds)
|
|
|
|
|
body)))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(map (lambda (x) #f) binds)))
|
2009-02-18 22:31:40 -05:00
|
|
|
|
(set-syntax! 'letrec (symbol-syntax 'let*))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define-macro (when c . body) (list 'if c (f-body body) #f))
|
|
|
|
|
(define-macro (unless c . body) (list 'if c #f (f-body body)))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (revappend l1 l2) (nconc (reverse l1) l2))
|
|
|
|
|
(define (nreconc l1 l2) (nconc (nreverse l1) l2))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (list-to-vector l) (apply vector l))
|
|
|
|
|
(define (vector-to-list v)
|
2008-07-26 18:04:02 -04:00
|
|
|
|
(let ((n (length v))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(l ()))
|
2008-07-26 18:04:02 -04:00
|
|
|
|
(for 1 n
|
|
|
|
|
(lambda (i)
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(set! l (cons (aref v (- n i)) l))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
l))
|
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (self-evaluating? x)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(or (and (atom? x)
|
|
|
|
|
(not (symbol? x)))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(and (constant? x)
|
2008-12-22 01:36:50 -05:00
|
|
|
|
(eq x (eval x)))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
|
|
|
|
; backquote
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define-macro (backquote x) (bq-process x))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (splice-form? x)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(or (and (pair? x) (or (eq (car x) '*comma-at*)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(eq (car x) '*comma-dot*)))
|
|
|
|
|
(eq x '*comma*)))
|
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (bq-process x)
|
|
|
|
|
(cond ((self-evaluating? x)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(if (vector? x)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(let ((body (bq-process (vector-to-list x))))
|
|
|
|
|
(if (eq (car body) 'list)
|
|
|
|
|
(cons vector (cdr body))
|
|
|
|
|
(list apply vector body)))
|
|
|
|
|
x))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
((atom? x) (list 'quote x))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
((eq (car x) 'backquote) (bq-process (bq-process (cadr x))))
|
|
|
|
|
((eq (car x) '*comma*) (cadr x))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
((not (any splice-form? x))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(let ((lc (lastcdr x))
|
|
|
|
|
(forms (map bq-bracket1 x)))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(if (null? lc)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(cons 'list forms)
|
|
|
|
|
(nconc (cons 'nlist* forms) (list (bq-process lc))))))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(#t (let ((p x) (q ()))
|
|
|
|
|
(while (and (pair? p)
|
|
|
|
|
(not (eq (car p) '*comma*)))
|
|
|
|
|
(set! q (cons (bq-bracket (car p)) q))
|
|
|
|
|
(set! p (cdr p)))
|
|
|
|
|
(let ((forms
|
|
|
|
|
(cond ((pair? p) (nreconc q (list (cadr p))))
|
|
|
|
|
((null? p) (nreverse q))
|
|
|
|
|
(#t (nreconc q (list (bq-process p)))))))
|
|
|
|
|
(if (null? (cdr forms))
|
|
|
|
|
(car forms)
|
|
|
|
|
(cons 'nconc forms)))))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (bq-bracket x)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(cond ((atom? x) (list list (bq-process x)))
|
2008-12-30 23:45:08 -05:00
|
|
|
|
((eq (car x) '*comma*) (list list (cadr x)))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
((eq (car x) '*comma-at*) (list 'copy-list (cadr x)))
|
|
|
|
|
((eq (car x) '*comma-dot*) (cadr x))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(#t (list list (bq-process x)))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
|
|
|
|
; bracket without splicing
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (bq-bracket1 x)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(if (and (pair? x) (eq (car x) '*comma*))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(cadr x)
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(bq-process x)))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
2009-02-20 00:11:05 -05:00
|
|
|
|
(define (quote-value v)
|
|
|
|
|
(if (self-evaluating? v)
|
|
|
|
|
v
|
|
|
|
|
(list 'quote v)))
|
|
|
|
|
|
|
|
|
|
(define-macro (case key . clauses)
|
|
|
|
|
(define (vals-to-cond key v)
|
|
|
|
|
(cond ((eq? v 'else) 'else)
|
|
|
|
|
((null? v) #f)
|
|
|
|
|
((null? (cdr v)) `(eqv? ,key ,(quote-value (car v))))
|
|
|
|
|
(else `(memv ,key ',v))))
|
|
|
|
|
(let ((g (gensym)))
|
|
|
|
|
`(let ((,g ,key))
|
|
|
|
|
(cond ,@(map (lambda (clause)
|
|
|
|
|
(cons (vals-to-cond g (car clause))
|
|
|
|
|
(cdr clause)))
|
|
|
|
|
clauses)))))
|
|
|
|
|
|
2009-02-20 14:50:35 -05:00
|
|
|
|
(define-macro (do vars test-spec . commands)
|
|
|
|
|
(let ((loop (gensym))
|
|
|
|
|
(test-expr (car test-spec))
|
|
|
|
|
(vars (map car vars))
|
|
|
|
|
(inits (map cadr vars))
|
|
|
|
|
(steps (map (lambda (x)
|
|
|
|
|
(if (pair? (cddr x))
|
|
|
|
|
(caddr x)
|
|
|
|
|
(car x)))
|
|
|
|
|
vars)))
|
|
|
|
|
`(letrec ((,loop (lambda ,vars
|
|
|
|
|
(if ,test-expr
|
|
|
|
|
(begin
|
|
|
|
|
,@(cdr test-spec))
|
|
|
|
|
(begin
|
|
|
|
|
,@commands
|
|
|
|
|
(,loop ,@steps))))))
|
|
|
|
|
(,loop ,@inits))))
|
|
|
|
|
|
2009-02-20 00:11:05 -05:00
|
|
|
|
(define-macro (dotimes var . body)
|
|
|
|
|
(let ((v (car var))
|
|
|
|
|
(cnt (cadr var)))
|
|
|
|
|
`(for 0 (- ,cnt 1)
|
|
|
|
|
(lambda (,v) ,(f-body body)))))
|
|
|
|
|
|
|
|
|
|
(define (map-int f n)
|
|
|
|
|
(if (<= n 0)
|
|
|
|
|
()
|
|
|
|
|
(let ((first (cons (f 0) ()))
|
|
|
|
|
(acc ()))
|
|
|
|
|
(set! acc first)
|
|
|
|
|
(for 1 (- n 1)
|
|
|
|
|
(lambda (i)
|
|
|
|
|
(begin (rplacd acc (cons (f i) ()))
|
|
|
|
|
(set! acc (cdr acc)))))
|
|
|
|
|
first)))
|
|
|
|
|
|
|
|
|
|
(define (iota n) (map-int identity n))
|
|
|
|
|
(define ι iota)
|
|
|
|
|
|
|
|
|
|
(define (error . args) (raise (cons 'error args)))
|
|
|
|
|
|
|
|
|
|
(define-macro (throw tag value) `(raise (list 'thrown-value ,tag ,value)))
|
|
|
|
|
(define-macro (catch tag expr)
|
|
|
|
|
(let ((e (gensym)))
|
|
|
|
|
`(trycatch ,expr
|
|
|
|
|
(lambda (,e) (if (and (pair? ,e)
|
|
|
|
|
(eq (car ,e) 'thrown-value)
|
|
|
|
|
(eq (cadr ,e) ,tag))
|
|
|
|
|
(caddr ,e)
|
|
|
|
|
(raise ,e))))))
|
|
|
|
|
|
|
|
|
|
(define-macro (unwind-protect expr finally)
|
|
|
|
|
(let ((e (gensym)))
|
|
|
|
|
`(prog1 (trycatch ,expr
|
|
|
|
|
(lambda (,e) (begin ,finally (raise ,e))))
|
|
|
|
|
,finally)))
|
|
|
|
|
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(define-macro (assert expr) `(if ,expr #t (raise '(assert-failed ,expr))))
|
2008-06-30 21:54:22 -04:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define-macro (time expr)
|
2008-06-30 21:54:22 -04:00
|
|
|
|
(let ((t0 (gensym)))
|
|
|
|
|
`(let ((,t0 (time.now)))
|
|
|
|
|
(prog1
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
,expr
|
|
|
|
|
(princ "Elapsed time: " (- (time.now) ,t0) " seconds\n")))))
|
|
|
|
|
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(define (display x) (princ x) #t)
|
2009-02-20 00:11:05 -05:00
|
|
|
|
(define (println . args) (prog1 (apply print args) (princ "\n")))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
|
|
|
|
|
(define (vu8 . elts) (apply array (cons 'uint8 elts)))
|
2008-12-21 00:55:00 -05:00
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (vector.map f v)
|
2008-12-21 00:55:00 -05:00
|
|
|
|
(let* ((n (length v))
|
|
|
|
|
(nv (vector.alloc n)))
|
|
|
|
|
(for 0 (- n 1)
|
|
|
|
|
(lambda (i)
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(aset! nv i (f (aref v i)))))
|
2008-12-21 00:55:00 -05:00
|
|
|
|
nv))
|
|
|
|
|
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (table.pairs t)
|
2008-12-21 00:55:00 -05:00
|
|
|
|
(table.foldl (lambda (k v z) (cons (cons k v) z))
|
|
|
|
|
() t))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (table.keys t)
|
2008-12-21 00:55:00 -05:00
|
|
|
|
(table.foldl (lambda (k v z) (cons k z))
|
|
|
|
|
() t))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (table.values t)
|
2008-12-21 00:55:00 -05:00
|
|
|
|
(table.foldl (lambda (k v z) (cons v z))
|
|
|
|
|
() t))
|
switching to scheme #t, #f, and () values
porting code to sort out which NILs are false and which are
empty lists
switching to scheme-style special forms. however you feel about
scheme names vs. CL names, using both is silly.
mostly switching to scheme predicate names, with compatibility
aliases for now. adding set-constant! to make this efficient.
adding null?, eqv?, assq, assv, assoc, memq, memv, member
adding 2-argument form of if
allowing else as final cond condition
looking for init file in same directory as executable, so flisp
can be started from anywhere
renaming T to FL_T, since exporting a 1-character symbol is
not very nice
adding opaque type boilerplate example file
adding correctness checking for the pattern-lambda benchmark
bugfix in int2str
2009-01-28 20:04:23 -05:00
|
|
|
|
(define (table.clone t)
|
2008-12-22 01:36:50 -05:00
|
|
|
|
(let ((nt (table)))
|
2009-01-31 20:53:58 -05:00
|
|
|
|
(table.foldl (lambda (k v z) (put! nt k v))
|
2008-12-22 01:36:50 -05:00
|
|
|
|
() t)
|
|
|
|
|
nt))
|
2009-02-05 22:41:24 -05:00
|
|
|
|
|
|
|
|
|
(define *whitespace*
|
|
|
|
|
(string.encode #array(wchar 9 10 11 12 13 32 133 160 5760 6158 8192
|
|
|
|
|
8193 8194 8195 8196 8197 8198 8199 8200
|
|
|
|
|
8201 8202 8232 8233 8239 8287 12288)))
|
2009-02-18 22:31:40 -05:00
|
|
|
|
|
|
|
|
|
(define (load filename)
|
|
|
|
|
(let ((F (file filename :read)))
|
|
|
|
|
(trycatch
|
|
|
|
|
(prog1
|
|
|
|
|
(let next (E v)
|
|
|
|
|
(if (not (io.eof? F))
|
|
|
|
|
(next (read F)
|
|
|
|
|
(eval E))
|
|
|
|
|
v))
|
|
|
|
|
(io.close F))
|
|
|
|
|
(lambda (e)
|
|
|
|
|
(begin
|
|
|
|
|
(io.close F)
|
|
|
|
|
(raise `(load-error ,filename ,e)))))))
|
|
|
|
|
|
2009-02-19 17:29:47 -05:00
|
|
|
|
(define (string.tail s n)
|
|
|
|
|
(string.sub s (string.inc s 0 n) (sizeof s)))
|
|
|
|
|
|
|
|
|
|
(define *banner* (string.tail "
|
|
|
|
|
; _
|
2009-02-18 22:31:40 -05:00
|
|
|
|
; |_ _ _ |_ _ | . _ _
|
|
|
|
|
; | (-||||_(_)|__|_)|_)
|
|
|
|
|
;-------------------|----------------------------------------------------------
|
|
|
|
|
|
2009-02-19 17:29:47 -05:00
|
|
|
|
" 1))
|
2009-02-18 22:31:40 -05:00
|
|
|
|
|
|
|
|
|
(define (repl)
|
|
|
|
|
(define (prompt)
|
|
|
|
|
(princ "> ") (io.flush *output-stream*)
|
|
|
|
|
(let ((v (trycatch (read)
|
|
|
|
|
(lambda (e) (begin (io.discardbuffer *input-stream*)
|
|
|
|
|
(raise e))))))
|
|
|
|
|
(and (not (io.eof? *input-stream*))
|
|
|
|
|
(let ((V (eval v)))
|
|
|
|
|
(print V)
|
|
|
|
|
(set! that V)
|
|
|
|
|
#t))))
|
|
|
|
|
(define (reploop)
|
|
|
|
|
(when (trycatch (and (prompt) (princ "\n"))
|
|
|
|
|
print-exception)
|
|
|
|
|
(begin (princ "\n")
|
|
|
|
|
(reploop))))
|
|
|
|
|
(reploop)
|
|
|
|
|
(princ "\n"))
|
|
|
|
|
|
|
|
|
|
(define (print-exception e)
|
|
|
|
|
(cond ((and (pair? e)
|
|
|
|
|
(eq? (car e) 'type-error)
|
|
|
|
|
(= (length e) 4))
|
|
|
|
|
(io.princ *stderr* "type-error: ")
|
|
|
|
|
(io.print *stderr* (cadr e))
|
|
|
|
|
(io.princ *stderr* ": expected ")
|
|
|
|
|
(io.print *stderr* (caddr e))
|
|
|
|
|
(io.princ *stderr* ", got ")
|
|
|
|
|
(io.print *stderr* (cadddr e)))
|
|
|
|
|
|
|
|
|
|
((and (pair? e)
|
|
|
|
|
(eq? (car e) 'unbound-error)
|
|
|
|
|
(pair? (cdr e)))
|
|
|
|
|
(io.princ *stderr*
|
|
|
|
|
"unbound-error: eval: variable " (cadr e)
|
|
|
|
|
" has no value"))
|
|
|
|
|
|
|
|
|
|
((and (pair? e)
|
|
|
|
|
(eq? (car e) 'error))
|
|
|
|
|
(io.princ *stderr* "error: ")
|
|
|
|
|
(apply io.princ (cons *stderr* (cdr e))))
|
|
|
|
|
|
|
|
|
|
((and (pair? e)
|
|
|
|
|
(eq? (car e) 'load-error))
|
|
|
|
|
(print-exception (caddr e))
|
|
|
|
|
(io.princ *stderr* "in file " (cadr e)))
|
|
|
|
|
|
|
|
|
|
((and (list? e)
|
|
|
|
|
(= (length e) 2))
|
|
|
|
|
(io.princ *stderr* (car e) ": " (cadr e)))
|
|
|
|
|
|
|
|
|
|
(else (io.princ *stderr* "*** Unhandled exception: ")
|
|
|
|
|
(io.print *stderr* e)))
|
|
|
|
|
|
|
|
|
|
(io.princ *stderr* "\n")
|
|
|
|
|
#t)
|
|
|
|
|
|
|
|
|
|
(define (__script fname)
|
|
|
|
|
(trycatch (load fname)
|
|
|
|
|
(lambda (e) (begin (print-exception e)
|
|
|
|
|
(exit 1)))))
|
|
|
|
|
|
|
|
|
|
(define (__start . argv)
|
|
|
|
|
(if (pair? (cdr argv))
|
|
|
|
|
(begin (set! *argv* (cdr argv))
|
|
|
|
|
(__script (cadr argv)))
|
|
|
|
|
(begin (set! *argv* argv)
|
|
|
|
|
(princ *banner*)
|
|
|
|
|
(repl)))
|
|
|
|
|
(exit 0))
|