mal/tests/step6_file.mal at master · localchart/mal · GitHub - github.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
;;; TODO: really a step5 test
;;
;; Testing that (do (do)) not broken by TCO
(do (do 1 2))
;=>2

;;
;; Testing read-string, eval and slurp
(read-string "(1 2 (3 4) nil)")
;=>(1 2 (3 4) nil)

(read-string "(+ 2 3)")
;=>(+ 2 3)

(read-string "7 ;; comment")
;=>7

;;; Differing output, but make sure no fatal error
(read-string ";; comment")


(eval (read-string "(+ 2 3)"))
;=>5

(slurp "../tests/test.txt")
;=>"A line of text\n"

;; Testing load-file

(load-file "../tests/inc.mal")
(inc1 7)
;=>8
(inc2 7)
;=>9
(inc3 9)
;=>12

;;
;; Testing that *ARGV* exists and is an empty list
(list? *ARGV*)
;=>true
*ARGV*
;=>()

;;
;; Testing atoms

(def! inc3 (fn* (a) (+ 3 a)))

(def! a (atom 2))
;=>(atom 2)

(atom? a)
;=>true

(atom? 1)
;=>false

(deref a)
;=>2

(reset! a 3)
;=>3

(deref a)
;=>3

(swap! a inc3)
;=>6

(deref a)
;=>6

(swap! a (fn* (a) a))
;=>6

(swap! a (fn* (a) (* 2 a)))
;=>12

(swap! a (fn* (a b) (* a b)) 10)
;=>120

(swap! a + 3)
;=>123

;; Testing swap!/closure interaction
(def! inc-it (fn* (a) (+ 1 a)))
(def! atm (atom 7))
(def! f (fn* () (swap! atm inc-it)))
(f)
;=>8
(f)
;=>9

;>>> deferrable=True
;>>> optional=True
;;
;; -------- Deferrable/Optional Functionality --------

;; Testing comments in a file
(load-file "../tests/incB.mal")
; "incB.mal finished"
;=>"incB.mal return string"
(inc4 7)
;=>11
(inc5 7)
;=>12

;; Testing map literal across multiple lines in a file
(load-file "../tests/incC.mal")
mymap
;=>{"a" 1}

;; Testing `@` reader macro (short for `deref`)
(def! atm (atom 9))
@atm
;=>9

;;; TODO: really a step5 test
;; Testing that vector params not broken by TCO
(def! g (fn* [] 78))
(g)
;=>78
(def! g (fn* [a] (+ a 78)))
(g 3)
;=>81