nendo 0.5.0 → 0.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (19) hide show
  1. data/emacs/nendo-mode.el +2 -0
  2. data/lib/init.nnd +51 -35
  3. data/lib/init.nndc +3371 -2920
  4. data/lib/nendo.rb +463 -194
  5. data/lib/srfi-2.nndc +48 -165
  6. data/lib/srfi-26.nndc +142 -511
  7. data/lib/text/html-lite.nndc +23 -1
  8. data/lib/util/combinations.nnd +290 -0
  9. data/lib/util/combinations.nndc +7218 -0
  10. data/lib/util/list.nndc +138 -387
  11. data/lib/util/match.nnd +672 -0
  12. data/lib/util/match.nndc +81024 -0
  13. data/test/match-test.nnd +186 -0
  14. data/test/nendo-util-test.nnd +5 -7
  15. data/test/nendo_spec.rb +697 -235
  16. data/test/syntax_spec.rb +561 -52
  17. data/test/util-combinations-test.nnd +383 -0
  18. metadata +9 -4
  19. data/example/scratch.nnd +0 -119
data/test/nendo_spec.rb CHANGED
@@ -2,24 +2,24 @@
2
2
  # -*- encoding: utf-8 -*-
3
3
  #
4
4
  # nendo_spec.rb - "RSpec file for nendo language"
5
- #
5
+ #
6
6
  # Copyright (c) 2009-2010 Kiyoka Nishiyama <kiyoka@sumibi.org>
7
- #
7
+ #
8
8
  # Redistribution and use in source and binary forms, with or without
9
9
  # modification, are permitted provided that the following conditions
10
10
  # are met:
11
- #
11
+ #
12
12
  # 1. Redistributions of source code must retain the above copyright
13
13
  # notice, this list of conditions and the following disclaimer.
14
- #
14
+ #
15
15
  # 2. Redistributions in binary form must reproduce the above copyright
16
16
  # notice, this list of conditions and the following disclaimer in the
17
17
  # documentation and/or other materials provided with the distribution.
18
- #
18
+ #
19
19
  # 3. Neither the name of the authors nor the names of its contributors
20
20
  # may be used to endorse or promote products derived from this
21
21
  # software without specific prior written permission.
22
- #
22
+ #
23
23
  # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24
24
  # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25
25
  # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -31,7 +31,7 @@
31
31
  # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32
32
  # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33
33
  # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34
- #
34
+ #
35
35
  require 'nendo'
36
36
  include Nendo
37
37
 
@@ -56,7 +56,7 @@ describe Cell, "when initialized as '(100)" do
56
56
  before do
57
57
  @cell = Cell.new( 100 )
58
58
  end
59
-
59
+
60
60
  it "should" do
61
61
  @cell.isNull.should_not be_true
62
62
  @cell.length.should == 1
@@ -75,7 +75,7 @@ describe Cell, "when initialized as '(100 . 200)" do
75
75
  before do
76
76
  @cell = Cell.new( 100, 200 )
77
77
  end
78
-
78
+
79
79
  it "should" do
80
80
  @cell.isNull.should_not be_true
81
81
  @cell.isDotted.should be_true
@@ -95,7 +95,7 @@ describe Cell, "when initialized as '(cons 100 (cons 200 300)) " do
95
95
  before do
96
96
  @cell = Cell.new( 100, Cell.new( 200, 300 ))
97
97
  end
98
-
98
+
99
99
  it "should" do
100
100
  @cell.isNull.should_not be_true
101
101
  @cell.isDotted.should_not be_true
@@ -534,15 +534,15 @@ describe Nendo, "when use quote and syntax-quote " do
534
534
  @nendo.evalStr( " (quote (1 . 2)) " ).should == "(1 . 2)"
535
535
  @nendo.evalStr( " (syntax-quote ())" ).should == "()"
536
536
  @nendo.evalStr( " (syntax-quote 1)" ).should == "1"
537
- @nendo.evalStr( " (syntax-quote \"str\") " ).should == '"str"'
537
+ @nendo.evalStr( ' (syntax-quote "str") ' ).should == '"str"'
538
538
  @nendo.evalStr( " (syntax-quote (1 . 2)) " ).should == "(1 . 2)"
539
- @nendo.evalStr( " (quote quote) " ).should == "'"
540
- @nendo.evalStr( " 'quote " ).should == "'"
541
- @nendo.evalStr( " ''1 " ).should == "'1"
542
- @nendo.evalStr( " (quote syntax-quote) " ).should == "syntax-quote"
543
- @nendo.evalStr( " (syntax-quote '1) " ).should == "'1"
544
- @nendo.evalStr( " (syntax-quote (quote 1)) " ).should == "'1"
545
- @nendo.evalStr( " (quote (syntax-quote 1)) " ).should == "(syntax-quote 1)"
539
+ @nendo.evalStr( " (quote quote) " ).should == "quote"
540
+ @nendo.evalStr( " 'quote " ).should == "quote"
541
+ @nendo.evalStr( " ''1 " ).should == "(quote 1)"
542
+ @nendo.evalStr( " (quote syntax-quote) " ).should == "quote"
543
+ @nendo.evalStr( " (syntax-quote '1) " ).should == "(quote 1)"
544
+ @nendo.evalStr( " (syntax-quote (quote 1)) " ).should == "(quote 1)"
545
+ @nendo.evalStr( " (quote (syntax-quote 1)) " ).should == "(quote 1)"
546
546
  end
547
547
  end
548
548
 
@@ -565,9 +565,9 @@ describe Nendo, "when read various list expressions" do
565
565
  @nendo.evalStr( " '[a (b) ((c)) (((d)))] " ).should == "(a (b) ((c)) (((d))))"
566
566
  @nendo.evalStr( " '(a [b] ([c]) (([d]))) " ).should == "(a (b) ((c)) (((d))))"
567
567
  @nendo.evalStr( " '[a [b] [[c]] [[[d]]]] " ).should == "(a (b) ((c)) (((d))))"
568
- @nendo.evalStr( " '('a)" ).should == "('a)"
569
- @nendo.evalStr( " '(''a)" ).should == "(''a)"
570
- @nendo.evalStr( " '('a 'b 'c)" ).should == "('a 'b 'c)"
568
+ @nendo.evalStr( " '('a)" ).should == "((quote a))"
569
+ @nendo.evalStr( " '(''a)" ).should == "((quote (quote a)))"
570
+ @nendo.evalStr( " '('a 'b 'c)" ).should == "((quote a) (quote b) (quote c))"
571
571
  @nendo.evalStr( ' \'("str") ' ).should == '("str")'
572
572
  @nendo.evalStr( ' \'("str" . 1) ' ).should == '("str" . 1)'
573
573
  @nendo.evalStr( ' \'(1 . "str") ' ).should == '(1 . "str")'
@@ -577,13 +577,13 @@ describe Nendo, "when read various list expressions" do
577
577
  @nendo.evalStr( " 'symbol " ).should == "symbol"
578
578
  @nendo.evalStr( " 'SYMBOL " ).should == "SYMBOL"
579
579
  @nendo.evalStr( " 'SyMbOl " ).should == "SyMbOl"
580
- @nendo.evalStr( " ''a " ).should == "'a"
580
+ @nendo.evalStr( " ''a " ).should == "(quote a)"
581
581
  @nendo.evalStr( " '1 " ).should == "1"
582
- @nendo.evalStr( " ''1 " ).should == "'1"
583
- @nendo.evalStr( " '''1 " ).should == "''1"
582
+ @nendo.evalStr( " ''1 " ).should == "(quote 1)"
583
+ @nendo.evalStr( " '''1 " ).should == "(quote (quote 1))"
584
584
  @nendo.evalStr( " '1.1 " ).should == "1.1"
585
- @nendo.evalStr( " ''1.1 " ).should == "'1.1"
586
- @nendo.evalStr( " '''1.1 " ).should == "''1.1"
585
+ @nendo.evalStr( " ''1.1 " ).should == "(quote 1.1)"
586
+ @nendo.evalStr( " '''1.1 " ).should == "(quote (quote 1.1))"
587
587
  @nendo.evalStr( " '() " ).should == "()"
588
588
  @nendo.evalStr( " '(()) " ).should == "(())"
589
589
  @nendo.evalStr( " '((())) " ).should == "((()))"
@@ -594,7 +594,7 @@ describe Nendo, "when read various list expressions" do
594
594
  @nendo.evalStr( " '(a . #f) " ).should == "(a . #f)"
595
595
  @nendo.evalStr( " '(a . nil) " ).should == "(a . nil)"
596
596
  @nendo.evalStr( " '(a b c d e . ()) " ).should == "(a b c d e)"
597
- @nendo.evalStr( " '(#t #t #f #f nil nil '() '()) " ).should == "(#t #t #f #f nil nil '() '())"
597
+ @nendo.evalStr( " '(#t #t #f #f nil nil '() '()) " ).should == "(#t #t #f #f nil nil (quote ()) (quote ()))"
598
598
  end
599
599
  end
600
600
 
@@ -686,6 +686,10 @@ describe Nendo, "when call evalStr() with built-in functions" do
686
686
  @nendo.evalStr( " (list '(a) '((b c))) " ).should == "((a) ((b c)))"
687
687
  @nendo.evalStr( " (list) " ).should == "()"
688
688
  @nendo.evalStr( " (list 1) " ).should == "(1)"
689
+ @nendo.evalStr( " (reverse '(1)) " ).should == "(1)"
690
+ @nendo.evalStr( " (reverse '(1 2 3)) " ).should == "(3 2 1)"
691
+ @nendo.evalStr( " (reverse '(1 2 ())) " ).should == "(() 2 1)"
692
+ @nendo.evalStr( " (reverse (list 1 2 (cdr '(100)))) " ).should == "(() 2 1)"
689
693
  @nendo.evalStr( " (define !a 10) !a" ).should == "10"
690
694
  @nendo.evalStr( " (define $a 11) $a" ).should == "11"
691
695
  @nendo.evalStr( " (define %a 12) %a" ).should == "12"
@@ -865,21 +869,40 @@ describe Nendo, "when call evalStr() with built-in special forms" do
865
869
  @nendo.evalStr( " (begin 1) " ).should == "1"
866
870
  @nendo.evalStr( " (begin 1 2) " ).should == "2"
867
871
  @nendo.evalStr( " (begin 1 2 3) " ).should == "3"
868
- @nendo.evalStr( " (set! x 2) (set! y (begin (set! x (* x 2)) (set! x (* x 2)) (set! x (* x 2)) 100)) (+ x y)" ).should == "116"
869
- @nendo.evalStr( " (let () 100) " ).should == "100"
870
- @nendo.evalStr( " (let ((a 11)) a) " ).should == "11"
871
- @nendo.evalStr( " (let ((a 11) (b 22)) (+ a b)) " ).should == "33"
872
- @nendo.evalStr( " (let ((a 22)) (let ((b 33)) (+ a b))) " ).should == "55"
873
- @nendo.evalStr( " (let ((a 22)(b 33)) (let ((c 44) (d 55)) (+ a b c d))) " ).should == "154"
874
- @nendo.evalStr( " (let ((a (let ((b 2)) (+ 100 b)))) a) " ).should == "102"
872
+ @nendo.evalStr( <<EOS
873
+ (set! x 2)
874
+ (set! y (begin
875
+ (set! x (* x 2))
876
+ (set! x (* x 2))
877
+ (set! x (* x 2))
878
+ 100))
879
+ (+ x y)
880
+ EOS
881
+ ).should == "116"
882
+ @nendo.evalStr( " (%let () 100) " ).should == "100"
883
+ @nendo.evalStr( " (%let ((a 11)) a) " ).should == "11"
884
+ @nendo.evalStr( " (%let ((a 11) (b 22)) (+ a b)) " ).should == "33"
885
+ @nendo.evalStr( " (%let ((a 22)) (%let ((b 33)) (+ a b))) " ).should == "55"
886
+ @nendo.evalStr( " (%let ((a 22)(b 33)) (%let ((c 44) (d 55)) (+ a b c d))) " ).should == "154"
887
+ @nendo.evalStr( " (%let ((a (%let ((b 2)) (+ 100 b)))) a) " ).should == "102"
875
888
  @nendo.evalStr( " (letrec () 100) " ).should == "100"
876
889
  @nendo.evalStr( " (letrec ((a 11)) a) " ).should == "11"
877
890
  @nendo.evalStr( " (letrec ((a 11) (b 22)) (+ a b)) " ).should == "33"
878
- @nendo.evalStr( " (letrec ((a 22)) (let ((b 33)) (+ a b))) " ).should == "55"
879
- @nendo.evalStr( " (letrec ((a 22)(b 33)) (let ((c 44) (d 55)) (+ a b c d))) " ).should == "154"
880
- @nendo.evalStr( " (letrec ((a (let ((b 2)) (+ 100 b)))) a) " ).should == "102"
881
- @nendo.evalStr( " (letrec ( (func1 (lambda (x) 13)) (func2 (lambda (x) (* 2 (func1)))) ) (list (func2) (func1))) " ).should == "(26 13)"
882
- @nendo.evalStr( " (letrec ( (func2 (lambda (x) (* 2 (func1)))) (func1 (lambda (x) 7)) ) (list (func2) (func1))) " ).should == "(14 7)"
891
+ @nendo.evalStr( " (letrec ((a 22)) (%let ((b 33)) (+ a b))) " ).should == "55"
892
+ @nendo.evalStr( " (letrec ((a 22)(b 33)) (%let ((c 44) (d 55)) (+ a b c d))) " ).should == "154"
893
+ @nendo.evalStr( " (letrec ((a (%let ((b 2)) (+ 100 b)))) a) " ).should == "102"
894
+ @nendo.evalStr( <<EOS
895
+ (letrec ((func1 (lambda (x) 13))
896
+ (func2 (lambda (x) (* 2 (func1)))))
897
+ (list (func2) (func1)))
898
+ EOS
899
+ ).should == "(26 13)"
900
+ @nendo.evalStr( <<EOS
901
+ (letrec ((func2 (lambda (x) (* 2 (func1))))
902
+ (func1 (lambda (x) 7)))
903
+ (list (func2) (func1)))
904
+ EOS
905
+ ).should == "(14 7)"
883
906
  @nendo.evalStr( " (if true 't 'f)" ).should == "t"
884
907
  @nendo.evalStr( " (if true '(1) '(2))" ).should == "(1)"
885
908
  @nendo.evalStr( " (if false 't 'f)" ).should == "f"
@@ -887,11 +910,18 @@ describe Nendo, "when call evalStr() with built-in special forms" do
887
910
  @nendo.evalStr( " (set! x 0) (if true (set! x 1) (set! x 2)) x" ).should == "1"
888
911
  @nendo.evalStr( " (set! x 0) (if false (set! x 1) (set! x 2)) x" ).should == "2"
889
912
  @nendo.evalStr( " (set! func (lambda (arg1) arg1)) (list (func 1) (func 2))" ).should == "(1 2)"
890
- @nendo.evalStr( " ((lambda (arg1) arg1) 3)" ).should == "3"
891
- @nendo.evalStr( " ((lambda (arg1) arg1) (+ 1 2 3))" ).should == "6"
892
- @nendo.evalStr( " ((if #t + *) 3 4)" ).should == "7"
893
- @nendo.evalStr( " ((if #f + *) 3 4)" ).should == "12"
894
- @nendo.evalStr( " (apply1 + '(1 2))" ).should == "3"
913
+ @nendo.evalStr( " ((lambda (arg1) arg1) 3)" ).should == "3"
914
+ @nendo.evalStr( " ((lambda (arg1) arg1) (+ 1 2 3))" ).should == "6"
915
+ @nendo.evalStr( " ((lambda (arg1 . arg2) arg1) 1 '(2))" ).should == "1"
916
+ @nendo.evalStr( " ((lambda (arg1 . arg2) arg2) 1 '(2))" ).should == "((2))"
917
+ @nendo.evalStr( " ((lambda (arg1 . arg2) arg2) 1 '(2 3))" ).should == "((2 3))"
918
+ @nendo.evalStr( " ((lambda (arg1 . arg2) arg1) '() '())" ).should == "()"
919
+ @nendo.evalStr( " ((lambda (arg1 . arg2) arg2) '() '())" ).should == "(())"
920
+ @nendo.evalStr( " ((lambda (arg1 . arg2) arg1) (cdr '(100)) (cdr '(200)))" ).should == "()"
921
+ @nendo.evalStr( " ((lambda (arg1 . arg2) arg2) (cdr '(100)) (cdr '(200)))" ).should == "(())"
922
+ @nendo.evalStr( " ((if #t + *) 3 4)" ).should == "7"
923
+ @nendo.evalStr( " ((if #f + *) 3 4)" ).should == "12"
924
+ @nendo.evalStr( " (apply1 + '(1 2))" ).should == "3"
895
925
  @nendo.evalStr( " (apply1 + (range 10 1))" ).should == "55"
896
926
  @nendo.evalStr( " (apply1 cons '(1 2))" ).should == "(1 . 2)"
897
927
  @nendo.evalStr( " (apply1 list '(1 2 3))" ).should == "(1 2 3)"
@@ -909,32 +939,55 @@ describe Nendo, "when call evalStr() with built-in special forms (renamed symbol
909
939
  @nendo.evalStr( " (/nendo/core/begin 1) " ).should == "1"
910
940
  @nendo.evalStr( " (/nendo/core/begin 1 2) " ).should == "2"
911
941
  @nendo.evalStr( " (/nendo/core/begin 1 2 3) " ).should == "3"
912
- @nendo.evalStr( " (/nendo/core/set! x 2) (/nendo/core/set! y (/nendo/core/begin (/nendo/core/set! x (* x 2)) (/nendo/core/set! x (* x 2)) (/nendo/core/set! x (* x 2)) 100)) (+ x y)" ).should == "116"
913
- @nendo.evalStr( " (/nendo/core/let () 100) " ).should == "100"
914
- @nendo.evalStr( " (/nendo/core/let ((a 11)) a) " ).should == "11"
915
- @nendo.evalStr( " (/nendo/core/let ((a 11) (b 22)) (+ a b)) " ).should == "33"
916
- @nendo.evalStr( " (/nendo/core/let ((a 22)) (let ((b 33)) (+ a b))) " ).should == "55"
917
- @nendo.evalStr( " (/nendo/core/let ((a 22)(b 33)) (let ((c 44) (d 55)) (+ a b c d))) " ).should == "154"
918
- @nendo.evalStr( " (/nendo/core/let ((a (let ((b 2)) (+ 100 b)))) a) " ).should == "102"
942
+ @nendo.evalStr( <<EOS
943
+ (/nendo/core/set! x 2)
944
+ (/nendo/core/set! y (/nendo/core/begin
945
+ (/nendo/core/set! x (* x 2))
946
+ (/nendo/core/set! x (* x 2))
947
+ (/nendo/core/set! x (* x 2))
948
+ 100))
949
+ (+ x y)
950
+ EOS
951
+ ).should == "116"
952
+ @nendo.evalStr( " (/nendo/core/%let () 100) " ).should == "100"
953
+ @nendo.evalStr( " (/nendo/core/%let ((a 11)) a) " ).should == "11"
954
+ @nendo.evalStr( " (/nendo/core/%let ((a 11) (b 22)) (+ a b)) " ).should == "33"
955
+ @nendo.evalStr( " (/nendo/core/%let ((a 22)) (let ((b 33)) (+ a b))) " ).should == "55"
956
+ @nendo.evalStr( " (/nendo/core/%let ((a 22)(b 33)) (let ((c 44) (d 55)) (+ a b c d))) " ).should == "154"
957
+ @nendo.evalStr( " (/nendo/core/%let ((a (let ((b 2)) (+ 100 b)))) a) " ).should == "102"
919
958
  @nendo.evalStr( " (/nendo/core/letrec () 100) " ).should == "100"
920
959
  @nendo.evalStr( " (/nendo/core/letrec ((a 11)) a) " ).should == "11"
921
960
  @nendo.evalStr( " (/nendo/core/letrec ((a 11) (b 22)) (+ a b)) " ).should == "33"
922
961
  @nendo.evalStr( " (/nendo/core/letrec ((a 22)) (let ((b 33)) (+ a b))) " ).should == "55"
923
962
  @nendo.evalStr( " (/nendo/core/letrec ((a 22)(b 33)) (let ((c 44) (d 55)) (+ a b c d))) " ).should == "154"
924
963
  @nendo.evalStr( " (/nendo/core/letrec ((a (let ((b 2)) (+ 100 b)))) a) " ).should == "102"
925
- @nendo.evalStr( " (/nendo/core/letrec ( (func1 (/nendo/core/lambda (x) 13)) (func2 (/nendo/core/lambda (x) (* 2 (func1)))) ) (list (func2) (func1))) " ).should == "(26 13)"
926
- @nendo.evalStr( " (/nendo/core/letrec ( (func2 (/nendo/core/lambda (x) (* 2 (func1)))) (func1 (/nendo/core/lambda (x) 7)) ) (list (func2) (func1))) " ).should == "(14 7)"
964
+ @nendo.evalStr( <<EOS
965
+ (/nendo/core/letrec ((func1 (/nendo/core/lambda (x) 13))
966
+ (func2 (/nendo/core/lambda (x) (* 2 (func1)))))
967
+ (list (func2) (func1)))
968
+ EOS
969
+ ).should == "(26 13)"
970
+ @nendo.evalStr( <<EOS
971
+ (/nendo/core/letrec ((func2 (/nendo/core/lambda (x) (* 2 (func1))))
972
+ (func1 (/nendo/core/lambda (x) 7)))
973
+ (list (func2) (func1)))
974
+ EOS
975
+ ).should == "(14 7)"
927
976
  @nendo.evalStr( " (/nendo/core/if true 't 'f)" ).should == "t"
928
977
  @nendo.evalStr( " (/nendo/core/if true '(1) '(2))" ).should == "(1)"
929
978
  @nendo.evalStr( " (/nendo/core/if false 't 'f)" ).should == "f"
930
979
  @nendo.evalStr( " (/nendo/core/if false '(1) '(2))" ).should == "(2)"
931
980
  @nendo.evalStr( " (/nendo/core/set! x 0) (/nendo/core/if true (set! x 1) (set! x 2)) x" ).should == "1"
932
981
  @nendo.evalStr( " (/nendo/core/set! x 0) (/nendo/core/if false (set! x 1) (set! x 2)) x" ).should == "2"
933
- @nendo.evalStr( " (/nendo/core/set! func (/nendo/core/lambda (arg1) arg1)) (list (func 1) (func 2))" ).should == "(1 2)"
934
- @nendo.evalStr( " ((/nendo/core/lambda (arg1) arg1) 3)" ).should == "3"
935
- @nendo.evalStr( " ((/nendo/core/lambda (arg1) arg1) (+ 1 2 3))" ).should == "6"
936
- @nendo.evalStr( " ((/nendo/core/if #t + *) 3 4)" ).should == "7"
937
- @nendo.evalStr( " ((/nendo/core/if #f + *) 3 4)" ).should == "12"
982
+ @nendo.evalStr( <<EOS
983
+ (/nendo/core/set! func (/nendo/core/lambda (arg1) arg1))
984
+ (list (func 1) (func 2))
985
+ EOS
986
+ ).should == "(1 2)"
987
+ @nendo.evalStr( " ((/nendo/core/lambda (arg1) arg1) 3)" ).should == "3"
988
+ @nendo.evalStr( " ((/nendo/core/lambda (arg1) arg1) (+ 1 2 3))" ).should == "6"
989
+ @nendo.evalStr( " ((/nendo/core/if #t + *) 3 4)" ).should == "7"
990
+ @nendo.evalStr( " ((/nendo/core/if #f + *) 3 4)" ).should == "12"
938
991
  lambda { @nendo.evalStr( " (/nendo/core/error \"My Runtime Error\") " ) }.should raise_error( RuntimeError )
939
992
  end
940
993
  end
@@ -946,26 +999,28 @@ describe Nendo, "when call evalStr() with global and lexical scope variable" do
946
999
  end
947
1000
  it "should" do
948
1001
  @nendo.evalStr( " (define var 111) " ).should == "111"
949
- @nendo.evalStr( " (let ((var 222)) var) " ).should == "222"
950
- @nendo.evalStr( " (let ((var 222)) (set! var 333) var) " ).should == "333"
951
- @nendo.evalStr( " (let ((var 222)) (set! var 333)) var " ).should == "111"
1002
+ @nendo.evalStr( " (%let ((var 222)) var) " ).should == "222"
1003
+ @nendo.evalStr( " (%let ((var 222)) (set! var 333) var) " ).should == "333"
1004
+ @nendo.evalStr( " (%let ((var 222)) (set! var 333)) var " ).should == "111"
952
1005
  @nendo.evalStr( " (define global1 \"G\") " ).should == '"G"'
953
- @nendo.evalStr( " " +
954
- "(let ((local1 \"L\")" +
955
- " (local2 \"L\"))" +
956
- " (set! global1 (+ global1 \"lobal1\"))" +
957
- " (set! local1 (+ local1 \"ocal1\"))" +
958
- " (set! local2 (+ local2 \"ocal2\"))" +
959
- " (list global1" +
960
- " local1" +
961
- " local2" +
962
- " (let ((local1 \"A\")" +
963
- " (local2 \"B\"))" +
964
- " (set! local1 (+ local1 \"a\"))" +
965
- " (set! local2 (+ local2 \"b\"))" +
966
- " (list local1 local2" +
967
- " (let ((local1 \"CCC\"))" +
968
- " (list global1 local1 local2))))))" ).should == '("Global1" "Local1" "Local2" ("Aa" "Bb" ("Global1" "CCC" "Bb")))'
1006
+ @nendo.evalStr( <<EOS
1007
+ (%let ((local1 \"L\")
1008
+ (local2 \"L\"))
1009
+ (set! global1 (+ global1 \"lobal1\"))
1010
+ (set! local1 (+ local1 \"ocal1\"))
1011
+ (set! local2 (+ local2 \"ocal2\"))
1012
+ (list global1
1013
+ local1
1014
+ local2
1015
+ (%let ((local1 \"A\")
1016
+ (local2 \"B\"))
1017
+ (set! local1 (+ local1 \"a\"))
1018
+ (set! local2 (+ local2 \"b\"))
1019
+ (list local1 local2
1020
+ (%let ((local1 \"CCC\"))
1021
+ (list global1 local1 local2))))))
1022
+ EOS
1023
+ ).should == '("Global1" "Local1" "Local2" ("Aa" "Bb" ("Global1" "CCC" "Bb")))'
969
1024
  end
970
1025
  end
971
1026
 
@@ -974,18 +1029,48 @@ describe Nendo, "when call evalStr() with macroexpand-1 function" do
974
1029
  @nendo = Nendo::Core.new()
975
1030
  end
976
1031
  it "should" do
977
- @nendo.evalStr( " (set! twice (macro (x) (list 'begin x x))) (macroexpand-1 '(twice (+ 1 1))) " ).should == "(begin (+ 1 1) (+ 1 1))"
978
- @nendo.evalStr( " (set! inc (macro (x) (list 'set! x (list '+ x 1)))) (macroexpand-1 '(inc a)) " ).should == "(set! a (+ a 1))"
1032
+ @nendo.evalStr( <<EOS
1033
+ (set! twice (macro (x) (list 'begin x x)))
1034
+ (macroexpand-1 '(twice (+ 1 1)))
1035
+ EOS
1036
+ ).should == "(begin (+ 1 1) (+ 1 1))"
1037
+ @nendo.evalStr( <<EOS
1038
+ (set! inc (macro (x) (list 'set! x (list '+ x 1))))
1039
+ (macroexpand-1 '(inc a))
1040
+ EOS
1041
+ ).should == "(set! a (+ a 1))"
979
1042
  @nendo.evalStr( " (set! a 10) (inc a) " ).should == "11"
980
1043
  @nendo.evalStr( " (set! a 10) (inc a) (inc a)" ).should == "12"
981
- @nendo.evalStr( " (macroexpand-1 '(twice (twice (inc a))))" ).should ==
1044
+ @nendo.evalStr( <<EOS
1045
+ (macroexpand-1
1046
+ '(twice (twice (inc a))))
1047
+ EOS
1048
+ ).should ==
982
1049
  "(begin (twice (inc a)) (twice (inc a)))"
983
- @nendo.evalStr( " (macroexpand-1 (macroexpand-1 '(twice (twice (inc a)))))" ).should ==
984
- "(begin (begin (inc a) (inc a)) (begin (inc a) (inc a)))"
985
- @nendo.evalStr( " (macroexpand-1 (macroexpand-1 (macroexpand-1 '(twice (twice (inc a))))))" ).should ==
986
- "(begin (begin (set! a (+ a 1)) (set! a (+ a 1))) (begin (inc a) (inc a)))"
987
- @nendo.evalStr( " (macroexpand-1 (macroexpand-1 (macroexpand-1 (macroexpand-1 '(twice (twice (inc a)))))))" ).should ==
988
- "(begin (begin (set! a (+ a 1)) (set! a (+ a 1))) (begin (set! a (+ a 1)) (set! a (+ a 1))))"
1050
+ @nendo.evalStr( <<EOS
1051
+ (macroexpand-1
1052
+ (macroexpand-1
1053
+ '(twice (twice (inc a)))))
1054
+ EOS
1055
+ ).should ==
1056
+ "(begin (begin (inc a) (inc a)) (twice (inc a)))"
1057
+ @nendo.evalStr( <<EOS
1058
+ (macroexpand-1
1059
+ (macroexpand-1
1060
+ (macroexpand-1
1061
+ '(twice (twice (inc a))))))
1062
+ EOS
1063
+ ).should ==
1064
+ "(begin (begin (set! a (+ a 1)) (inc a)) (twice (inc a)))"
1065
+ @nendo.evalStr( <<EOS
1066
+ (macroexpand-1
1067
+ (macroexpand-1
1068
+ (macroexpand-1
1069
+ (macroexpand-1
1070
+ '(twice (twice (inc a)))))))
1071
+ EOS
1072
+ ).should ==
1073
+ "(begin (begin (set! a (+ a 1)) (set! a (+ a 1))) (twice (inc a)))"
989
1074
  @nendo.evalStr( " (set! a 10) (twice (twice (inc a)))" ).should == "14"
990
1075
  end
991
1076
  end
@@ -1004,7 +1089,17 @@ describe Nendo, "when use #xxxx syntax " do
1004
1089
  @nendo.evalStr( " #! \n #t" ).should == "#t"
1005
1090
  @nendo.evalStr( " #! \n 100" ).should == "100"
1006
1091
  @nendo.evalStr( " #! 123 \n 100" ).should == "100"
1007
- @nendo.evalStr( " '#?=1" ).should == "(debug-print 1 \"(string)\" 1 '1)"
1092
+ @nendo.evalStr( " '#?=1" ).should == "(debug-print 1 \"(string)\" 1 (quote 1))"
1093
+ @nendo.evalStr( " '#?." ).should == '"(string):1"'
1094
+ @nendo.evalStr( " '#?." ).should == '"(string):1"'
1095
+ @nendo.evalStr( " (begin #?. (+ 1 1))" ).should == "2"
1096
+ @nendo.evalStr( <<EOS
1097
+ (begin
1098
+ #?.
1099
+ (+ 1 1)
1100
+ #?. )
1101
+ EOS
1102
+ ).should == '"(string):4"'
1008
1103
  @nendo.evalStr( " #b0 " ).should == Integer("0b0").to_s
1009
1104
  @nendo.evalStr( " #b01 " ).should == Integer("0b01").to_s
1010
1105
  @nendo.evalStr( " #b10 " ).should == Integer("0b10").to_s
@@ -1080,7 +1175,7 @@ describe Nendo, "when use regexp litteral and library functions " do
1080
1175
  @nendo.evalStr( " #/[a-z]/i " ).should == "#/[a-z]/i"
1081
1176
  lambda { @nendo.evalStr( " #/[a-z]/I " ) }.should raise_error(NameError)
1082
1177
  lambda { @nendo.evalStr( " #/[a-z]/a " ) }.should raise_error(NameError)
1083
-
1178
+
1084
1179
  @nendo.evalStr( ' (string->regexp "abc") ' ).should == '#/abc/'
1085
1180
  @nendo.evalStr( ' (string->regexp "[a-z]") ' ).should == '#/[a-z]/'
1086
1181
  @nendo.evalStr( ' (string->regexp "[a-zA-Z0-9]+" ) ' ).should == '#/[a-zA-Z0-9]+/'
@@ -1136,7 +1231,12 @@ describe Nendo, "when use regexp litteral and library functions " do
1136
1231
  @nendo.evalStr( ' (rxmatch->string #/XXX/ "xxx")' ).should == '#f'
1137
1232
 
1138
1233
  pending( "JRuby can't compute correctly" ) if defined? JRUBY_VERSION
1139
- @nendo.evalStr( ' (define matchdata (rxmatch #/([あ-ん])([あ-ん])([あ-ん])([あ-ん])([あ-ん])/ "ABC漢字あいうえお漢字ABC")) ' ).should == 'あいうえお'
1234
+ @nendo.evalStr( <<EOS
1235
+ (define matchdata
1236
+ (rxmatch #/([あ-ん])([あ-ん])([あ-ん])([あ-ん])([あ-ん])/
1237
+ "ABC漢字あいうえお漢字ABC"))
1238
+ EOS
1239
+ ).should == 'あいうえお'
1140
1240
  @nendo.evalStr( ' (rxmatch-start matchdata) ' ).should == '5'
1141
1241
  @nendo.evalStr( ' (rxmatch-end matchdata) ' ).should == '10'
1142
1242
  @nendo.evalStr( ' (rxmatch-substring matchdata) ' ).should == '"あいうえお"'
@@ -1168,6 +1268,17 @@ describe Nendo, "when call functions in init.nnd " do
1168
1268
  @nendo.evalStr( " (append '() '(2)) " ).should == "(2)"
1169
1269
  @nendo.evalStr( " (append '(1) '(2)) " ).should == "(1 2)"
1170
1270
  @nendo.evalStr( " (append '(1 2) '(3 4)) " ).should == "(1 2 3 4)"
1271
+ @nendo.evalStr( " (append '(1 2) (cdr '(200))) " ).should == "(1 2)"
1272
+ @nendo.evalStr( " (append (cdr '(100)) '(10 20)) " ).should == "(10 20)"
1273
+ @nendo.evalStr( " (define lst '()) " ).should == "()"
1274
+ @nendo.evalStr( " (push! lst 1) " ).should == "(1)"
1275
+ @nendo.evalStr( " lst " ).should == "(1)"
1276
+ @nendo.evalStr( " (push! lst 2) " ).should == "(2 1)"
1277
+ @nendo.evalStr( " lst " ).should == "(2 1)"
1278
+ @nendo.evalStr( " (push! lst 3) " ).should == "(3 2 1)"
1279
+ @nendo.evalStr( " lst " ).should == "(3 2 1)"
1280
+ @nendo.evalStr( ' (push! lst "str") ' ).should == '("str" 3 2 1)'
1281
+ @nendo.evalStr( " lst " ).should == '("str" 3 2 1)'
1171
1282
  @nendo.evalStr( " (pair? '()) " ).should == "#f"
1172
1283
  @nendo.evalStr( " (pair? '(1)) " ).should == "#t"
1173
1284
  @nendo.evalStr( " (pair? '(1 2)) " ).should == "#t"
@@ -1256,6 +1367,11 @@ describe Nendo, "when call functions in init.nnd " do
1256
1367
  @nendo.evalStr( ' (string-append "a") ' ).should == '"a"'
1257
1368
  @nendo.evalStr( ' (string-append "a" "b") ' ).should == '"ab"'
1258
1369
  @nendo.evalStr( ' (string-append "a" "B" "c" "D" "e") ' ).should == '"aBcDe"'
1370
+ @nendo.evalStr( ' (string=? "ABC" "ABC") ' ).should == '#t'
1371
+ @nendo.evalStr( ' (string=? "ABC" "ABc") ' ).should == '#f'
1372
+ @nendo.evalStr( ' (string=? "ABC" "abc") ' ).should == '#f'
1373
+ @nendo.evalStr( ' (string=? 100 100) ' ).should == '#t'
1374
+ @nendo.evalStr( ' (string=? (+ "A" "B") "AB") ' ).should == '#t'
1259
1375
  @nendo.evalStr( " (to_i \"22\") " ).should == '22'
1260
1376
  @nendo.evalStr( " (to-i \"22\") " ).should == '22'
1261
1377
  @nendo.evalStr( " (to_i \"10000\") " ).should == '10000'
@@ -1289,8 +1405,27 @@ describe Nendo, "when call functions in init.nnd " do
1289
1405
  @nendo.evalStr( " (cond (true 1) (true 2)) " ).should == "1"
1290
1406
  @nendo.evalStr( " (cond (false 1) (false 2)) " ).should == "()"
1291
1407
  @nendo.evalStr( " (cond (false 1) (false 2) (else 3)) " ).should == "3"
1292
- @nendo.evalStr( " (cond ((- 10 9) => (lambda (x) (+ \"<\" (to_s x) \">\"))) (else 2)) " ).should == '"<1>"'
1293
- @nendo.evalStr( " (cond (true 1) ((- 10 8) => (lambda (x) (+ \"<\" (to_s x) \">\"))) (else 3)) " ).should == "1"
1408
+ @nendo.evalStr( <<EOS
1409
+ (cond
1410
+ ((- 10 9)
1411
+ =>
1412
+ (lambda (x)
1413
+ (+ \"<\" (to_s x) \">\")))
1414
+ (else
1415
+ 2))
1416
+ EOS
1417
+ ).should == '"<1>"'
1418
+ @nendo.evalStr( <<EOS
1419
+ (cond
1420
+ (true 1)
1421
+ ((- 10 8)
1422
+ =>
1423
+ (lambda (x)
1424
+ (+ \"<\" (to_s x) \">\")))
1425
+ (else
1426
+ 3))
1427
+ EOS
1428
+ ).should == "1"
1294
1429
  @nendo.evalStr( " (or) " ).should == "#f"
1295
1430
  @nendo.evalStr( " (or true) " ).should == "#t"
1296
1431
  @nendo.evalStr( " (or false) " ).should == "#f"
@@ -1318,8 +1453,27 @@ describe Nendo, "when call functions in init.nnd " do
1318
1453
  @nendo.evalStr( " (and true '(2) true) " ).should == "#t"
1319
1454
  @nendo.evalStr( " (and true true '(2)) " ).should == "(2)"
1320
1455
  @nendo.evalStr( " (and true '(2) false) " ).should == "#f"
1321
- @nendo.evalStr( " (define total 0) (and 1 2 (set! total (+ total 1)) (set! total (+ total 2)) 5) total" ).should == "3"
1322
- @nendo.evalStr( " (define total 1) (and 1 2 false (set! total (+ total 2)) (set! total (+ total 3)) 5) total" ).should == "1"
1456
+ @nendo.evalStr( <<EOS
1457
+ (define total 0)
1458
+ (and 1
1459
+ 2
1460
+ (set! total (+ total 1))
1461
+ (set! total (+ total 2))
1462
+ 5)
1463
+ total
1464
+ EOS
1465
+ ).should == "3"
1466
+ @nendo.evalStr( <<EOS
1467
+ (define total 1)
1468
+ (and 1
1469
+ 2
1470
+ false
1471
+ (set! total (+ total 2))
1472
+ (set! total (+ total 3))
1473
+ 5)
1474
+ total
1475
+ EOS
1476
+ ).should == "1"
1323
1477
  @nendo.evalStr( " (apply + 100 '()) " ).should == "100"
1324
1478
  @nendo.evalStr( " (apply + '(1 2)) " ).should == "3"
1325
1479
  @nendo.evalStr( " (apply + 1 2 '(3)) " ).should == "6"
@@ -1333,28 +1487,134 @@ describe Nendo, "when call functions in init.nnd " do
1333
1487
  @nendo.evalStr( " (apply + (range 11)) " ).should == "55"
1334
1488
  @nendo.evalStr( " (apply + (map (lambda (x) (+ x 1)) (range 10))) " ).should == "55"
1335
1489
  @nendo.evalStr( " (apply + (append (range 11) '(100))) " ).should == "155"
1490
+ @nendo.evalStr( " (apply cons '(1 2)) " ).should == "(1 . 2)"
1491
+ @nendo.evalStr( " (apply list '(1 2)) " ).should == "(1 2)"
1492
+ @nendo.evalStr( " (apply list (list 1 '())) " ).should == "(1 ())"
1493
+ @nendo.evalStr( " (apply list (list 1 (cdr '(100)))) " ).should == "(1 ())"
1336
1494
  @nendo.evalStr( " (map (lambda (x) 1) '()) " ).should == "()"
1337
1495
  @nendo.evalStr( " (map (lambda (x) 1) (to-list '#())) " ).should == "()"
1338
1496
  @nendo.evalStr( " (map (lambda (x) (* x 2)) '(1 2 3)) " ).should == "(2 4 6)"
1339
1497
  @nendo.evalStr( " (map (lambda (x) (+ x 1)) '(1 2 3)) " ).should == "(2 3 4)"
1340
- @nendo.evalStr( " (map (lambda (a b) (+ a b)) '(1 2 3) '(10 20 30)) " ).should == "(11 22 33)"
1341
- @nendo.evalStr( " (map (lambda (a b) (- b a)) '(1 2 3) '(10 20 30)) " ).should == "(9 18 27)"
1342
- @nendo.evalStr( " (map (lambda (a b c) (+ a b c)) '(1 2 3) '(10 20 30) '(100 200 300)) " ).should == "(111 222 333)"
1343
- @nendo.evalStr( " (define _result"+
1344
- " (map"+
1345
- " (lambda (x)"+
1346
- " (* x 2))"+
1347
- " (range 10000 1)))"+
1348
- " (list"+
1349
- " (first _result)"+
1350
- " (second _result)"+
1351
- " (last-pair _result))" ).should == "(2 4 (20000))"
1352
- @nendo.evalStr( " (define _lst '()) (for-each (lambda (x) (set! _lst (cons 1 _lst))) '()) _lst" ).should == "()"
1353
- @nendo.evalStr( " (define _lst '()) (for-each (lambda (x) (set! _lst (cons (* x 2) _lst))) '(1 2 3)) _lst" ).should == "(6 4 2)"
1354
- @nendo.evalStr( " (define _lst '()) (for-each (lambda (x) (set! _lst (cons (+ x 1) _lst))) '(1 2 3)) _lst" ).should == "(4 3 2)"
1355
- @nendo.evalStr( " (define _lst '()) (for-each (lambda (a b) (set! _lst (cons (cons a b) _lst))) '(1 2 3) '(10 20 30)) _lst" ).should ==
1498
+ @nendo.evalStr( <<EOS
1499
+ (map
1500
+ (lambda (a b) (+ a b))
1501
+ '(1 2 3)
1502
+ '(10 20 30))
1503
+ EOS
1504
+ ).should == "(11 22 33)"
1505
+ @nendo.evalStr( <<EOS
1506
+ (map
1507
+ (lambda (a b)
1508
+ (- b a))
1509
+ '(1 2 3)
1510
+ '(10 20 30))
1511
+ EOS
1512
+ ).should == "(9 18 27)"
1513
+ @nendo.evalStr( <<EOS
1514
+ (map
1515
+ (lambda (a b c)
1516
+ (+ a b c))
1517
+ '(1 2 3)
1518
+ '(10 20 30)
1519
+ '(100 200 300))
1520
+ EOS
1521
+ ).should == "(111 222 333)"
1522
+ @nendo.evalStr( <<EOS
1523
+ (define _result
1524
+ (map
1525
+ (lambda (x)
1526
+ (* x 2))
1527
+ (range 10000 1)))
1528
+ (list
1529
+ (first _result)
1530
+ (second _result)
1531
+ (last-pair _result))
1532
+ EOS
1533
+ ).should == "(2 4 (20000))"
1534
+
1535
+ @nendo.evalStr( <<EOS
1536
+ (list
1537
+ (list* 1)
1538
+ (list* 1 2)
1539
+ (list* 1 2 3)
1540
+ (list* 1 2 3 4))
1541
+ EOS
1542
+ ).should == "(1 (1 . 2) (1 2 . 3) (1 2 3 . 4))"
1543
+
1544
+ @nendo.evalStr( <<EOS
1545
+ (list
1546
+ (list* '())
1547
+ (list* 1 '())
1548
+ (list* 1 2 '())
1549
+ (list* 1 2 3 '()))
1550
+ EOS
1551
+ ).should == "(() (1) (1 2) (1 2 3))"
1552
+
1553
+ @nendo.evalStr( <<EOS
1554
+ (list
1555
+ (list* (cdr '(100)))
1556
+ (list* 1 (cdr '(100)))
1557
+ (list* 1 2 (cdr '(100)))
1558
+ (list* 1 2 3 (cdr '(100))))
1559
+ EOS
1560
+ ).should == "(() (1) (1 2) (1 2 3))"
1561
+
1562
+ @nendo.evalStr( <<EOS
1563
+ (list
1564
+ (list* '())
1565
+ (list* '() '())
1566
+ (list* '() '() '())
1567
+ (list* '() '() '() '()))
1568
+ EOS
1569
+ ).should == "(() (()) (() ()) (() () ()))"
1570
+
1571
+ @nendo.evalStr( <<EOS
1572
+ (define _lst '())
1573
+ (for-each
1574
+ (lambda (x)
1575
+ (set! _lst (cons 1 _lst)))
1576
+ '())
1577
+ _lst
1578
+ EOS
1579
+ ).should == "()"
1580
+ @nendo.evalStr( <<EOS
1581
+ (define _lst '())
1582
+ (for-each
1583
+ (lambda (x)
1584
+ (set! _lst (cons (* x 2) _lst)))
1585
+ '(1 2 3))
1586
+ _lst
1587
+ EOS
1588
+ ).should == "(6 4 2)"
1589
+ @nendo.evalStr( <<EOS
1590
+ (define _lst '())
1591
+ (for-each
1592
+ (lambda (x)
1593
+ (set! _lst (cons (+ x 1) _lst)))
1594
+ '(1 2 3))
1595
+ _lst
1596
+ EOS
1597
+ ).should == "(4 3 2)"
1598
+ @nendo.evalStr( <<EOS
1599
+ (define _lst '())
1600
+ (for-each
1601
+ (lambda (a b)
1602
+ (set! _lst (cons (cons a b) _lst)))
1603
+ '(1 2 3)
1604
+ '(10 20 30))
1605
+ _lst
1606
+ EOS
1607
+ ).should ==
1356
1608
  "((3 . 30) (2 . 20) (1 . 10))"
1357
- @nendo.evalStr( " (define _cnt 0) (for-each (lambda (x) (set! _cnt (+ _cnt 1))) (range 10000)) _cnt" ).should == "10000"
1609
+ @nendo.evalStr( <<EOS
1610
+ (define _cnt 0)
1611
+ (for-each
1612
+ (lambda (x)
1613
+ (set! _cnt (+ _cnt 1)))
1614
+ (range 10000))
1615
+ _cnt
1616
+ EOS
1617
+ ).should == "10000"
1358
1618
  @nendo.evalStr( " (filter (lambda (x) x) '()) " ).should == "()"
1359
1619
  @nendo.evalStr( " (filter (lambda (x) (= x 100)) '(1 2 3)) " ).should == "()"
1360
1620
  @nendo.evalStr( " (filter (lambda (x) (= x 2)) '(1 2 3)) " ).should == "(2)"
@@ -1370,26 +1630,42 @@ describe Nendo, "when call functions in init.nnd " do
1370
1630
  @nendo.evalStr( " (filter-map (lambda (x) (= x 100)) '(1 2 3)) " ).should == "()"
1371
1631
  @nendo.evalStr( " (filter-map (lambda (x) (= x 2)) '(1 2 3)) " ).should == "(#t)"
1372
1632
  @nendo.evalStr( " (filter-map (lambda (x) (not (= x 2))) '(1 2 3)) " ).should == "(#t #t)"
1373
- @nendo.evalStr( " (filter-map (lambda (x) (if (= x 2) (* x 10) false)) '(1 2 3)) " ).should == "(20)"
1374
- @nendo.evalStr( " (filter-map (lambda (x) (if (not (= x 2)) (* x 10) false)) '(1 2 3)) " ).should == "(10 30)"
1633
+ @nendo.evalStr( <<EOS
1634
+ (filter-map
1635
+ (lambda (x)
1636
+ (if (= x 2) (* x 10) false))
1637
+ '(1 2 3))
1638
+ EOS
1639
+ ).should == "(20)"
1640
+ @nendo.evalStr( <<EOS
1641
+ (filter-map
1642
+ (lambda (x)
1643
+ (if (not (= x 2)) (* x 10) false))
1644
+ '(1 2 3))
1645
+ EOS
1646
+ ).should == "(10 30)"
1375
1647
  @nendo.evalStr( " (any even? '(1 2 3)) " ).should == "#t"
1376
1648
  @nendo.evalStr( " (any even? '(1 3)) " ).should == "#f"
1377
1649
  @nendo.evalStr( " (any odd? '(1 3)) " ).should == "#t"
1378
1650
  @nendo.evalStr( " (any (lambda (x) x) '(1 2 3)) " ).should == "1"
1379
- @nendo.evalStr( " " +
1380
- "(let1 result '()" +
1381
- " (do" +
1382
- " ((i 0 (+ i 1)))" +
1383
- " ((< 10 i) #f)" +
1384
- " (set! result (cons i result)))" +
1385
- " (reverse result))" ).should == "(0 1 2 3 4 5 6 7 8 9 10)"
1386
- @nendo.evalStr( " " +
1387
- "(let1 result '()" +
1388
- " (do" +
1389
- " ((i 0 (+ i 3)))" +
1390
- " ((< (* 3 10) i) #f)" +
1391
- " (set! result (cons i result)))" +
1392
- " (reverse result))" ).should == "(0 3 6 9 12 15 18 21 24 27 30)"
1651
+ @nendo.evalStr( <<EOS
1652
+ (let1 result '()
1653
+ (do
1654
+ ((i 0 (+ i 1)))
1655
+ ((< 10 i) #f)
1656
+ (set! result (cons i result)))
1657
+ (reverse result))
1658
+ EOS
1659
+ ).should == "(0 1 2 3 4 5 6 7 8 9 10)"
1660
+ @nendo.evalStr( <<EOS
1661
+ (let1 result '()
1662
+ (do
1663
+ ((i 0 (+ i 3)))
1664
+ ((< (* 3 10) i) #f)
1665
+ (set! result (cons i result)))
1666
+ (reverse result))
1667
+ EOS
1668
+ ).should == "(0 3 6 9 12 15 18 21 24 27 30)"
1393
1669
  end
1394
1670
  end
1395
1671
 
@@ -1414,22 +1690,30 @@ describe Nendo, "when use values " do
1414
1690
  @nendo.evalStr( " (values-values (values 1 2)) " ).should == "(1 2)"
1415
1691
  @nendo.evalStr( " (values-values (values 1 2 3)) " ).should == "(1 2 3)"
1416
1692
  @nendo.evalStr( " (values-values (values '(a) \"b\" '(\"C\"))) " ).should == '((a) "b" ("C"))'
1417
- @nendo.evalStr( "" +
1418
- " (call-with-values" +
1419
- " (lambda () (values 4 5)) " +
1420
- " (lambda (a b) b))" ).should == "5"
1421
- @nendo.evalStr( "" +
1422
- " (call-with-values" +
1423
- " (lambda () (values 1 2)) " +
1424
- " cons)" ).should == "(1 . 2)"
1425
- @nendo.evalStr( "" +
1426
- " (call-with-values" +
1427
- " (lambda () (values 10)) " +
1428
- " list)" ).should == "(10)"
1429
- @nendo.evalStr( "" +
1430
- " (call-with-values" +
1431
- " (lambda () (values)) " +
1432
- " list)" ).should == "()"
1693
+ @nendo.evalStr( <<EOS
1694
+ (call-with-values
1695
+ (lambda () (values 4 5))
1696
+ (lambda (a b) b))
1697
+ EOS
1698
+ ).should == "5"
1699
+ @nendo.evalStr( <<EOS
1700
+ (call-with-values
1701
+ (lambda () (values 1 2))
1702
+ cons)
1703
+ EOS
1704
+ ).should == "(1 . 2)"
1705
+ @nendo.evalStr( <<EOS
1706
+ (call-with-values
1707
+ (lambda () (values 10))
1708
+ list)
1709
+ EOS
1710
+ ).should == "(10)"
1711
+ @nendo.evalStr( <<EOS
1712
+ (call-with-values
1713
+ (lambda () (values))
1714
+ list)
1715
+ EOS
1716
+ ).should == "()"
1433
1717
  @nendo.evalStr( " (call-with-values * -) " ).should == "-1"
1434
1718
  @nendo.evalStr( " (receive (a) (values) (list a)) " ).should == "()"
1435
1719
  @nendo.evalStr( " (receive (a) (values 10) (list a)) " ).should == "(10)"
@@ -1488,7 +1772,7 @@ describe Nendo, "when use quasiquote macro " do
1488
1772
  @nendo.evalStr( " (set! a 3) `(1 2 ,@(list a)) " ).should == "(1 2 3)"
1489
1773
  @nendo.evalStr( " (set! a 3) `(1 ,@(list 2 a)) " ).should == "(1 2 3)"
1490
1774
  @nendo.evalStr( " (set! a 11) `,a " ).should == "11"
1491
- @nendo.evalStr( " (set! a 12) ``,a " ).should == "`,a"
1775
+ @nendo.evalStr( " (set! a 12) ``,a " ).should == "(quasiquote (unquote a))"
1492
1776
  @nendo.evalStr( ' (define str "string") str ' ).should == '"string"'
1493
1777
  @nendo.evalStr( ' `(,str) ' ).should == '("string")'
1494
1778
  @nendo.evalStr( ' `("STRING") ' ).should == '("STRING")'
@@ -1499,8 +1783,8 @@ describe Nendo, "when use quasiquote macro " do
1499
1783
  @nendo.evalStr( ' (caar `(("STRING" ,str))) ' ).should == '"STRING"'
1500
1784
  @nendo.evalStr( ' (string-join `("A" "B" "C" "D")) ' ).should == '"ABCD"'
1501
1785
  @nendo.evalStr( " `(list ,(+ 1 2) 4) " ).should == "(list 3 4)"
1502
- @nendo.evalStr( " (let ((name 'a)) `(list ,name ',name)) " ).should == "(list a 'a)"
1503
- @nendo.evalStr( " `(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f) " ).should == "(a `(b ,(+ 1 2) ,(foo 4 d) e) f)"
1786
+ @nendo.evalStr( " (let ((name 'a)) `(list ,name ',name)) " ).should == "(list a (quote a))"
1787
+ @nendo.evalStr( " `(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f) " ).should == "(a (quasiquote (b (unquote (+ 1 2)) (unquote (foo 4 d)) e)) f)"
1504
1788
  @nendo.evalStr( " `(( foo ,(- 10 3)) ,@(cdr '(c)) . ,(car '(cons))) " ).should == "((foo 7) . cons)"
1505
1789
  end
1506
1790
  end
@@ -1524,24 +1808,34 @@ describe Nendo, "when use macros made by quasiquote. " do
1524
1808
  @nendo.evalStr( " (let* ((a 10) (b (* a 2))) (cons a b)) " ).should == "(10 . 20)"
1525
1809
  @nendo.evalStr( " (let* ((a 10) (b (* a 2)) (c (* b 3))) (list a b c)) " ).should == "(10 20 60)"
1526
1810
  @nendo.evalStr( " (begin0 1 2 3) " ).should == "1"
1527
- @nendo.evalStr( " (define a 2) (begin0 (set! a (* a 2)) (set! a (* a 2)) (set! a (* a 2)) ) " ).should == "4"
1811
+ @nendo.evalStr( <<EOS
1812
+ (define a 2)
1813
+ (begin0 (set! a (* a 2))
1814
+ (set! a (* a 2))
1815
+ (set! a (* a 2)))
1816
+ EOS
1817
+ ).should == "4"
1528
1818
  @nendo.evalStr( " (begin0 100) " ).should == "100"
1529
1819
  @nendo.evalStr( " (begin0) " ).should == "#f"
1530
- @nendo.evalStr( " " +
1531
- "(receive (a b)" +
1532
- " (begin0" +
1533
- " (values 1 2)" +
1534
- " (values 10 20)" +
1535
- " (values 100 200))" +
1536
- " (cons a b))" ).should == "(1 . 2)"
1820
+ @nendo.evalStr( <<EOS
1821
+ (receive (a b)
1822
+ (begin0
1823
+ (values 1 2)
1824
+ (values 10 20)
1825
+ (values 100 200))
1826
+ (cons a b))
1827
+ EOS
1828
+ ).should == "(1 . 2)"
1537
1829
  @nendo.evalStr( " (macroexpand '(when #t (print \"1\") (print \"2\"))) " ).should == '(if #t (begin (print "1") (print "2")))'
1538
1830
  @nendo.evalStr( " (macroexpand '(unless #t (print \"1\") (print \"2\"))) " ).should == '(if (not #t) (begin (print "1") (print "2")))'
1539
- @nendo.evalStr( " (macroexpand '(if-let1 a #t (print \"T\") (print \"F\"))) " ).should == '(let ((a #t)) (if a (print "T") (print "F")))'
1831
+ @nendo.evalStr( " (macroexpand '(if-let1 a #t (print \"T\") (print \"F\"))) " ).should == '(%let ((a #t)) (if a (print "T") (print "F")))'
1540
1832
  @nendo.evalStr( " (let1 count 0 (when #t (set! count (+ count 1)) (set! count (+ count 1))) count) " ).should == "2"
1541
1833
  @nendo.evalStr( " (let1 count 0 (when #f (set! count (+ count 1)) (set! count (+ count 1))) count) " ).should == "0"
1542
1834
  @nendo.evalStr( " (let1 count 0 (unless #t (set! count (+ count 1)) (set! count (+ count 1))) count) " ).should == "0"
1543
1835
  @nendo.evalStr( " (let1 count 0 (unless #f (set! count (+ count 1)) (set! count (+ count 1))) count) " ).should == "2"
1544
1836
  @nendo.evalStr( " (if-let1 m (rxmatch #/([0-9]+)/ \"abc100abc\") (rxmatch-substring m 1)) " ).should == '"100"'
1837
+ @nendo.evalStr( " (macroexpand '#?.) " ).should == '"(string):1"'
1838
+ @nendo.evalStr( " (macroexpand '(begin 1 2 #?. 4 5)) " ).should == '(begin 1 2 "(string):1" 4 5)'
1545
1839
  end
1546
1840
  end
1547
1841
 
@@ -1551,11 +1845,51 @@ describe Nendo, "when use define and lambda macro " do
1551
1845
  @nendo.loadInitFile
1552
1846
  end
1553
1847
  it "should" do
1554
- @nendo.evalStr( " (macroexpand '(define (main argv) (newline) 0)) " ).should == "(define main (lambda (argv) (newline) 0))"
1555
- @nendo.evalStr( " (macroexpand '(define (main argv) (define (foo x) x) (+ 10 20) 0 (foo 111))) " ).should == "(define main (lambda (argv) (letrec ((foo (lambda (x) x))) (+ 10 20) 0 (foo 111))))"
1556
- @nendo.evalStr( " (macroexpand '(define (main argv) (define result '()) (define (foo x) x) (define val 0) (define (bar x) (+ val 10)) )) " ).should == "(define main (lambda (argv) (letrec ((result '()) (foo (lambda (x) x)) (val 0) (bar (lambda (x) (+ val 10)))))))"
1557
- @nendo.evalStr( " (define (main argv) (define (foo x) x) (+ 10 20) 0 (foo 111)) (main) " ).should == "111"
1558
- @nendo.evalStr( " (define (main argv) (define (foo1 x) (+ 1 x)) (define (foo2 x) (+ 2 x)) (* (foo1 20) (foo2 30))) (main '()) " ).should == "672"
1848
+ @nendo.evalStr( <<EOS
1849
+ (macroexpand
1850
+ '(define (main argv)
1851
+ (newline)
1852
+ 0))
1853
+ EOS
1854
+ ).should == "(define main (lambda (argv) (newline) 0))"
1855
+ @nendo.evalStr( <<EOS
1856
+ (macroexpand
1857
+ '(define (main argv)
1858
+ (define (foo x) x)
1859
+ (+ 10 20)
1860
+ 0
1861
+ (foo 111)))
1862
+ EOS
1863
+ ).should == "(define main (lambda (argv) (letrec ((foo (lambda (x) x))) (+ 10 20) 0 (foo 111))))"
1864
+ @nendo.evalStr( <<EOS
1865
+ (macroexpand
1866
+ '(define (main argv)
1867
+ (define result '())
1868
+ (define (foo x) x)
1869
+ (define val 0)
1870
+ (define (bar x)
1871
+ (+ val 10))))
1872
+ EOS
1873
+ ).should == "(define main (lambda (argv) (letrec ((result (quote ())) (foo (lambda (x) x)) (val 0) (bar (lambda (x) (+ val 10)))))))"
1874
+ @nendo.evalStr( <<EOS
1875
+ (define (main argv)
1876
+ (define (foo x) x)
1877
+ (+ 10 20)
1878
+ 0
1879
+ (foo 111))
1880
+ (main)
1881
+ EOS
1882
+ ).should == "111"
1883
+ @nendo.evalStr( <<EOS
1884
+ (define (main argv)
1885
+ (define (foo1 x) (+ 1 x))
1886
+ (define (foo2 x) (+ 2 x))
1887
+ (*
1888
+ (foo1 20)
1889
+ (foo2 30)))
1890
+ (main '())
1891
+ EOS
1892
+ ).should == "672"
1559
1893
  @nendo.evalStr( " (macroexpand '(define (main argv) 0)) " ).should == "(define main (lambda (argv) 0))"
1560
1894
  end
1561
1895
  end
@@ -1566,15 +1900,27 @@ describe Nendo, "when use macro macro " do
1566
1900
  @nendo.loadInitFile
1567
1901
  end
1568
1902
  it "should" do
1569
- @nendo.evalStr( " (define inc!-macro (macro (x) (+ x 1))) #t" ).should == "#t"
1903
+ @nendo.evalStr( <<EOS
1904
+ (define inc!-macro
1905
+ (macro (x)
1906
+ (+ x 1)))
1907
+ EOS
1908
+ ).should match( /Nendo::LispMacro/ )
1570
1909
  @nendo.evalStr( " (inc!-macro 10) " ).should == "11"
1571
- @nendo.evalStr( " (define dec!-macro (macro (x) (define (dec! v) (- v 1)) (dec! x))) #t" ).should == "#t"
1910
+ @nendo.evalStr( <<EOS
1911
+ (define dec!-macro
1912
+ (macro (x)
1913
+ (define (dec! v)
1914
+ (- v 1))
1915
+ (dec! x)))
1916
+ EOS
1917
+ ).should match( /Nendo::LispMacro/ )
1572
1918
  @nendo.evalStr( " (dec!-macro 10) " ).should == "9"
1573
1919
  @nendo.evalStr( " (. (dec!-macro 10) class) " ).should == 'Fixnum'
1574
1920
  end
1575
1921
  end
1576
1922
 
1577
- describe Nendo, "when use macros expands some syntax. " do
1923
+ describe Nendo, "when use macros expand some syntax. " do
1578
1924
  before do
1579
1925
  @nendo = Nendo::Core.new()
1580
1926
  @nendo.loadInitFile
@@ -1616,8 +1962,8 @@ describe Nendo, "when use dot-operator (.) macro " do
1616
1962
  lambda { @nendo.evalStr( " (macroexpand '(. open)) " ) }.should raise_error( ArgumentError )
1617
1963
  lambda { @nendo.evalStr( " (macroexpand '(. open \"aaa\")) " ) }.should raise_error( TypeError )
1618
1964
  @nendo.evalStr( " (macroexpand '(. a size)) " ).should == "(a.size)"
1619
- @nendo.evalStr( " (macroexpand '(. (. a size) to_s)) " ).gsub( /[12]0[0-9][0-9][0-9]/, "X0000" ).should == "(let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (a.size))) (__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000.to_s))"
1620
- @nendo.evalStr( " (macroexpand '(. (. (. a size) to_s) to_i)) " ).gsub( /[12]0[0-9][0-9][0-9]/, "X0000" ).should == "(let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (a.size))) (__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000.to_s)))) (__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000.to_i))"
1965
+ @nendo.evalStr( " (macroexpand '(. (. a size) to_s)) " ).gsub( /[12]0[0-9][0-9][0-9]/, "X0000" ).should == "(%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (a.size))) (__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000.to_s))"
1966
+ @nendo.evalStr( " (macroexpand '(. (. (. a size) to_s) to_i)) " ).gsub( /[12]0[0-9][0-9][0-9]/, "X0000" ).should == "(%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (a.size))) (__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000.to_s)))) (__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000.to_i))"
1621
1967
  lambda { @nendo.evalStr( " (macroexpand '(. (. a size))) " ) }.should raise_error( ArgumentError )
1622
1968
  @nendo.evalStr( " (set! str \"str\") str.size " ).should == "3"
1623
1969
  @nendo.evalStr( " (set! str \"str\") (. str size) " ).should == "3"
@@ -1792,17 +2138,52 @@ describe Nendo, "when use hash-table feature " do
1792
2138
  @nendo.evalStr( " (hash-table-num-entries h)" ).should == "1"
1793
2139
  @nendo.evalStr( " (hash-table-clear! h)" ).should == "{}"
1794
2140
  @nendo.evalStr( " (hash-table-num-entries h)" ).should == "0"
1795
- @nendo.evalStr( " (set! h (hash-table eq? '(\"a\" \"AAA\") '(\"b\" \"BBB\") '(\"c\" \"CCC\" 100))) (hash-table-keys h)" ).should == "(\"a\" \"b\" \"c\")"
1796
- @nendo.evalStr( " (set! h (hash-table eq? '(\"a\" \"AAA\") '(\"b\" \"BBB\") '(\"c\" \"CCC\" 100))) (hash-table-values h)" ).should == "((\"AAA\") (\"BBB\") (\"CCC\" 100))"
1797
- @nendo.evalStr( " (set! h (hash-table eq? '(\"a\" . \"AAA\") '(\"b\" . \"BBB\") '(\"c\" . \"CCC\"))) h" ).should == "{\"a\"=>\"AAA\", \"b\"=>\"BBB\", \"c\"=>\"CCC\"}"
2141
+ @nendo.evalStr( <<EOS
2142
+ (set! h (hash-table eq?
2143
+ '("a" "AAA")
2144
+ '("b" "BBB")
2145
+ '("c" "CCC" 100)))
2146
+ (hash-table-keys h)
2147
+ EOS
2148
+ ).should == "(\"a\" \"b\" \"c\")"
2149
+ @nendo.evalStr( <<EOS
2150
+ (set! h (hash-table eq?
2151
+ '("a" "AAA")
2152
+ '("b" "BBB")
2153
+ '("c" "CCC" 100)))
2154
+ (hash-table-values h)
2155
+ EOS
2156
+ ).should == "((\"AAA\") (\"BBB\") (\"CCC\" 100))"
2157
+ @nendo.evalStr( <<EOS
2158
+ (set! h (hash-table eq?
2159
+ '("a" . "AAA")
2160
+ '("b" . "BBB")
2161
+ '("c" . "CCC")))
2162
+ h
2163
+ EOS
2164
+ ).should == "{\"a\"=>\"AAA\", \"b\"=>\"BBB\", \"c\"=>\"CCC\"}"
1798
2165
  @nendo.evalStr( " (hash-table-keys h)" ).should == '("a" "b" "c")'
1799
2166
  @nendo.evalStr( " (hash-table-values h)" ).should == '("AAA" "BBB" "CCC")'
1800
2167
  @nendo.evalStr( " (hash-table-map h (lambda (a b) (+ a b)))" ).should == '("aAAA" "bBBB" "cCCC")'
1801
2168
  @nendo.evalStr( " (hash-table-for-each h (lambda (a b) (+ a b)))" ).should == '("aAAA" "bBBB" "cCCC")'
1802
2169
  @nendo.evalStr( " (set! h (make-hash-table)) " ).should == "{}"
1803
- @nendo.evalStr( " (set! h (hash-table eq? '(true . 1) '(false . 2) '(nil . 3))) h" ).should == "{true=>1, false=>2, nil=>3}"
2170
+ @nendo.evalStr( <<EOS
2171
+ (set! h (hash-table eq?
2172
+ '(true . 1)
2173
+ '(false . 2)
2174
+ '(nil . 3)))
2175
+ h
2176
+ EOS
2177
+ ).should == "{true=>1, false=>2, nil=>3}"
1804
2178
  @nendo.evalStr( " (hash-table-keys h) " ).should == "(#t #f nil)"
1805
- @nendo.evalStr( " (set! h (hash-table eq? '(1 . true) '(2 . false) '(3 . nil))) h" ).should == "{1=>true, 2=>false, 3=>nil}"
2179
+ @nendo.evalStr( <<EOS
2180
+ (set! h (hash-table eq?
2181
+ '(1 . true)
2182
+ '(2 . false)
2183
+ '(3 . nil)))
2184
+ h
2185
+ EOS
2186
+ ).should == "{1=>true, 2=>false, 3=>nil}"
1806
2187
  @nendo.evalStr( " (hash-table-keys h) " ).should == "(1 2 3)"
1807
2188
  end
1808
2189
  end
@@ -1858,75 +2239,156 @@ describe Nendo, "tail call optimization " do
1858
2239
  @nendo.loadInitFile # to self optimizing. The init.nnd file will be loaded twice, so `filter' can be optimized on second loading phase.
1859
2240
  end
1860
2241
  it "should" do
1861
- @nendo.evalStr( " (setup-tailcall-mark '(print \"abc\")) " ).should == "(%tailcall (print \"abc\"))"
1862
- @nendo.evalStr( " (setup-tailcall-mark '(begin (print \"abc\") 1 2 3)) " ).should == "(begin (print \"abc\") 1 2 3)"
1863
- @nendo.evalStr( " (setup-tailcall-mark '(begin 1 2 (print \"abc\") 3)) " ).should == "(begin 1 2 (print \"abc\") 3)"
1864
- @nendo.evalStr( " (setup-tailcall-mark '(begin 1 2 3 (print \"abc\"))) " ).should == "(begin 1 2 3 (%tailcall (print \"abc\")))"
1865
- @nendo.evalStr( " (setup-tailcall-mark '(lambda (x) x)) " ).should == "(lambda (x) x)"
1866
- @nendo.evalStr( " (setup-tailcall-mark '(macro (x) x)) " ).should == "(macro (x) x)"
1867
- @nendo.evalStr( " (setup-tailcall-mark '(%syntax (x) x)) " ).should == "(%syntax (x) x)"
1868
- @nendo.evalStr( " (setup-tailcall-mark '(%syntax (a b c) (begin a b c))) " ).should == "(%syntax (a b c) (begin a b c))"
1869
- @nendo.evalStr( " (setup-tailcall-mark '(lambda (x) (%syntax (y) x))) " ).should == "(lambda (x) (%syntax (y) x))"
1870
- @nendo.evalStr( " (setup-tailcall-mark '(lambda (x) (syntax-quote x))) " ).should == "(lambda (x) (syntax-quote x))"
1871
- @nendo.evalStr( " (setup-tailcall-mark '(lambda (x) (quote x))) " ).should == "(lambda (x) 'x)"
1872
- @nendo.evalStr( "" +
1873
- "(setup-tailcall-mark"+
1874
- " '(lambda '(x)"+
1875
- " 1"+
1876
- " 2"+
1877
- " (print \"abc\")))" ).should == "(lambda '(x) 1 2 (%tailcall (print \"abc\")))"
1878
- @nendo.evalStr( "" +
1879
- "(setup-tailcall-mark"+
1880
- " '(lambda (x)"+
1881
- " 1"+
1882
- " 2"+
1883
- " (if #t"+
1884
- " (begin 1 2 (print \"abc\"))"+
1885
- " (begin 1 2 (print \"ABC\")))))" ).should == "(lambda (x) 1 2 (if #t (begin 1 2 (%tailcall (print \"abc\"))) (begin 1 2 (%tailcall (print \"ABC\")))))"
1886
- @nendo.evalStr( "(setup-tailcall-mark (macroexpand "+
1887
- " '(define (foo) (foo))"+
1888
- " ))" ).should == "(define foo (lambda () (%tailcall (foo))))"
1889
- @nendo.evalStr( "(setup-tailcall-mark (macroexpand "+
1890
- " '(values? (make-values '()))"+
1891
- " ))" ).should == "(%tailcall (values? (make-values '())))"
1892
- @nendo.evalStr( "(setup-tailcall-mark (macroexpand "+
1893
- " '(cond (false 1) (false 2))"+
1894
- " ))" ).should == "(if #f (begin 1) (if #f (begin 2) ()))"
1895
- @nendo.evalStr( "(setup-tailcall-mark (macroexpand "+
1896
- " '(cond (false 1) (false 2) (else 3))"+
1897
- " ))" ).should == "(if #f (begin 1) (if #f (begin 2) (if #t (begin 3) ())))"
1898
- @nendo.evalStr( "(setup-tailcall-mark (macroexpand "+
1899
- " '(and (foo 1) (bar 2))"+
1900
- " ))" ).should == "(if (not (eq? #f (foo 1))) (%tailcall (bar 2)) #f)"
1901
- @nendo.evalStr( "(setup-tailcall-mark (macroexpand "+
1902
- " '(or (foo 1) (bar 2))"+
1903
- " ))" ).gsub( /[24]0[0-9][0-9][0-9]/, "X0000" ).should == "(let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (foo 1))) (if __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (bar 2))) (if __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 #f))))"
1904
- @nendo.evalStr( "(setup-tailcall-mark (macroexpand "+
1905
- " '(let loop ((x 1)) 1 2 (loop 100))"+
1906
- " ))" ).should == "(letrec ((loop (lambda (x) 1 2 (%tailcall (loop 100))))) (%tailcall (loop 1)))"
1907
- @nendo.evalStr( "(setup-tailcall-mark (macroexpand "+
2242
+ @nendo.evalStr( " (%setup-%tailcall-mark '(print \"abc\")) " ).should == "(%tailcall (print \"abc\"))"
2243
+ @nendo.evalStr( " (%setup-%tailcall-mark '(begin (print \"abc\") 1 2 3)) " ).should == "(begin (print \"abc\") 1 2 3)"
2244
+ @nendo.evalStr( " (%setup-%tailcall-mark '(begin 1 2 (print \"abc\") 3)) " ).should == "(begin 1 2 (print \"abc\") 3)"
2245
+ @nendo.evalStr( " (%setup-%tailcall-mark '(begin 1 2 3 (print \"abc\"))) " ).should == "(begin 1 2 3 (%tailcall (print \"abc\")))"
2246
+ @nendo.evalStr( " (%setup-%tailcall-mark '(lambda (x) x)) " ).should == "(lambda (x) x)"
2247
+ @nendo.evalStr( " (%setup-%tailcall-mark '(macro (x) x)) " ).should == "(macro (x) x)"
2248
+ @nendo.evalStr( " (%setup-%tailcall-mark '(%syntax (x) x)) " ).should == "(%syntax (x) x)"
2249
+ @nendo.evalStr( " (%setup-%tailcall-mark '(%syntax (a b c) (begin a b c))) " ).should == "(%syntax (a b c) (begin a b c))"
2250
+ @nendo.evalStr( " (%setup-%tailcall-mark '(lambda (x) (%syntax (y) x))) " ).should == "(lambda (x) (%syntax (y) x))"
2251
+ @nendo.evalStr( " (%setup-%tailcall-mark '(lambda (x) (syntax-quote x))) " ).should == "(lambda (x) (quote x))"
2252
+ @nendo.evalStr( " (%setup-%tailcall-mark '(lambda (x) (quote x))) " ).should == "(lambda (x) (quote x))"
2253
+ @nendo.evalStr( <<EOS
2254
+ (%setup-%tailcall-mark
2255
+ '(lambda '(x)
2256
+ 1
2257
+ 2
2258
+ (print \"abc\")))
2259
+ EOS
2260
+ ).should == "(lambda (quote (x)) 1 2 (%tailcall (print \"abc\")))"
2261
+ @nendo.evalStr( <<EOS
2262
+ (%setup-%tailcall-mark
2263
+ '(lambda (x)
2264
+ 1
2265
+ 2
2266
+ (if #t
2267
+ (begin 1 2 (print "abc"))
2268
+ (begin 1 2 (print "ABC")))))
2269
+ EOS
2270
+ ).should == "(lambda (x) 1 2 (if #t (begin 1 2 (%tailcall (print \"abc\"))) (begin 1 2 (%tailcall (print \"ABC\")))))"
2271
+ @nendo.evalStr( <<EOS
2272
+ (%setup-%tailcall-mark (macroexpand
2273
+ '(define (foo) (foo))
2274
+ ))
2275
+ EOS
2276
+ ).should == "(define foo (lambda () (%tailcall (foo))))"
2277
+ @nendo.evalStr( <<EOS
2278
+ (%setup-%tailcall-mark (macroexpand
2279
+ '(values? (make-values '()))
2280
+ ))
2281
+ EOS
2282
+ ).should == "(%tailcall (values? (make-values (quote ()))))"
2283
+ @nendo.evalStr( <<EOS
2284
+ (%setup-%tailcall-mark (macroexpand
2285
+ '(cond
2286
+ (false 1)
2287
+ (false 2))
2288
+ ))
2289
+ EOS
2290
+ ).should == "(if #f (begin 1) (if #f (begin 2) ()))"
2291
+ @nendo.evalStr( <<EOS
2292
+ (%setup-%tailcall-mark (macroexpand
2293
+ '(cond
2294
+ (false 1)
2295
+ (false 2)
2296
+ (else 3))
2297
+ ))
2298
+ EOS
2299
+ ).should == "(if #f (begin 1) (if #f (begin 2) (if #t (begin 3) ())))"
2300
+ @nendo.evalStr( <<EOS
2301
+ (%setup-%tailcall-mark (macroexpand
2302
+ '(and
2303
+ (foo 1)
2304
+ (bar 2))
2305
+ ))
2306
+ EOS
2307
+ ).should == "(if (not (eq? #f (foo 1))) (%tailcall (bar 2)) #f)"
2308
+ @nendo.evalStr( <<EOS
2309
+ (%setup-%tailcall-mark (macroexpand
2310
+ '(or
2311
+ (foo 1)
2312
+ (bar 2))
2313
+ ))
2314
+ EOS
2315
+ ).gsub( /[24]0[0-9][0-9][0-9]/, "X0000" ).should == "(%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (foo 1))) (if __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (%let ((__gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 (bar 2))) (if __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 __gensym__fb4e25e49e9fb4e46342224606faf2e3eabf1251_X0000 #f))))"
2316
+ @nendo.evalStr( <<EOS
2317
+ (%setup-%tailcall-mark (macroexpand
2318
+ '(let loop ((x 1))
2319
+ 1
2320
+ 2
2321
+ (loop 100))
2322
+ ))
2323
+ EOS
2324
+ ).should == "(letrec ((loop (lambda (x) 1 2 (%tailcall (loop 100))))) (%tailcall (loop 1)))"
2325
+ @nendo.evalStr( "(%setup-%tailcall-mark (macroexpand "+
1908
2326
  " '(let1 aaa 111 aaa)"+
1909
- " ))" ).should == "(let ((aaa 111)) aaa)"
1910
- @nendo.evalStr( "" +
1911
- "(setup-tailcall-mark"+
1912
- " '(letrec ((func1 "+
1913
- " (lambda (x)"+
1914
- " 1"+
1915
- " (func2)))"+
1916
- " (func2 "+
1917
- " (lambda (x)"+
1918
- " 2"+
1919
- " (func1))))"+
1920
- " (func1 100)))" ).should == "(letrec ((func1 (lambda (x) 1 (%tailcall (func2)))) (func2 (lambda (x) 2 (%tailcall (func1))))) (%tailcall (func1 100)))"
2327
+ " ))" ).should == "(%let ((aaa 111)) aaa)"
2328
+ @nendo.evalStr( <<EOS
2329
+ (%setup-%tailcall-mark
2330
+ '(letrec ((func1
2331
+ (lambda (x)
2332
+ 1
2333
+ (func2)))
2334
+ (func2
2335
+ (lambda (x)
2336
+ 2
2337
+ (func1))))
2338
+ (func1 100)))
2339
+ EOS
2340
+ ).should == "(letrec ((func1 (lambda (x) 1 (%tailcall (func2)))) (func2 (lambda (x) 2 (%tailcall (func1))))) (%tailcall (func1 100)))"
1921
2341
  @nendo.evalStr( "(set-optimize-level 0) " ).should == "0"
1922
- lambda { @nendo.evalStr( "(filter (lambda (x) (< x 10)) (range 10000)) " ) }.should raise_error(SystemStackError)
2342
+ lambda { @nendo.evalStr( <<EOS
2343
+ (filter
2344
+ (lambda (x) (< x 10))
2345
+ (range 10000))
2346
+ EOS
2347
+ ) }.should raise_error(SystemStackError)
1923
2348
  @nendo.evalStr( "(set-optimize-level 1) " ).should == "1"
1924
- @nendo.evalStr( "(apply + (map (lambda (x) (* x 2)) (range 10000))) " ).should == "99990000"
1925
- @nendo.evalStr( "(filter (lambda (x) (< x 10)) (range 1000)) " ).should == "(0 1 2 3 4 5 6 7 8 9)"
1926
- @nendo.evalStr( "(filter-map (lambda (x) (when (< x 10) (- x))) (range 1000)) " ).should == "(0 -1 -2 -3 -4 -5 -6 -7 -8 -9)"
1927
- @nendo.evalStr( "(define str (if #t (car '(\"a\")) (car '(\"b\")))) (sprintf \"A%sZ\" str) " ).should == '"AaZ"'
1928
- @nendo.evalStr( "(letrec ((str (if #t (+ \"a\" \"A\") '()))) str.class) " ).should == 'String'
1929
- @nendo.evalStr( "(letrec ((str (if #t (+ \"a\" \"A\") '()))) (+ str \"...\")) " ).should == '"aA..."'
2349
+ @nendo.evalStr( <<EOS
2350
+ (apply +
2351
+ (map
2352
+ (lambda (x) (* x 2))
2353
+ (range 10000)))
2354
+ EOS
2355
+ ).should == "99990000"
2356
+ @nendo.evalStr( <<EOS
2357
+ (filter
2358
+ (lambda (x) (< x 10))
2359
+ (range 1000))
2360
+ EOS
2361
+ ).should == "(0 1 2 3 4 5 6 7 8 9)"
2362
+ @nendo.evalStr( <<EOS
2363
+ (filter-map
2364
+ (lambda (x)
2365
+ (when (< x 10) (- x)))
2366
+ (range 1000))
2367
+ EOS
2368
+ ).should == "(0 -1 -2 -3 -4 -5 -6 -7 -8 -9)"
2369
+ @nendo.evalStr( <<EOS
2370
+ (define str
2371
+ (if #t
2372
+ (car '("a"))
2373
+ (car '("b"))))
2374
+ (sprintf "A%sZ" str)
2375
+ EOS
2376
+ ).should == '"AaZ"'
2377
+ @nendo.evalStr( <<EOS
2378
+ (letrec ((str (if #t
2379
+ (+ "a" "A")
2380
+ '())))
2381
+ str.class)
2382
+ EOS
2383
+ ).should == 'String'
2384
+ @nendo.evalStr( <<EOS
2385
+ (letrec ((str
2386
+ (if #t
2387
+ (+ \"a\" \"A\")
2388
+ '())))
2389
+ (+ str \"...\"))
2390
+ EOS
2391
+ ).should == '"aA..."'
1930
2392
  end
1931
2393
  end
1932
2394