#20 map, flatMap, and flatten work on one level

- Map and Flatten Enumerators are no longer recursive.
- Added [Callable identity] to use in testing flatMap.
- Removed testMapLiftsMappables - map shouldn’t lift mappables

src/main/Callables.h

@@ -5,6 +5,8 @@ typedef NSNumber *(^CALLABLE_TO_NUMBER)(id);
 typedef NSString *(^ACCUMULATOR_TO_STRING)(id, id);
 
 @interface Callables : NSObject
++ (id (^)(id))identity;
+
 + (NSString * (^)(NSString *))toUpperCase;
 
 + (NSString * (^)(NSString *, NSString *))appendString;

src/main/Callables.m

@@ -1,6 +1,10 @@
 #import "Callables.h"
 
 @implementation Callables
++ (id (^)(id))identity {
+    return [^(id item) { return item; } copy];
+}
+
 + (NSString * (^)(NSString *))toUpperCase {
     return [^(NSString *item) { return item.uppercaseString; } copy];
 }

src/main/enumerators/FlattenEnumerator.m

@@ -20,7 +20,7 @@ - (id)nextObject {
     while((item = [currentEnumerator nextObject]) == nil) {
         id nextItem = [enumerator nextObject];
         if ([nextItem respondsToSelector:@selector(toEnumerator)]) {
-            currentEnumerator = [FlattenEnumerator withEnumerator:[nextItem toEnumerator]];
+            currentEnumerator = [nextItem toEnumerator];
             continue;
         }
         return nextItem;

src/main/enumerators/MapEnumerator.m

@@ -20,7 +20,7 @@ + (NSEnumerator *)withEnumerator:(NSEnumerator *)enumerator andFunction:(id (^)(
 
 - (id)nextObject {
     id item = [enumerator nextObject];
-    return (item == nil) ? nil : [item conformsToProtocol:@protocol(Mappable)] ? [item map:func] : func(item);
+    return (item == nil) ? nil : func(item);
 }
 
 

src/test-unit/NSArrayTest.m

@@ -39,16 +39,18 @@ - (void)testFlatMap {
             array(@"one", @"two", nil),
             array(@"three", @"four", nil),
             nil);
-    assertThat([items flatMap:[Callables toUpperCase]], hasItems(@"ONE", @"TWO", @"THREE", @"FOUR", nil));
+    assertThat([items flatMap:[Callables identity]], hasItems(@"one", @"two", @"three", @"four", nil));
 }
 
--(void)testFlatMapSupportsNDepthSequences {
+-(void)testFlatMapFlattensOnlyOneLevel {
     NSArray *items = array(
             @"one",
             array(@"two", @"three", nil),
             array(array(@"four", nil), nil),
             nil);
-    assertThat([items flatMap:[Callables toUpperCase]], hasItems(@"ONE", @"TWO", @"THREE", @"FOUR", nil));
+    NSArray *flatMapped = [items flatMap:[Callables identity]];
+    assertThat(flatMapped, hasItems(@"one", @"two", @"three", nil));
+    assertThat([flatMapped objectAtIndex:3], hasItems(@"four", nil));
 }
 
 -(void)testFlattenResolvesOptions {

src/test-unit/SequenceTest.m

@@ -64,7 +64,7 @@ - (void)testFlatMap {
             sequence(@"one", [None none], nil),
             sequence(@"three", @"four", nil),
             nil);
-    assertThat([[items flatMap:[Callables toUpperCase]] asArray], hasItems(@"ONE", @"THREE", @"FOUR", nil));
+    assertThat([[items flatMap:[Callables identity]] asArray], hasItems(@"one", [None none], @"three", @"four", nil));
 
     Sequence *numbers = sequence(@1, @2, @3, @4, nil);
     Sequence *flattenedNumbers = [numbers flatMap:^(NSNumber *number) {
@@ -104,7 +104,17 @@ - (void)testGroupByHandlesNilKeyAsUniqueGroup {
     }];
     assertThatInt([[groups asArray] count], equalToInt(3));
     assertThat([groups first], hasItems(@"one", nil));
+}
 
+- (void)testGroupByGeneratesMappableGroups {
+    Sequence *groups = [sequence(@"one", @"two", @"three", @"four", @"five", @"six", @"seven", nil) groupBy:^(NSString *item) {
+        return [NSNumber numberWithInt:item.length];
+    }];
+    Sequence *counts = [groups map:^id(Group *g) {
+        return @([[g asArray] count]);
+    }];
+    assertThat(counts, hasItems(@3, @2, @2, nil));
+    assertThatInt([[counts asArray] count], equalToInt(3));
 }
 
 - (void)testGrouped {
@@ -137,14 +147,6 @@ - (void)testMap {
     assertThat([doubled asArray], hasItems(@2, @4, @6, nil));
 }
 
-- (void)testMapLiftsMappables {
-    Sequence *lazy = sequence(@[@1], option(@2), [None none], nil);
-    Sequence *doubled = [lazy map:^(NSNumber *item) {
-        return @([item intValue] * 2);
-    }];
-    assertThat([doubled asArray], hasItems(@[@2], option(@4), [None none], nil));
-}
-
 - (void)testMapDoesNotRetainBlocks {
     self.checkRetained = @0;
     Sequence *lazy = sequence(@1, @2, @3, nil);
@@ -163,6 +165,14 @@ - (void)testMapWithIndex {
     assertThat([indexes asArray], hasItems(@0, @1, @2, nil));
 }
 
+- (void)testMapWithIndexNested {
+    Sequence *lazy = sequence(@"one", @"two", @"three", sequence(@"nestedOne", @"nestedTwo", nil), nil);
+    Sequence *indexes = [lazy mapWithIndex:^(id item, NSInteger index) {
+        return @(index);
+    }];
+    assertThat([indexes asArray], hasItems(@0, @1, @2, @3, nil));
+}
+
 - (void)testMerge {
     Sequence *result1 = [sequence(@"1", @"2", nil) merge:sequence(@"3", @"4", @"5", nil)];
     assertThat([result1 asArray], hasItems(@"1", @"3", @"2", @"4", @"5", nil));
@@ -315,12 +325,12 @@ - (void)testNonForwardBehaviour {
     assertThat([items take:1], hasItems(@"one", nil));
     assertThat([items take:1], hasItems(@"one", nil));
 
-    Sequence *flattenable = sequence(sequence(@"one", nil), @"two", nil);
+    Sequence *flattenable = sequence(@"one", @"two", nil);
     assertThat([flattenable flatMap:^(NSString *item) {
-        return [item substringFromIndex:1];
+        return option([item substringFromIndex:1]);
     }], hasItems(@"ne", @"wo", nil));
     assertThat([flattenable flatMap:^(NSString *item) {
-        return [item substringFromIndex:1];
+        return option([item substringFromIndex:1]);
     }], hasItems(@"ne", @"wo", nil));
 }