Добавлена функция functional::takewhile

Author: aNNiMON

src/main/java/com/annimon/ownlang/lib/modules/functional.java

@@ -22,9 +22,10 @@ public void init() {
         Functions.set("map", new functional_map());
         Functions.set("flatmap", new functional_flatmap());
         Functions.set("reduce", new functional_reduce());
-        Functions.set("filter", new functional_filter());
+        Functions.set("filter", new functional_filter(false));
         Functions.set("sortby", new functional_sortby());
-        
+        Functions.set("takewhile", new functional_filter(true));
+
         Functions.set("chain", new functional_chain());
         Functions.set("combine", new functional_combine());
     }

src/main/java/com/annimon/ownlang/lib/modules/functions/functional_dropwhile.java

@@ -0,0 +1,53 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.TypeException;
+import com.annimon.ownlang.lib.*;
+import java.util.ArrayList;
+import java.util.List;
+
+import java.util.Map;
+
+public final class functional_filter implements Function {
+
+    @Override
+    public Value execute(Value... args) {
+        Arguments.check(2, args.length);
+        if (args[1].type() != Types.FUNCTION) {
+            throw new TypeException("Function expected in second argument");
+        }
+
+        final Value container = args[0];
+        final Function consumer = ((FunctionValue) args[1]).getValue();
+        if (container.type() == Types.ARRAY) {
+            return filterArray((ArrayValue) container, consumer);
+        }
+        
+        if (container.type() == Types.MAP) {
+            return filterMap((MapValue) container, consumer);
+        }
+
+        throw new TypeException("Invalid first argument. Array or map expected");
+    }
+    
+    private Value filterArray(ArrayValue array, Function predicate) {
+        final int size = array.size();
+        final List<Value> values = new ArrayList<Value>(size);
+        for (Value value : array) {
+            if (predicate.execute(value) != NumberValue.ZERO) {
+                values.add(value);
+            }
+        }
+        final int newSize = values.size();
+        return new ArrayValue(values.toArray(new Value[newSize]));
+    }
+    
+    private Value filterMap(MapValue map, Function predicate) {
+        final MapValue result = new MapValue(map.size());
+        for (Map.Entry<Value, Value> element : map) {
+            if (predicate.execute(element.getKey(), element.getValue()) != NumberValue.ZERO) {
+                result.set(element.getKey(), element.getValue());
+            }
+        }
+        return result;
+    }
+}

src/main/java/com/annimon/ownlang/lib/modules/functions/functional_filter.java

@@ -4,11 +4,16 @@
 import com.annimon.ownlang.lib.*;
 import java.util.ArrayList;
 import java.util.List;
-
 import java.util.Map;
 
 public final class functional_filter implements Function {
 
+    private final boolean takeWhile;
+
+    public functional_filter(boolean takeWhile) {
+        this.takeWhile = takeWhile;
+    }
+
     @Override
     public Value execute(Value... args) {
         Arguments.check(2, args.length);
@@ -17,36 +22,36 @@ public Value execute(Value... args) {
         }
 
         final Value container = args[0];
-        final Function consumer = ((FunctionValue) args[1]).getValue();
+        final Function predicate = ((FunctionValue) args[1]).getValue();
         if (container.type() == Types.ARRAY) {
-            return filterArray((ArrayValue) container, consumer);
+            return filterArray((ArrayValue) container, predicate, takeWhile);
         }
 
         if (container.type() == Types.MAP) {
-            return filterMap((MapValue) container, consumer);
+            return filterMap((MapValue) container, predicate, takeWhile);
         }
 
         throw new TypeException("Invalid first argument. Array or map expected");
     }
 
-    private Value filterArray(ArrayValue array, Function predicate) {
+    private Value filterArray(ArrayValue array, Function predicate, boolean takeWhile) {
         final int size = array.size();
         final List<Value> values = new ArrayList<Value>(size);
         for (Value value : array) {
             if (predicate.execute(value) != NumberValue.ZERO) {
                 values.add(value);
-            }
+            } else if (takeWhile) break;
         }
         final int newSize = values.size();
         return new ArrayValue(values.toArray(new Value[newSize]));
     }
 
-    private Value filterMap(MapValue map, Function predicate) {
+    private Value filterMap(MapValue map, Function predicate, boolean takeWhile) {
         final MapValue result = new MapValue(map.size());
         for (Map.Entry<Value, Value> element : map) {
             if (predicate.execute(element.getKey(), element.getValue()) != NumberValue.ZERO) {
                 result.set(element.getKey(), element.getValue());
-            }
+            } else if (takeWhile) break;
         }
         return result;
     }

src/test/resources/modules/functional/stream.own

@@ -0,0 +1,11 @@
+use "functional"
+
+def testFunctionalChain() {
+  data = [1,2,3,4,5,6,7]
+  result = chain(data,
+    ::filter, def(x) = x <= 4,
+    ::sortby, def(x) = -x,
+    ::map,    def(x) = x * 2,
+  )
+  assertEquals([8,6,4,2], result)
+}