From c7c2fb47099bb9e66cd9cf6660db250982836d17 Mon Sep 17 00:00:00 2001
From: Nat Quayle Nelson <natquaylenelson@gmail.com>
Date: Fri, 11 Dec 2020 19:55:45 -0700
Subject: [PATCH] pairs, memoize

---
 src/kiss/Kiss.hx    |  2 ++
 src/kiss/Prelude.hx | 30 +++++++++++++++++++++++++++++-
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/src/kiss/Kiss.hx b/src/kiss/Kiss.hx
index 0fc8a2c..d432ac5 100644
--- a/src/kiss/Kiss.hx
+++ b/src/kiss/Kiss.hx
@@ -46,6 +46,8 @@ class Kiss {
         k.defAlias("print", Symbol("Prelude.print"));
         k.defAlias("groups", Symbol("Prelude.groups"));
         k.defAlias("zip", Symbol("Prelude.zip"));
+        k.defAlias("pairs", Symbol("Prelude.pairs")); // TODO test pairs
+        k.defAlias("memoize", Symbol("Prelude.memoize")); // TODO test memoize
         k.defAlias("map", Symbol("Lambda.map"));
         k.defAlias("filter", Symbol("Lambda.filter")); // TODO use truthy as the default filter function
         k.defAlias("has", Symbol("Lambda.has"));
diff --git a/src/kiss/Prelude.hx b/src/kiss/Prelude.hx
index 2600051..304d1d4 100644
--- a/src/kiss/Prelude.hx
+++ b/src/kiss/Prelude.hx
@@ -4,6 +4,7 @@ using Std;
 
 import kiss.Operand;
 import haxe.ds.Either;
+import haxe.Constraints;
 
 /** What functions that process Lists should do when there are more elements than expected **/
 enum ExtraElementHandling {
@@ -158,7 +159,7 @@ class Prelude {
         return fullGroups;
     }
 
-    public static function zip<A, B>(a:Array<A>, b:Array<B>, extraHandling = Drop):Array<Array<Dynamic>> {
+    public static function zip(a:Array<Dynamic>, b:Array<Dynamic>, extraHandling = Drop):kiss.List<kiss.List<Dynamic>> {
         var max = Math.floor(if (a.length != b.length) {
             switch (extraHandling) {
                 case Throw:
@@ -186,6 +187,16 @@ class Prelude {
         ];
     }
 
+    public static function pairs(l:kiss.List<Dynamic>, loopAround = false):kiss.List<kiss.List<Dynamic>> {
+        var l1 = l.slice(0, l.length - 1);
+        var l2 = l.slice(1, l.length);
+        if (loopAround) {
+            l1.push(l[-1]);
+            l2.unshift(l[0]);
+        }
+        return zip(l1, l2);
+    }
+
     // Ranges with a min, exclusive max, and step size, just like Python.
     public static function range(min, max, step):Iterator<Int> {
         if (step <= 0)
@@ -224,6 +235,23 @@ class Prelude {
         }
     }
 
+    // Based on: http://old.haxe.org/doc/snip/memoize
+    public static function memoize(func:Function, ?caller:Dynamic):Function {
+        var argMap = new Map<String, Dynamic>();
+        var f = (args:Array<Dynamic>) -> {
+            var argString = args.join('|');
+            return if (argMap.exists(argString)) {
+                argMap[argString];
+            } else {
+                var ret = Reflect.callMethod(caller, func, args);
+                argMap[argString] = ret;
+                ret;
+            };
+        };
+        f = Reflect.makeVarArgs(f);
+        return f;
+    }
+
     public static function print<T>(v:T) {
         #if (sys || hxnodejs)
         Sys.println(v);