prelude 0.0.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.
- data/CHANGELOG +7 -0
- data/COPYING +339 -0
- data/README +47 -0
- data/Rakefile +109 -0
- data/TODO +6 -0
- data/lib/prelude.rb +66 -0
- data/lib/prelude/list.rb +572 -0
- data/lib/prelude/monad.rb +39 -0
- data/lib/prelude/tuple.rb +64 -0
- data/test/tc_higher.rb +89 -0
- data/test/tc_list.rb +772 -0
- data/test/tc_tuple.rb +44 -0
- data/test/ts_prelude.rb +35 -0
- metadata +59 -0
@@ -0,0 +1,39 @@
|
|
1
|
+
#--
|
2
|
+
# This file is part of the Prelude library that provides tools to
|
3
|
+
# enable Haskell style functional programming in Ruby.
|
4
|
+
#
|
5
|
+
# http://prelude.rubyforge.org
|
6
|
+
#
|
7
|
+
# Copyright (C) 2006 APP Design, Inc.
|
8
|
+
#
|
9
|
+
# This program is free software; you can redistribute it and/or modify
|
10
|
+
# it under the terms of the GNU General Public License as published by
|
11
|
+
# the Free Software Foundation; either version 2 of the License, or
|
12
|
+
# (at your option) any later version.
|
13
|
+
#
|
14
|
+
# This program is distributed in the hope that it will be useful,
|
15
|
+
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
16
|
+
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
17
|
+
# GNU General Public License for more details.
|
18
|
+
#
|
19
|
+
# You should have received a copy of the GNU General Public License along
|
20
|
+
# with this program; if not, write to the Free Software Foundation, Inc.,
|
21
|
+
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
22
|
+
#++
|
23
|
+
|
24
|
+
module Prelude
|
25
|
+
|
26
|
+
# $Id: monad.rb 2 2006-08-25 00:11:17Z prelude $
|
27
|
+
#
|
28
|
+
# Monad implementation is inspired by the following sources:
|
29
|
+
#
|
30
|
+
# * article "Late to the Party" posted at http://cwilliams.textdriven.com/pages/monads, I could not detect
|
31
|
+
# the author's name
|
32
|
+
# * writings by MenTaLguY, see http://moonbase.rydia.net/mental/writings/programming/monads-in-ruby/00introduction.html
|
33
|
+
#
|
34
|
+
class Monad
|
35
|
+
def bind(&block)
|
36
|
+
collect(&block).flatten
|
37
|
+
end
|
38
|
+
end # Monad
|
39
|
+
end # Prelude
|
@@ -0,0 +1,64 @@
|
|
1
|
+
#--
|
2
|
+
# This file is part of the Prelude library that provides tools to
|
3
|
+
# enable Haskell style functional programming in Ruby.
|
4
|
+
#
|
5
|
+
# http://prelude.rubyforge.org
|
6
|
+
#
|
7
|
+
# Copyright (C) 2006 APP Design, Inc.
|
8
|
+
#
|
9
|
+
# This program is free software; you can redistribute it and/or modify
|
10
|
+
# it under the terms of the GNU General Public License as published by
|
11
|
+
# the Free Software Foundation; either version 2 of the License, or
|
12
|
+
# (at your option) any later version.
|
13
|
+
#
|
14
|
+
# This program is distributed in the hope that it will be useful,
|
15
|
+
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
16
|
+
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
17
|
+
# GNU General Public License for more details.
|
18
|
+
#
|
19
|
+
# You should have received a copy of the GNU General Public License along
|
20
|
+
# with this program; if not, write to the Free Software Foundation, Inc.,
|
21
|
+
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
22
|
+
#++
|
23
|
+
|
24
|
+
module Prelude
|
25
|
+
|
26
|
+
# $Id: tuple.rb 2 2006-08-25 00:11:17Z prelude $
|
27
|
+
#
|
28
|
+
class Tuple < Array
|
29
|
+
|
30
|
+
def new(*args)
|
31
|
+
case
|
32
|
+
when args.nil? || args.empty? :
|
33
|
+
super.new([nil, nil])
|
34
|
+
when args.lengh == 1 && args[0].kind_of(Array) :
|
35
|
+
super.new(args[0][0])
|
36
|
+
self << super.new([args[0][1..-1]])
|
37
|
+
when args.lengh == 1 :
|
38
|
+
super.new([args[0], nil])
|
39
|
+
when args.lengh == 2 :
|
40
|
+
super.new(args)
|
41
|
+
when args.lengh > 2 :
|
42
|
+
super.new([args[0], args[1..-1]])
|
43
|
+
end # case
|
44
|
+
end
|
45
|
+
|
46
|
+
def fst
|
47
|
+
self[0]
|
48
|
+
end
|
49
|
+
|
50
|
+
def snd
|
51
|
+
self[1]
|
52
|
+
end
|
53
|
+
|
54
|
+
def fst=(o)
|
55
|
+
self[0] = o
|
56
|
+
end
|
57
|
+
|
58
|
+
def snd=(o)
|
59
|
+
self[1] = o
|
60
|
+
end
|
61
|
+
|
62
|
+
end # Tuple
|
63
|
+
|
64
|
+
end # Prelude
|
data/test/tc_higher.rb
ADDED
@@ -0,0 +1,89 @@
|
|
1
|
+
#--
|
2
|
+
# $Id: tc_higher.rb 1 2006-08-24 20:34:21Z prelude $
|
3
|
+
#
|
4
|
+
#
|
5
|
+
# This file is part of the Prelude library that provides tools to
|
6
|
+
# enable Haskell style functional programming in Ruby.
|
7
|
+
#
|
8
|
+
# http://prelude.rubyforge.org
|
9
|
+
#
|
10
|
+
# Copyright (C) 2006 APP Design, Inc.
|
11
|
+
#
|
12
|
+
# This program is free software; you can redistribute it and/or modify
|
13
|
+
# it under the terms of the GNU General Public License as published by
|
14
|
+
# the Free Software Foundation; either version 2 of the License, or
|
15
|
+
# (at your option) any later version.
|
16
|
+
#
|
17
|
+
# This program is distributed in the hope that it will be useful,
|
18
|
+
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
19
|
+
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
20
|
+
# GNU General Public License for more details.
|
21
|
+
#
|
22
|
+
# You should have received a copy of the GNU General Public License along
|
23
|
+
# with this program; if not, write to the Free Software Foundation, Inc.,
|
24
|
+
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
25
|
+
#++
|
26
|
+
|
27
|
+
class TestHigher < Test::Unit::TestCase
|
28
|
+
|
29
|
+
def setup
|
30
|
+
# Nothing
|
31
|
+
end # setup
|
32
|
+
|
33
|
+
def teardown
|
34
|
+
# Nothing
|
35
|
+
end # teardown
|
36
|
+
|
37
|
+
#
|
38
|
+
# Test higher functions
|
39
|
+
#
|
40
|
+
def test_curry_proc
|
41
|
+
add5 = (proc {|x,y,z| x+y+z}).curry(5)
|
42
|
+
|
43
|
+
result = add5[3, 2]
|
44
|
+
expect = 10
|
45
|
+
|
46
|
+
assert_equal(expect, result)
|
47
|
+
|
48
|
+
result = add5.call(3, 2)
|
49
|
+
expect = 10
|
50
|
+
|
51
|
+
assert_equal(expect, result)
|
52
|
+
end
|
53
|
+
|
54
|
+
def test_curry_symbol
|
55
|
+
add5 = :+.curry(5)
|
56
|
+
|
57
|
+
result = add5.call(3)
|
58
|
+
expect = 8
|
59
|
+
|
60
|
+
assert_equal(expect, result)
|
61
|
+
|
62
|
+
result = add5[4]
|
63
|
+
expect = 9
|
64
|
+
|
65
|
+
assert_equal(expect, result)
|
66
|
+
end
|
67
|
+
|
68
|
+
def test_stream
|
69
|
+
add5 = proc {|x| x+5}
|
70
|
+
add6 = proc {|x,y| x+y+6}
|
71
|
+
add11 = add5 << add6
|
72
|
+
|
73
|
+
result = add11[1, 2]
|
74
|
+
expect = 14
|
75
|
+
|
76
|
+
assert_equal(expect, result)
|
77
|
+
|
78
|
+
result = add5 << 1
|
79
|
+
expect = 6
|
80
|
+
|
81
|
+
assert_equal(expect, result)
|
82
|
+
|
83
|
+
result = add5 << add6 << [1, 2]
|
84
|
+
expect = 14
|
85
|
+
|
86
|
+
assert_equal(expect, result)
|
87
|
+
end
|
88
|
+
|
89
|
+
end # TestHigher
|
data/test/tc_list.rb
ADDED
@@ -0,0 +1,772 @@
|
|
1
|
+
#--
|
2
|
+
# $Id: tc_list.rb 1 2006-08-24 20:34:21Z prelude $
|
3
|
+
#
|
4
|
+
#
|
5
|
+
# This file is part of the Prelude library that provides tools to
|
6
|
+
# enable Haskell style functional programming in Ruby.
|
7
|
+
#
|
8
|
+
# http://prelude.rubyforge.org
|
9
|
+
#
|
10
|
+
# Copyright (C) 2006 APP Design, Inc.
|
11
|
+
#
|
12
|
+
# This program is free software; you can redistribute it and/or modify
|
13
|
+
# it under the terms of the GNU General Public License as published by
|
14
|
+
# the Free Software Foundation; either version 2 of the License, or
|
15
|
+
# (at your option) any later version.
|
16
|
+
#
|
17
|
+
# This program is distributed in the hope that it will be useful,
|
18
|
+
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
19
|
+
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
20
|
+
# GNU General Public License for more details.
|
21
|
+
#
|
22
|
+
# You should have received a copy of the GNU General Public License along
|
23
|
+
# with this program; if not, write to the Free Software Foundation, Inc.,
|
24
|
+
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
25
|
+
#++
|
26
|
+
|
27
|
+
class TestList < Test::Unit::TestCase
|
28
|
+
|
29
|
+
def setup
|
30
|
+
|
31
|
+
@a = List.new([1, 2, 3, 4, 5])
|
32
|
+
@true_list = List.new([true, true, true])
|
33
|
+
@false_list = List.new([false, false, false])
|
34
|
+
@mixed_list = List.new([false, true, false])
|
35
|
+
|
36
|
+
end # setup
|
37
|
+
|
38
|
+
def teardown
|
39
|
+
# Nothing
|
40
|
+
end # teardown
|
41
|
+
|
42
|
+
def test_head
|
43
|
+
result = @a.head
|
44
|
+
expect = 1
|
45
|
+
|
46
|
+
assert_equal(expect, result)
|
47
|
+
end
|
48
|
+
|
49
|
+
# Compatibility with the Array class
|
50
|
+
def test_array_plus
|
51
|
+
b = [6, 7]
|
52
|
+
|
53
|
+
result = @a+b
|
54
|
+
expect = [1, 2, 3, 4, 5, 6, 7]
|
55
|
+
|
56
|
+
assert_instance_of(List, result)
|
57
|
+
assert_equal(expect, result)
|
58
|
+
end
|
59
|
+
|
60
|
+
def test_array_assignment
|
61
|
+
@a[1] = 10
|
62
|
+
result = @a
|
63
|
+
expect = [1, 10, 3, 4, 5]
|
64
|
+
|
65
|
+
assert_instance_of(List, result)
|
66
|
+
assert_equal(expect, result)
|
67
|
+
end
|
68
|
+
|
69
|
+
def test_array_shift
|
70
|
+
result = @a << 100 << 101
|
71
|
+
expect = [1, 2, 3, 4, 5, 100, 101]
|
72
|
+
|
73
|
+
assert_instance_of(List, result)
|
74
|
+
assert_equal(expect, result)
|
75
|
+
end
|
76
|
+
|
77
|
+
# , last -- :: [a] -> a
|
78
|
+
def test_last
|
79
|
+
result = @a.last
|
80
|
+
expect = 5
|
81
|
+
|
82
|
+
assert_equal(expect, result)
|
83
|
+
end
|
84
|
+
|
85
|
+
# , tail -- :: [a] -> [a]
|
86
|
+
def test_tail
|
87
|
+
result = @a.tail
|
88
|
+
expect = [2, 3, 4, 5]
|
89
|
+
|
90
|
+
assert_equal(expect, result)
|
91
|
+
end
|
92
|
+
|
93
|
+
# , init -- :: [a] -> [a]
|
94
|
+
def test_init
|
95
|
+
result = @a.init
|
96
|
+
expect = [1, 2, 3, 4]
|
97
|
+
|
98
|
+
assert_equal(expect, result)
|
99
|
+
end
|
100
|
+
|
101
|
+
# , null -- :: [a] -> Bool
|
102
|
+
def test_null
|
103
|
+
result = @a.null
|
104
|
+
expect = false
|
105
|
+
|
106
|
+
assert_equal(expect, result)
|
107
|
+
end
|
108
|
+
|
109
|
+
# , length -- :: [a] -> Int
|
110
|
+
def test_length
|
111
|
+
result = @a.length
|
112
|
+
expect = 5
|
113
|
+
|
114
|
+
assert_equal(expect, result)
|
115
|
+
end
|
116
|
+
|
117
|
+
|
118
|
+
# -- * List transformations
|
119
|
+
# , map -- :: (a -> b) -> [a] -> [b]
|
120
|
+
# already defined by the Array
|
121
|
+
|
122
|
+
# , reverse -- :: [a] -> [a]
|
123
|
+
# already defined by the Array
|
124
|
+
|
125
|
+
# , intersperse -- :: a -> [a] -> [a]
|
126
|
+
def test_intersperse
|
127
|
+
result = @a.intersperse
|
128
|
+
expect = []
|
129
|
+
|
130
|
+
assert_equal(expect, result)
|
131
|
+
end
|
132
|
+
|
133
|
+
# , transpose -- :: [[a]] -> [[a]]
|
134
|
+
def test_transpose
|
135
|
+
result = List.new([@a, @a, @a]).transpose
|
136
|
+
expect = [[1, 1, 1], [2, 2, 2], [3, 3, 3], [4, 4, 4], [5, 5, 5] ]
|
137
|
+
|
138
|
+
assert_equal(expect, result)
|
139
|
+
end
|
140
|
+
|
141
|
+
# -- * Reducing lists (folds)
|
142
|
+
|
143
|
+
# , foldl -- :: (a -> b -> a) -> a -> [b] -> a
|
144
|
+
|
145
|
+
# Classic recursive functional definition causes stack overflow for
|
146
|
+
# arrays of any usable size... So don't use it, it's here for completeness
|
147
|
+
def test_f_foldl
|
148
|
+
result = @a.f_foldl(0){ |x, y| x+y}
|
149
|
+
expect = 15
|
150
|
+
|
151
|
+
assert_equal(expect, result)
|
152
|
+
end
|
153
|
+
|
154
|
+
# This is a more pedestrian iterative version.
|
155
|
+
def test_foldl
|
156
|
+
result = @a.foldl(0){ |x, y| x+y}
|
157
|
+
expect = 15
|
158
|
+
|
159
|
+
assert_equal(expect, result)
|
160
|
+
end
|
161
|
+
|
162
|
+
# , foldl' -- :: (a -> b -> a) -> a -> [b] -> a
|
163
|
+
def test_foldl_
|
164
|
+
result = @a.foldl_
|
165
|
+
expect = []
|
166
|
+
|
167
|
+
assert_equal(expect, result)
|
168
|
+
end
|
169
|
+
|
170
|
+
# , foldl1 -- :: (a -> a -> a) -> [a] -> a
|
171
|
+
def test_foldl1
|
172
|
+
result = @a.foldl1{ |x, y| x*y}
|
173
|
+
expect = 120
|
174
|
+
|
175
|
+
assert_equal(expect, result)
|
176
|
+
end
|
177
|
+
|
178
|
+
# , foldl1' -- :: (a -> a -> a) -> [a] -> a
|
179
|
+
def test_foldl1_
|
180
|
+
result = @a.foldl1_
|
181
|
+
expect = []
|
182
|
+
|
183
|
+
assert_equal(expect, result)
|
184
|
+
end
|
185
|
+
|
186
|
+
# , foldr -- :: (a -> b -> b) -> b -> [a] -> b
|
187
|
+
def test_foldr
|
188
|
+
result = @a.foldr(0){ |x, y| x+y}
|
189
|
+
expect = 15
|
190
|
+
|
191
|
+
assert_equal(expect, result)
|
192
|
+
end
|
193
|
+
|
194
|
+
# , foldr1 -- :: (a -> a -> a) -> [a] -> a
|
195
|
+
def test_foldr1
|
196
|
+
result = @a.foldr1{ |x, y| x*y}
|
197
|
+
expect = 120
|
198
|
+
|
199
|
+
assert_equal(expect, result)
|
200
|
+
end
|
201
|
+
|
202
|
+
# -- ** Special folds
|
203
|
+
|
204
|
+
# , concat -- :: [[a]] -> [a]
|
205
|
+
def test_concat
|
206
|
+
result = List.new([@a, [@a]]).concat
|
207
|
+
expect = @a+@a
|
208
|
+
|
209
|
+
assert_equal(expect, result)
|
210
|
+
end
|
211
|
+
|
212
|
+
# , concatMap -- :: (a -> [b]) -> [a] -> [b]
|
213
|
+
def test_concatMap
|
214
|
+
result = @a.concatMap
|
215
|
+
expect = []
|
216
|
+
|
217
|
+
assert_equal(expect, result)
|
218
|
+
end
|
219
|
+
|
220
|
+
# , and -- :: [Bool] -> Bool
|
221
|
+
def test_and
|
222
|
+
result = @true_list.and
|
223
|
+
expect = true
|
224
|
+
|
225
|
+
assert_equal(expect, result)
|
226
|
+
|
227
|
+
result = @mixed_list.and
|
228
|
+
expect = false
|
229
|
+
|
230
|
+
assert_equal(expect, result)
|
231
|
+
|
232
|
+
result = @false_list.and
|
233
|
+
expect = false
|
234
|
+
|
235
|
+
assert_equal(expect, result)
|
236
|
+
end
|
237
|
+
|
238
|
+
# , or -- :: [Bool] -> Bool
|
239
|
+
def test_or
|
240
|
+
result = @true_list.or
|
241
|
+
expect = true
|
242
|
+
|
243
|
+
assert_equal(expect, result)
|
244
|
+
|
245
|
+
result = @mixed_list.or
|
246
|
+
expect = true
|
247
|
+
|
248
|
+
assert_equal(expect, result)
|
249
|
+
|
250
|
+
result = @false_list.or
|
251
|
+
expect = false
|
252
|
+
|
253
|
+
assert_equal(expect, result)
|
254
|
+
end
|
255
|
+
|
256
|
+
# , any -- :: (a -> Bool) -> [a] -> Bool
|
257
|
+
def test_any
|
258
|
+
result = @a.any{|x| x>5}
|
259
|
+
expect = false
|
260
|
+
|
261
|
+
assert_equal(expect, result)
|
262
|
+
|
263
|
+
result = @a.any{|x| x<5}
|
264
|
+
expect = true
|
265
|
+
|
266
|
+
assert_equal(expect, result)
|
267
|
+
end
|
268
|
+
|
269
|
+
# , all -- :: (a -> Bool) -> [a] -> Bool
|
270
|
+
def test_all
|
271
|
+
result = @a.all{|x| x>3}
|
272
|
+
expect = false
|
273
|
+
|
274
|
+
assert_equal(expect, result)
|
275
|
+
|
276
|
+
result = @a.all{|x| x>0}
|
277
|
+
expect = true
|
278
|
+
|
279
|
+
assert_equal(expect, result)
|
280
|
+
end
|
281
|
+
|
282
|
+
# , sum -- :: (Num a) => [a] -> a
|
283
|
+
def test_sum
|
284
|
+
result = @a.sum
|
285
|
+
expect = []
|
286
|
+
|
287
|
+
assert_equal(expect, result)
|
288
|
+
end
|
289
|
+
|
290
|
+
# , product -- :: (Num a) => [a] -> a
|
291
|
+
def test_product
|
292
|
+
result = @a.product
|
293
|
+
expect = []
|
294
|
+
|
295
|
+
assert_equal(expect, result)
|
296
|
+
end
|
297
|
+
|
298
|
+
# , maximum -- :: (Ord a) => [a] -> a
|
299
|
+
def test_maximum
|
300
|
+
result = @a.maximum
|
301
|
+
expect = []
|
302
|
+
|
303
|
+
assert_equal(expect, result)
|
304
|
+
end
|
305
|
+
|
306
|
+
# , minimum -- :: (Ord a) => [a] -> a
|
307
|
+
def test_minimum
|
308
|
+
result = @a.minimum
|
309
|
+
expect = []
|
310
|
+
|
311
|
+
assert_equal(expect, result)
|
312
|
+
end
|
313
|
+
|
314
|
+
|
315
|
+
# -- * Building lists
|
316
|
+
|
317
|
+
# -- ** Scans
|
318
|
+
# , scanl -- :: (a -> b -> a) -> a -> [b] -> [a]
|
319
|
+
def test_scanl
|
320
|
+
result = @a.scanl(0){ |x, y| x+y}
|
321
|
+
expect = [0, 1, 3, 6, 10, 15]
|
322
|
+
|
323
|
+
assert_equal(expect, result)
|
324
|
+
end
|
325
|
+
|
326
|
+
# , scanl1 -- :: (a -> a -> a) -> [a] -> [a]
|
327
|
+
def test_scanl1
|
328
|
+
result = @a.scanl1{ |x, y| x+y}
|
329
|
+
expect = [1, 3, 6, 10, 15]
|
330
|
+
|
331
|
+
assert_equal(expect, result)
|
332
|
+
end
|
333
|
+
|
334
|
+
# , scanr -- :: (a -> b -> b) -> b -> [a] -> [b]
|
335
|
+
def test_scanr
|
336
|
+
result = @a.scanr(0){ |x, y| x+y}
|
337
|
+
expect = [0, 1, 3, 6, 10, 15]
|
338
|
+
|
339
|
+
assert_equal(expect, result)
|
340
|
+
end
|
341
|
+
|
342
|
+
# , scanr1 -- :: (a -> a -> a) -> [a] -> [a]
|
343
|
+
def test_scanr1
|
344
|
+
result = @a.scanr1{ |x, y| x+y}
|
345
|
+
expect = [1, 3, 6, 10, 15]
|
346
|
+
|
347
|
+
assert_equal(expect, result)
|
348
|
+
end
|
349
|
+
|
350
|
+
|
351
|
+
# -- ** Accumulating maps
|
352
|
+
# , mapAccumL -- :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
|
353
|
+
def test_mapAccumL
|
354
|
+
result = @a.mapAccumL
|
355
|
+
expect = []
|
356
|
+
|
357
|
+
assert_equal(expect, result)
|
358
|
+
end
|
359
|
+
|
360
|
+
# , mapAccumR -- :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
|
361
|
+
def test_mapAccumR
|
362
|
+
result = @a.mapAccumR
|
363
|
+
expect = []
|
364
|
+
|
365
|
+
assert_equal(expect, result)
|
366
|
+
end
|
367
|
+
|
368
|
+
|
369
|
+
# -- ** Infinite lists
|
370
|
+
# , iterate -- :: (a -> a) -> a -> [a]
|
371
|
+
def test_iterate
|
372
|
+
result = @a.iterate
|
373
|
+
expect = []
|
374
|
+
|
375
|
+
assert_equal(expect, result)
|
376
|
+
end
|
377
|
+
|
378
|
+
# , repeat -- :: a -> [a]
|
379
|
+
def test_repeat
|
380
|
+
result = @a.repeat
|
381
|
+
expect = []
|
382
|
+
|
383
|
+
assert_equal(expect, result)
|
384
|
+
end
|
385
|
+
|
386
|
+
# , replicate -- :: Int -> a -> [a]
|
387
|
+
def test_replicate
|
388
|
+
result = @a.replicate
|
389
|
+
expect = []
|
390
|
+
|
391
|
+
assert_equal(expect, result)
|
392
|
+
end
|
393
|
+
|
394
|
+
# , cycle -- :: [a] -> [a]
|
395
|
+
def test_cycle
|
396
|
+
result = @a.cycle
|
397
|
+
expect = []
|
398
|
+
|
399
|
+
assert_equal(expect, result)
|
400
|
+
end
|
401
|
+
|
402
|
+
|
403
|
+
# -- ** Unfolding
|
404
|
+
# , unfoldr -- :: (b -> Maybe (a, b)) -> b -> [a]
|
405
|
+
def test_unfoldr
|
406
|
+
result = @a.unfoldr
|
407
|
+
expect = []
|
408
|
+
|
409
|
+
assert_equal(expect, result)
|
410
|
+
end
|
411
|
+
|
412
|
+
|
413
|
+
# -- * Sublists
|
414
|
+
|
415
|
+
# -- ** Extracting sublists
|
416
|
+
# , take -- :: Int -> [a] -> [a]
|
417
|
+
def test_take
|
418
|
+
result = @a.take(2)
|
419
|
+
expect = [1, 2]
|
420
|
+
|
421
|
+
assert_equal(expect, result)
|
422
|
+
end
|
423
|
+
|
424
|
+
# , drop -- :: Int -> [a] -> [a]
|
425
|
+
def test_drop
|
426
|
+
result = @a.drop(2)
|
427
|
+
expect = [3, 4, 5]
|
428
|
+
|
429
|
+
assert_equal(expect, result)
|
430
|
+
end
|
431
|
+
|
432
|
+
# , splitAt -- :: Int -> [a] -> ([a], [a])
|
433
|
+
def test_split_at
|
434
|
+
result = @a.split_at(2)
|
435
|
+
expect = [[1, 2],[3, 4, 5]]
|
436
|
+
|
437
|
+
assert_equal(expect, result)
|
438
|
+
end
|
439
|
+
|
440
|
+
# , takeWhile -- :: (a -> Bool) -> [a] -> [a]
|
441
|
+
def test_takeWhile
|
442
|
+
result = @a.takeWhile{|x| x<4}
|
443
|
+
expect = [1, 2, 3]
|
444
|
+
|
445
|
+
assert_equal(expect, result)
|
446
|
+
end
|
447
|
+
|
448
|
+
# , dropWhile -- :: (a -> Bool) -> [a] -> [a]
|
449
|
+
def test_dropWhile
|
450
|
+
result = @a.dropWhile{|x| x<4}
|
451
|
+
expect = [4, 5]
|
452
|
+
|
453
|
+
assert_equal(expect, result)
|
454
|
+
end
|
455
|
+
|
456
|
+
# , span -- :: (a -> Bool) -> [a] -> ([a], [a])
|
457
|
+
def test_span
|
458
|
+
result = @a.span{|x| x<3}
|
459
|
+
expect = [[1, 2], [3, 4, 5]]
|
460
|
+
|
461
|
+
assert_equal(expect, result)
|
462
|
+
end
|
463
|
+
|
464
|
+
# , break -- :: (a -> Bool) -> [a] -> ([a], [a])
|
465
|
+
def test_break
|
466
|
+
result = @a.break
|
467
|
+
expect = []
|
468
|
+
|
469
|
+
assert_equal(expect, result)
|
470
|
+
end
|
471
|
+
|
472
|
+
# , group -- :: Eq a => [a] -> [[a]]
|
473
|
+
def test_group
|
474
|
+
result = @a.group
|
475
|
+
expect = []
|
476
|
+
|
477
|
+
assert_equal(expect, result)
|
478
|
+
end
|
479
|
+
|
480
|
+
# , inits -- :: [a] -> [[a]]
|
481
|
+
def test_inits
|
482
|
+
result = @a.inits
|
483
|
+
expect = []
|
484
|
+
|
485
|
+
assert_equal(expect, result)
|
486
|
+
end
|
487
|
+
|
488
|
+
# , tails -- :: [a] -> [[a]]
|
489
|
+
def test_tails
|
490
|
+
result = @a.tails
|
491
|
+
expect = []
|
492
|
+
|
493
|
+
assert_equal(expect, result)
|
494
|
+
end
|
495
|
+
|
496
|
+
# -- ** Predicates
|
497
|
+
# , isPrefixOf -- :: (Eq a) => [a] -> [a] -> Bool
|
498
|
+
def test_isPrefixOf
|
499
|
+
result = @a.isPrefixOf
|
500
|
+
expect = []
|
501
|
+
|
502
|
+
assert_equal(expect, result)
|
503
|
+
end
|
504
|
+
|
505
|
+
# , isSuffixOf -- :: (Eq a) => [a] -> [a] -> Bool
|
506
|
+
def test_isSuffixOf
|
507
|
+
result = @a.isSuffixOf
|
508
|
+
expect = []
|
509
|
+
|
510
|
+
assert_equal(expect, result)
|
511
|
+
end
|
512
|
+
|
513
|
+
|
514
|
+
# -- * Searching lists
|
515
|
+
|
516
|
+
# -- ** Searching by equality
|
517
|
+
# , elem -- :: a -> [a] -> Bool
|
518
|
+
def test_elem
|
519
|
+
result = @a.elem
|
520
|
+
expect = []
|
521
|
+
|
522
|
+
assert_equal(expect, result)
|
523
|
+
end
|
524
|
+
|
525
|
+
# , notElem -- :: a -> [a] -> Bool
|
526
|
+
def test_notElem
|
527
|
+
result = @a.notElem
|
528
|
+
expect = []
|
529
|
+
|
530
|
+
assert_equal(expect, result)
|
531
|
+
end
|
532
|
+
|
533
|
+
# , lookup -- :: (Eq a) => a -> [(a,b)] -> Maybe b
|
534
|
+
def test_lookup
|
535
|
+
result = @a.lookup
|
536
|
+
expect = []
|
537
|
+
|
538
|
+
assert_equal(expect, result)
|
539
|
+
end
|
540
|
+
|
541
|
+
# -- ** Searching with a predicate
|
542
|
+
# , find -- :: (a -> Bool) -> [a] -> Maybe a
|
543
|
+
def test_find
|
544
|
+
result = @a.find{|x| x==3}
|
545
|
+
expect = 3
|
546
|
+
|
547
|
+
assert_equal(expect, result)
|
548
|
+
end
|
549
|
+
|
550
|
+
# , filter -- :: (a -> Bool) -> [a] -> [a]
|
551
|
+
def test_filter
|
552
|
+
result = @a.filter
|
553
|
+
expect = []
|
554
|
+
|
555
|
+
assert_equal(expect, result)
|
556
|
+
end
|
557
|
+
|
558
|
+
# , partition -- :: (a -> Bool) -> [a] -> ([a], [a])
|
559
|
+
def test_partition
|
560
|
+
result = @a.partition{|x| x>3}
|
561
|
+
expect = [[4, 5], [1, 2, 3]]
|
562
|
+
|
563
|
+
assert_equal(expect, result)
|
564
|
+
end
|
565
|
+
|
566
|
+
|
567
|
+
# -- * Indexing lists
|
568
|
+
# -- | These functions treat a list @xs@ as a indexed collection,
|
569
|
+
# -- with indices ranging from 0 to @'length' xs - 1@.
|
570
|
+
|
571
|
+
# , (!!) -- :: [a] -> Int -> a
|
572
|
+
# Don't know how to implement it in Ruby
|
573
|
+
|
574
|
+
|
575
|
+
# , elemIndex -- :: (Eq a) => a -> [a] -> Maybe Int
|
576
|
+
def test_elemIndex
|
577
|
+
result = @a.elemIndex
|
578
|
+
expect = []
|
579
|
+
|
580
|
+
assert_equal(expect, result)
|
581
|
+
end
|
582
|
+
|
583
|
+
# , elemIndices -- :: (Eq a) => a -> [a] -> [Int]
|
584
|
+
def test_elemIndices
|
585
|
+
result = @a.elemIndices
|
586
|
+
expect = []
|
587
|
+
|
588
|
+
assert_equal(expect, result)
|
589
|
+
end
|
590
|
+
|
591
|
+
|
592
|
+
# , findIndex -- :: (a -> Bool) -> [a] -> Maybe Int
|
593
|
+
def test_findIndex
|
594
|
+
result = @a.findIndex
|
595
|
+
expect = []
|
596
|
+
|
597
|
+
assert_equal(expect, result)
|
598
|
+
end
|
599
|
+
|
600
|
+
# , findIndices -- :: (a -> Bool) -> [a] -> [Int]
|
601
|
+
def test_findIndices
|
602
|
+
result = @a.findIndices
|
603
|
+
expect = []
|
604
|
+
|
605
|
+
assert_equal(expect, result)
|
606
|
+
end
|
607
|
+
|
608
|
+
|
609
|
+
# -- * Zipping and unzipping lists
|
610
|
+
|
611
|
+
# , zip -- :: [a] -> [b] -> [(a,b)]
|
612
|
+
def test_zip
|
613
|
+
result = @a.zip(@a)
|
614
|
+
expect = [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5] ]
|
615
|
+
|
616
|
+
assert_equal(expect, result)
|
617
|
+
end
|
618
|
+
|
619
|
+
# , zip3
|
620
|
+
def test_zip3
|
621
|
+
result = @a.zip3
|
622
|
+
expect = []
|
623
|
+
|
624
|
+
assert_equal(expect, result)
|
625
|
+
end
|
626
|
+
|
627
|
+
# , zip4, zip5, zip6, zip7
|
628
|
+
def test_zip4
|
629
|
+
result = @a.zip4
|
630
|
+
expect = []
|
631
|
+
|
632
|
+
assert_equal(expect, result)
|
633
|
+
end
|
634
|
+
|
635
|
+
|
636
|
+
# , zipWith -- :: (a -> b -> c) -> [a] -> [b] -> [c]
|
637
|
+
def test_zipWith
|
638
|
+
result = @a.zipWith
|
639
|
+
expect = []
|
640
|
+
|
641
|
+
assert_equal(expect, result)
|
642
|
+
end
|
643
|
+
|
644
|
+
# , zipWith3
|
645
|
+
def test_zipWith3
|
646
|
+
result = @a.zipWith3
|
647
|
+
expect = []
|
648
|
+
|
649
|
+
assert_equal(expect, result)
|
650
|
+
end
|
651
|
+
|
652
|
+
# , zipWith4, zipWith5, zipWith6, zipWith7
|
653
|
+
def test_zipWith4
|
654
|
+
result = @a.zipWith4
|
655
|
+
expect = []
|
656
|
+
|
657
|
+
assert_equal(expect, result)
|
658
|
+
end
|
659
|
+
|
660
|
+
|
661
|
+
# , unzip -- :: [(a,b)] -> ([a],[b])
|
662
|
+
def test_unzip
|
663
|
+
result = @a.unzip
|
664
|
+
expect = []
|
665
|
+
|
666
|
+
assert_equal(expect, result)
|
667
|
+
end
|
668
|
+
|
669
|
+
# , unzip3
|
670
|
+
def test_unzip3
|
671
|
+
result = @a.unzip3
|
672
|
+
expect = []
|
673
|
+
|
674
|
+
assert_equal(expect, result)
|
675
|
+
end
|
676
|
+
|
677
|
+
# , unzip4, unzip5, unzip6, unzip7
|
678
|
+
def test_unzip4
|
679
|
+
result = @a.unzip4
|
680
|
+
expect = []
|
681
|
+
|
682
|
+
assert_equal(expect, result)
|
683
|
+
end
|
684
|
+
|
685
|
+
|
686
|
+
# -- * Special lists
|
687
|
+
|
688
|
+
# -- ** Functions on strings
|
689
|
+
# , lines -- :: String -> [String]
|
690
|
+
def test_lines
|
691
|
+
result = @a.lines
|
692
|
+
expect = []
|
693
|
+
|
694
|
+
assert_equal(expect, result)
|
695
|
+
end
|
696
|
+
|
697
|
+
# , words -- :: String -> [String]
|
698
|
+
def test_words
|
699
|
+
result = @a.words
|
700
|
+
expect = []
|
701
|
+
|
702
|
+
assert_equal(expect, result)
|
703
|
+
end
|
704
|
+
|
705
|
+
# , unlines -- :: [String] -> String
|
706
|
+
def test_unlines
|
707
|
+
result = @a.unlines
|
708
|
+
expect = []
|
709
|
+
|
710
|
+
assert_equal(expect, result)
|
711
|
+
end
|
712
|
+
|
713
|
+
# , unwords -- :: [String] -> String
|
714
|
+
def test_unwords
|
715
|
+
result = @a.unwords
|
716
|
+
expect = []
|
717
|
+
|
718
|
+
assert_equal(expect, result)
|
719
|
+
end
|
720
|
+
|
721
|
+
|
722
|
+
# -- ** \"Set\" operations
|
723
|
+
|
724
|
+
# , nub -- :: (Eq a) => [a] -> [a]
|
725
|
+
def test_nub
|
726
|
+
result = @a.nub
|
727
|
+
expect = []
|
728
|
+
|
729
|
+
assert_equal(expect, result)
|
730
|
+
end
|
731
|
+
|
732
|
+
|
733
|
+
# , delete -- :: (Eq a) => a -> [a] -> [a]
|
734
|
+
def test_delete
|
735
|
+
result = @a.delete(3)
|
736
|
+
expect = []
|
737
|
+
|
738
|
+
assert_equal(expect, result)
|
739
|
+
end
|
740
|
+
|
741
|
+
# , (\\) -- :: (Eq a) => [a] -> [a] -> [a]
|
742
|
+
# Don't know how to implement it in Ruby
|
743
|
+
|
744
|
+
# , union -- :: (Eq a) => [a] -> [a] -> [a]
|
745
|
+
def test_union
|
746
|
+
result = @a.union
|
747
|
+
expect = []
|
748
|
+
|
749
|
+
assert_equal(expect, result)
|
750
|
+
end
|
751
|
+
|
752
|
+
# , intersect -- :: (Eq a) => [a] -> [a] -> [a]
|
753
|
+
def test_intersect
|
754
|
+
result = @a.intersect
|
755
|
+
expect = []
|
756
|
+
|
757
|
+
assert_equal(expect, result)
|
758
|
+
end
|
759
|
+
|
760
|
+
|
761
|
+
# -- ** Ordered lists
|
762
|
+
# , sort -- :: (Ord a) => [a] -> [a]
|
763
|
+
|
764
|
+
# , insert -- :: (Ord a) => a -> [a] -> [a]
|
765
|
+
def test_insert
|
766
|
+
result = @a.insert(3.5)
|
767
|
+
expect = []
|
768
|
+
|
769
|
+
assert_equal(expect, result)
|
770
|
+
end
|
771
|
+
|
772
|
+
end # TestList
|