upscheme/femtolisp/torture.scm

(define ones (map (lambda (x) 1) (iota 1000000)))

(display (apply + ones))
(newline)

(define (big n)
  (if (<= n 0)
      0
      `(+ 1 1 1 1 1 1 1 1 1 1 ,(big (- n 1)))))

(define nst (big 100000))

(display (eval nst))
(newline)

(define longg (cons '+ ones))
(display (eval longg))
(newline)

(define (f x)
  (begin (display x)
	 (newline)
	 (f (+ x 1))
	 0))
optimizations to map and case several optimizations to the compiler itself, mostly involving emit and encode-byte-code experimental, very basic profiling utility 2009-06-10 20:34:50 -04:00			`(define ones (map (lambda (x) 1) (iota 1000000)))`

			`(display (apply + ones))`
			`(newline)`

adding the ability to heap-allocate extentions to the value stack, so recursion depth is limited only by the process stack limit. reorganizing evaluator so the same code is used for evaluating and pushing arguments for both builtin functions and lambdas. for now this is slower, but it was done in preparation for Things To Come. adding list-head implementing the calling convention for long argument lists in bytecode compiler. arguments are broken down into a nest of list and nconc calls. also implementing vararg builtins. 2009-04-01 00:31:49 -04:00			`(define (big n)`
			`(if (<= n 0)`
			`0`
			`(+ 1 1 1 1 1 1 1 1 1 1 ,(big (- n 1)))))

optimizations to map and case several optimizations to the compiler itself, mostly involving emit and encode-byte-code experimental, very basic profiling utility 2009-06-10 20:34:50 -04:00			`(define nst (big 100000))`
adding the ability to heap-allocate extentions to the value stack, so recursion depth is limited only by the process stack limit. reorganizing evaluator so the same code is used for evaluating and pushing arguments for both builtin functions and lambdas. for now this is slower, but it was done in preparation for Things To Come. adding list-head implementing the calling convention for long argument lists in bytecode compiler. arguments are broken down into a nest of list and nconc calls. also implementing vararg builtins. 2009-04-01 00:31:49 -04:00
			`(display (eval nst))`
			`(newline)`

optimizations to map and case several optimizations to the compiler itself, mostly involving emit and encode-byte-code experimental, very basic profiling utility 2009-06-10 20:34:50 -04:00			`(define longg (cons '+ ones))`
			`(display (eval longg))`
			`(newline)`

adding the ability to heap-allocate extentions to the value stack, so recursion depth is limited only by the process stack limit. reorganizing evaluator so the same code is used for evaluating and pushing arguments for both builtin functions and lambdas. for now this is slower, but it was done in preparation for Things To Come. adding list-head implementing the calling convention for long argument lists in bytecode compiler. arguments are broken down into a nest of list and nconc calls. also implementing vararg builtins. 2009-04-01 00:31:49 -04:00			`(define (f x)`
			`(begin (display x)`
			`(newline)`
			`(f (+ x 1))`
			`0))`