Differences between version #5858 and #5998

53d52
< 
55,56d53
< import neko.Lib;
< 
63c60
<     neko.Lib.println("nums: " + nums);
---
>     trace("nums: " + nums);
66,67c63,64
<     neko.Lib.println("count: " + Lambda.count(nums));
<     neko.Lib.println("is empty: " + Lambda.empty(nums));
---
>     trace("count: " + Lambda.count(nums));
>     trace("is empty: " + Lambda.empty(nums));
70,71c67,68
<     neko.Lib.println("contains 2: " + Lambda.has(nums, 2));
<     neko.Lib.println("contains 3: " + Lambda.has(nums, 3));
---
>     trace("contains 2: " + Lambda.has(nums, 2));
>     trace("contains 3: " + Lambda.has(nums, 3));
74,77c71,74
<     neko.Lib.println("contains an element less than 10: "
< 		     + Lambda.exists(nums, function(ii) { return ii<10; }));
<     neko.Lib.println("contains an element greater than 10: "
< 		     + Lambda.exists(nums, function(ii) { return ii>10; }));
---
>     trace("contains an element less than 10: "
>              + Lambda.exists(nums, function(ii) { return ii<10; }));
>     trace("contains an element greater than 10: "
>              + Lambda.exists(nums, function(ii) { return ii>10; }));
80,83c77,80
<     neko.Lib.println("all elements less than 10: "
< 		     + Lambda.foreach(nums, function(ii) { return ii<10; }));
<     neko.Lib.println("all elements greater than 10: "
< 		     + Lambda.foreach(nums, function(ii) { return ii>10; }));
---
>     trace("all elements less than 10: "
>              + Lambda.foreach(nums, function(ii) { return ii<10; }));
>     trace("all elements greater than 10: "
>              + Lambda.foreach(nums, function(ii) { return ii>10; }));
87c84
<     neko.Lib.println("even: " + Lambda.filter(nums, isEven));
---
>     trace("even: " + Lambda.filter(nums, isEven));
91c88
<     neko.Lib.println("times two: " + Lambda.map(nums, timesTwo));
---
>     trace("times two: " + Lambda.map(nums, timesTwo));
95c92
<     neko.Lib.println("sum: " + Lambda.fold(nums, sum, 0));
---
>     trace("sum: " + Lambda.fold(nums, sum, 0));
108,119c105,116
< nums: [1, 3, 5, 6, 7, 8]
< count: 6
< is empty: false
< contains 2: false
< contains 3: true
< contains an element less than 10: true
< contains an element greater than 10: false
< all elements less than 10: true
< all elements greater than 10: false
< even: {6, 8}
< times two: {2, 6, 10, 12, 14, 16}
< sum: 30
---
> LambdaNumberTest.hx:7: nums: [1, 3, 5, 6, 7, 8]
> LambdaNumberTest.hx:10: count: 6
> LambdaNumberTest.hx:11: is empty: false
> LambdaNumberTest.hx:14: contains 2: false
> LambdaNumberTest.hx:15: contains 3: true
> LambdaNumberTest.hx:18: contains an element less than 10: true
> LambdaNumberTest.hx:20: contains an element greater than 10: false
> LambdaNumberTest.hx:24: all elements less than 10: true
> LambdaNumberTest.hx:26: all elements greater than 10: false
> LambdaNumberTest.hx:31: even: {6, 8}
> LambdaNumberTest.hx:35: times two: {2, 6, 10, 12, 14, 16}
> LambdaNumberTest.hx:39: sum: 30
122a120
> Note that since there is no way to create and populate a list in a single statement we create ''words'' as an ''Array'' and convert it to a ''list'' with the ''Lambda.list'' function.
125,126d122
< import neko.Lib;
< 
133c129
<     neko.Lib.println("words: " + words);
---
>     trace("words: " + words);
136c132
<     neko.Lib.println("join: " + words.join('_'));
---
>     trace("join: " + words.join('_'));
139,140c135,136
<     neko.Lib.println("count: " + Lambda.count(words));
<     neko.Lib.println("is empty: " + words.isEmpty());
---
>     trace("count: " + Lambda.count(words));
>     trace("is empty: " + words.isEmpty());
143,144c139,140
<     neko.Lib.println("contains cat: " + Lambda.has(words, 'cat'));
<     neko.Lib.println("contains tree: " + Lambda.has(words, 'tree'));
---
>     trace("contains cat: " + Lambda.has(words, 'cat'));
>     trace("contains tree: " + Lambda.has(words, 'tree'));
147,150c143,146
<     neko.Lib.println("contains an element less than 5 letters: "
< 		     + Lambda.exists(words, function(ii) { return ii.length<5; })); 
<     neko.Lib.println("contains an element greater than 5 letters: "
< 		     + Lambda.exists(words, function(ii) { return ii.length>5; }));
---
>     trace("contains an element less than 5 letters: "
>              + Lambda.exists(words, function(ii) { return ii.length<5; })); 
>     trace("contains an element greater than 5 letters: "
>              + Lambda.exists(words, function(ii) { return ii.length>5; }));
153,156c149,152
<     neko.Lib.println("all elements are less than 5 letters: "
< 		     + Lambda.foreach(words, function(ii) { return ii.length<5; }));
<     neko.Lib.println("all elements are greater than 5 letters: "
< 		     + Lambda.foreach(words, function(ii) { return ii.length>5; }));
---
>     trace("all elements are less than 5 letters: "
>              + Lambda.foreach(words, function(ii) { return ii.length<5; }));
>     trace("all elements are greater than 5 letters: "
>              + Lambda.foreach(words, function(ii) { return ii.length>5; }));
160c156
<     neko.Lib.println("three letter words: " + words.filter(isThreeLetters));
---
>     trace("three letter words: " + words.filter(isThreeLetters));
164c160
<     neko.Lib.println("capitalized: " + words.map(capitalize));
---
>     trace("capitalized: " + words.map(capitalize));
168c164
<     neko.Lib.println("total letters: " + Lambda.fold(words, countLetters, 0));
---
>     trace("total letters: " + Lambda.fold(words, countLetters, 0));
181,194c177,210
< words: {car, boat, cat, frog}
< join: car_boat_cat_frog
< count: 4
< is empty: false
< contains cat: true
< contains tree: false
< contains an element less than 5 letters: true
< contains an element greater than 5 letters: false
< all elements are less than 5 letters: true
< all elements are greater than 5 letters: false
< three letter words: {car, cat}
< capitalized: {CAR, BOAT, CAT, FROG}
< total letters: 14
< </code>
\ No newline at end of file
---
> ListWordTest.hx:7: words: {car, boat, cat, frog}
> ListWordTest.hx:10: join: car_boat_cat_frog
> ListWordTest.hx:13: count: 4
> ListWordTest.hx:14: is empty: false
> ListWordTest.hx:17: contains cat: true
> ListWordTest.hx:18: contains tree: false
> ListWordTest.hx:21: contains an element less than 5 letters: true
> ListWordTest.hx:23: contains an element greater than 5 letters: false
> ListWordTest.hx:27: all elements are less than 5 letters: true
> ListWordTest.hx:29: all elements are greater than 5 letters: false
> ListWordTest.hx:34: three letter words: {car, cat}
> ListWordTest.hx:38: capitalized: {CAR, BOAT, CAT, FROG}
> ListWordTest.hx:42: total letters: 14
> </code>
> 
> ==== Type Inference ==== 
> We use type inference to improve code readability, but we could have declared each variable's type explicitly.  If doing so ''nums'' would be defined as:
> <code haxe>
>     var nums : Array<Int> = [1, 3, 5, 6, 7, 8];
> </code>
> ''words'' could be defined as:
> <code haxe>
>     var words : Array<String> = Lambda.list(['car', 'boat', 'cat', 'frog']);
> </code>
> ''isEven'' could be defined as:
> <code haxe>
>     var isEven : Int->Bool = function(num:Int) 
> 	{ return Math.floor(num/2) == num/2; }
> </code>
> ''countLetters'' could be defined as:
> <code haxe>
>     var countLetters : String->Int->Int = function(word:String, total:Int) 
> 	{ return total+=word.length; }
> </code>