1
1
//! A standard linked list
2
+ #[ forbid( deprecated_mode) ] ;
3
+ #[ forbid( deprecated_pattern) ] ;
2
4
3
5
import core:: cmp:: Eq ;
4
6
import core:: option;
@@ -28,9 +30,9 @@ fn from_vec<T: copy>(v: &[T]) -> @list<T> {
28
30
* * z - The initial value
29
31
* * f - The function to apply
30
32
*/
31
- fn foldl < T : copy , U > ( z : T , ls : @list < U > , f : fn ( T , U ) -> T ) -> T {
33
+ fn foldl < T : copy , U > ( + z : T , ls : @list < U > , f : fn ( ( & T ) , ( & U ) ) -> T ) -> T {
32
34
let mut accum: T = z;
33
- do iter( ls) |elt| { accum = f ( accum, elt) ; }
35
+ do iter( ls) |elt| { accum = f ( & accum, & elt) ; }
34
36
accum
35
37
}
36
38
@@ -41,12 +43,12 @@ fn foldl<T: copy, U>(z: T, ls: @list<U>, f: fn(T, U) -> T) -> T {
41
43
* When function `f` returns true then an option containing the element
42
44
* is returned. If `f` matches no elements then none is returned.
43
45
*/
44
- fn find < T : copy > ( ls : @list < T > , f : fn ( T ) -> bool ) -> Option < T > {
46
+ fn find < T : copy > ( ls : @list < T > , f : fn ( ( & T ) ) -> bool ) -> Option < T > {
45
47
let mut ls = ls;
46
48
loop {
47
49
ls = match * ls {
48
50
cons( hd, tl) => {
49
- if f ( hd) { return Some ( hd) ; }
51
+ if f ( & hd) { return Some ( hd) ; }
50
52
tl
51
53
}
52
54
nil => return None
@@ -55,7 +57,7 @@ fn find<T: copy>(ls: @list<T>, f: fn(T) -> bool) -> Option<T> {
55
57
}
56
58
57
59
/// Returns true if a list contains an element with the given value
58
- fn has < T : copy Eq > ( ls : @list < T > , elt : T ) -> bool {
60
+ fn has < T : copy Eq > ( ls : @list < T > , + elt : T ) -> bool {
59
61
for each( ls) |e| {
60
62
if e == elt { return true ; }
61
63
}
@@ -110,10 +112,13 @@ pure fn append<T: copy>(l: @list<T>, m: @list<T>) -> @list<T> {
110
112
}
111
113
}
112
114
113
- /// Push an element to the front of a list
114
- fn push < T : copy > ( & l: list < T > , v : T ) {
115
- l = cons ( v, @l) ;
115
+ /*
116
+ /// Push one element into the front of a list, returning a new list
117
+ /// THIS VERSION DOESN'T ACTUALLY WORK
118
+ pure fn push<T: copy>(ll: &mut @list<T>, +vv: T) {
119
+ ll = &mut @cons(vv, *ll)
116
120
}
121
+ */
117
122
118
123
/// Iterate over a list
119
124
fn iter < T > ( l : @list < T > , f : fn ( T ) ) {
@@ -201,7 +206,7 @@ mod tests {
201
206
202
207
#[ test]
203
208
fn test_foldl ( ) {
204
- fn add ( & & a: uint , & & b: int ) -> uint { return a + ( b as uint ) ; }
209
+ fn add ( a : & uint , b : & int ) -> uint { return * a + ( * b as uint ) ; }
205
210
let l = from_vec ( ~[ 0 , 1 , 2 , 3 , 4 ] ) ;
206
211
let empty = @list:: nil :: < int > ;
207
212
assert ( list:: foldl ( 0 u, l, add) == 10 u) ;
@@ -210,23 +215,23 @@ mod tests {
210
215
211
216
#[ test]
212
217
fn test_foldl2 ( ) {
213
- fn sub ( & & a: int , & & b: int ) -> int {
214
- a - b
218
+ fn sub ( a : & int , b : & int ) -> int {
219
+ * a - * b
215
220
}
216
221
let l = from_vec ( ~[ 1 , 2 , 3 , 4 ] ) ;
217
222
assert ( list:: foldl ( 0 , l, sub) == -10 ) ;
218
223
}
219
224
220
225
#[ test]
221
226
fn test_find_success ( ) {
222
- fn match_ ( & & i: int ) -> bool { return i == 2 ; }
227
+ fn match_ ( i : & int ) -> bool { return * i == 2 ; }
223
228
let l = from_vec ( ~[ 0 , 1 , 2 ] ) ;
224
229
assert ( list:: find ( l, match_) == option:: Some ( 2 ) ) ;
225
230
}
226
231
227
232
#[ test]
228
233
fn test_find_fail ( ) {
229
- fn match_ ( & & _i: int ) -> bool { return false ; }
234
+ fn match_ ( _i : & int ) -> bool { return false ; }
230
235
let l = from_vec ( ~[ 0 , 1 , 2 ] ) ;
231
236
let empty = @list:: nil :: < int > ;
232
237
assert ( list:: find ( l, match_) == option:: None :: < int > ) ;
@@ -251,6 +256,11 @@ mod tests {
251
256
assert ( list:: len ( empty) == 0 u) ;
252
257
}
253
258
259
+ #[ test]
260
+ fn test_append ( ) {
261
+ assert from_vec ( ~[ 1 , 2 , 3 , 4 ] )
262
+ == list:: append ( list:: from_vec ( ~[ 1 , 2 ] ) , list:: from_vec ( ~[ 3 , 4 ] ) ) ;
263
+ }
254
264
}
255
265
256
266
// Local Variables:
0 commit comments