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

Author: aNNiMON

src/main/java/com/annimon/ownlang/lib/MapValue.java

@@ -20,7 +20,7 @@ public static MapValue merge(MapValue map1, MapValue map2) {
         result.map.putAll(map2.map);
         return result;
     }
-    
+
     private final Map<Value, Value> map;
 
     public MapValue(int size) {
@@ -30,6 +30,18 @@ public MapValue(int size) {
     public MapValue(Map<Value, Value> map) {
         this.map = map;
     }
+
+    public ArrayValue toPairs() {
+        final int size = map.size();
+        final ArrayValue result = new ArrayValue(size);
+        int index = 0;
+        for (Map.Entry<Value, Value> entry : map.entrySet()) {
+            result.set(index++, new ArrayValue(new Value[] {
+                entry.getKey(), entry.getValue()
+            }));
+        }
+        return result;
+    }
 
     @Override
     public int type() {

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

@@ -28,6 +28,7 @@ public void init() {
         Functions.set("dropwhile", new functional_dropwhile());
 
         Functions.set("chain", new functional_chain());
+        Functions.set("stream", new functional_stream());
         Functions.set("combine", new functional_combine());
     }
 }

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

@@ -0,0 +1,106 @@
+package com.annimon.ownlang.lib.modules.functions;
+
+import com.annimon.ownlang.exceptions.TypeException;
+import com.annimon.ownlang.lib.*;
+
+public final class functional_stream implements Function {
+
+    @Override
+    public Value execute(Value... args) {
+        Arguments.checkAtLeast(1, args.length);
+
+        if (args.length > 1) {
+            return new StreamValue(new ArrayValue(args));
+        }
+        
+        final Value value = args[0];
+        switch (value.type()) {
+            case Types.MAP:
+                return new StreamValue(((MapValue) value).toPairs());
+            case Types.ARRAY:
+                return new StreamValue((ArrayValue) value);
+            default:
+                throw new TypeException("Invalid argument. Array or map expected");
+        }
+    }
+
+    private static class StreamValue extends MapValue {
+
+        private final ArrayValue container;
+
+        public StreamValue(ArrayValue container) {
+            super(12);
+            this.container = container;
+            init();
+        }
+
+        private void init() {
+            set("filter", wrapIntermediate(new functional_filter(false)));
+            set("map", wrapIntermediate(new functional_map()));
+            set("flatMap", wrapIntermediate(new functional_flatmap()));
+            set("sortBy", wrapIntermediate(new functional_sortby()));
+            set("takeWhile", wrapIntermediate(new functional_filter(true)));
+            set("dropWhile", wrapIntermediate(new functional_dropwhile()));
+            set("skip", this::skip);
+            set("limit", this::limit);
+
+            set("reduce", wrapTerminal(new functional_reduce()));
+            set("forEach", wrapTerminal(new functional_foreach()));
+            set("toArray", args -> container);
+            set("count", args -> NumberValue.of(container.size()));
+        }
+
+        private Value skip(Value... args) {
+            Arguments.check(1, args.length);
+
+            final int skipCount = args[0].asInt();
+            final int size = container.size();
+
+            if (skipCount <= 0) return this;
+            if (skipCount >= size) {
+                return new StreamValue(new ArrayValue(0));
+            }
+
+            final Value[] result = new Value[size - skipCount];
+            System.arraycopy(container.getCopyElements(), skipCount, result, 0, result.length);
+            return new StreamValue(new ArrayValue(result));
+        }
+
+        private Value limit(Value... args) {
+            Arguments.check(1, args.length);
+
+            final int limitCount = args[0].asInt();
+            final int size = container.size();
+
+            if (limitCount >= size) return this;
+            if (limitCount <= 0) {
+                return new StreamValue(new ArrayValue(0));
+            }
+
+            final Value[] result = new Value[limitCount];
+            System.arraycopy(container.getCopyElements(), 0, result, 0, limitCount);
+            return new StreamValue(new ArrayValue(result));
+        }
+
+        private FunctionValue wrapIntermediate(Function f) {
+            return wrap(f, true);
+        }
+
+        private FunctionValue wrapTerminal(Function f) {
+            return wrap(f, false);
+        }
+
+        private FunctionValue wrap(Function f, boolean intermediate) {
+            return new FunctionValue(args -> {
+                final Value[] newArgs = new Value[args.length + 1];
+                System.arraycopy(args, 0, newArgs, 1, args.length);
+                newArgs[0] = container;
+                final Value result = f.execute(newArgs);
+                if (intermediate && result.type() == Types.ARRAY) {
+                    return new StreamValue((ArrayValue) result);
+                }
+                return result;
+            });
+        }
+    }
+}

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

@@ -1,11 +1,39 @@
 use "functional"
 
-def testFunctionalChain() {
+def testStream() {
   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,
-  )
+  result = stream(data)
+    .filter(def(x) = x <= 4)
+    .sortBy(def(x) = -x)
+    .map(def(x) = x * 2)
+    .toArray()
   assertEquals([8,6,4,2], result)
 }
+
+def testSkip() {
+  data = [1,2,3,4,5,6,7]
+  assertEquals(7, stream(data).skip(0).count())
+  assertEquals(5, stream(data).skip(2).count())
+  assertEquals(0, stream(data).skip(7).count())
+  assertEquals(0, stream(data).skip(20).count())
+}
+
+def testLimit() {
+  data = [1,2,3,4,5,6,7]
+  assertEquals(0, stream(data).limit(0).count())
+  assertEquals(2, stream(data).limit(2).count())
+  assertEquals(7, stream(data).limit(7).count())
+  assertEquals(7, stream(data).limit(20).count())
+}
+
+def testTakeWhile() {
+  data = [2,4,6,5,6,7,8]
+  assertEquals([2, 4, 6], stream(data).takeWhile(def(x) = x % 2 == 0).toArray())
+  assertEquals(0, stream(data).takeWhile(def(x) = x % 2 != 0).count())
+}
+
+def testDropWhile() {
+  data = [2,4,6,5,6,7,8]
+  assertEquals([5, 6, 7, 8], stream(data).dropWhile(def(x) = x % 2 == 0).toArray())
+  assertEquals(data, stream(data).dropWhile(def(x) = x % 2 != 0).toArray())
+}