From 9ff78407129e7a1fbc96848ca09a5f28cf7080ed Mon Sep 17 00:00:00 2001
From: Michael Williamson <mike@zwobble.org>
Date: Thu, 31 Mar 2016 22:19:02 +0100
Subject: Improve generic support in the interpreter

---
 .../org/zwobble/couscous/util/ExtraIterables.java  | 54 ++++++++++++++++++++++
 .../java/org/zwobble/couscous/util/ExtraMaps.java  | 16 ++++++-
 2 files changed, 69 insertions(+), 1 deletion(-)

(limited to 'src/main/java/org/zwobble/couscous/util')

diff --git a/src/main/java/org/zwobble/couscous/util/ExtraIterables.java b/src/main/java/org/zwobble/couscous/util/ExtraIterables.java
index 9cdb0f0..1fd9fca 100644
--- a/src/main/java/org/zwobble/couscous/util/ExtraIterables.java
+++ b/src/main/java/org/zwobble/couscous/util/ExtraIterables.java
@@ -1,6 +1,7 @@
 package org.zwobble.couscous.util;
 
 import java.util.Iterator;
+import java.util.function.BiFunction;
 
 public class ExtraIterables {
     private ExtraIterables() {}
@@ -15,4 +16,57 @@ public class ExtraIterables {
             throw new RuntimeException("Iterables not of same length");
         }
     }
+
+    public static <T1, T2, R> Iterable<R> map(Iterable<T1> iterable1, Iterable<T2> iterable2, BiFunction<T1, T2, R> function) {
+        return new Iterable<R>() {
+            @Override
+            public Iterator<R> iterator() {
+                Iterator<T1> iterator1 = iterable1.iterator();
+                Iterator<T2> iterator2 = iterable2.iterator();
+                return map(iterator1, iterator2, function);
+            }
+        };
+    }
+
+    private static <R, T1, T2> Iterator<R> map(Iterator<T1> iterator1, Iterator<T2> iterator2, BiFunction<T1, T2, R> function) {
+        return new Iterator<R>() {
+            @Override
+            public boolean hasNext() {
+                return iterator1.hasNext() && iterator2.hasNext();
+            }
+
+            @Override
+            public R next() {
+                return function.apply(iterator1.next(), iterator2.next());
+            }
+        };
+    }
+
+    public static <T> Iterable<T> cast(Class<T> type, Iterable<?> iterable) {
+        return new Iterable<T>() {
+            @Override
+            public Iterator<T> iterator() {
+                return cast(type, iterable.iterator());
+            }
+        };
+    }
+
+    private static <T> Iterator<T> cast(Class<T> type, Iterator<?> iterator) {
+        return new Iterator<T>() {
+            @Override
+            public boolean hasNext() {
+                return iterator.hasNext();
+            }
+
+            @Override
+            public T next() {
+                Object next = iterator.next();
+                if (type.isInstance(next)) {
+                    return (T) next;
+                } else {
+                    throw new ClassCastException();
+                }
+            }
+        };
+    }
 }
diff --git a/src/main/java/org/zwobble/couscous/util/ExtraMaps.java b/src/main/java/org/zwobble/couscous/util/ExtraMaps.java
index 55829cf..f25f06f 100644
--- a/src/main/java/org/zwobble/couscous/util/ExtraMaps.java
+++ b/src/main/java/org/zwobble/couscous/util/ExtraMaps.java
@@ -28,6 +28,16 @@ public class ExtraMaps {
         return Optional.ofNullable(map.get(key));
     }
 
+    public static <T, K, V> Map<K, V> toMap(Iterable<K> keys, Iterable<V> values) {
+        return toMap(ExtraIterables.map(keys, values, ExtraMaps::entry));
+    }
+
+    public static <T, K, V> Map<K, V> toMap(Iterable<Map.Entry<K, V>> entries) {
+        ImmutableMap.Builder<K, V> builder = ImmutableMap.builder();
+        entries.forEach(builder::put);
+        return builder.build();
+    }
+
     public static <T, K, V> Map<K, V> toMap(Iterable<T> iterable, Function<T, Map.Entry<K, V>> function) {
         ImmutableMap.Builder<K, V> builder = ImmutableMap.builder();
 
@@ -39,6 +49,10 @@ public class ExtraMaps {
     }
 
     public static <T, K> Map<K, T> toMapWithKeys(Iterable<T> iterable, Function<T, K> function) {
-        return toMap(iterable, value -> new AbstractMap.SimpleImmutableEntry<K, T>(function.apply(value), value));
+        return toMap(iterable, value -> entry(function.apply(value), value));
+    }
+
+    public static <K, V> Map.Entry<K, V> entry(K key, V value) {
+        return new AbstractMap.SimpleImmutableEntry<>(key, value);
     }
 }
-- 
cgit v1.2.3