new: ListUtils/IntListUtils #map(projection)

new: CoIntFunction
new: ProjectionIntFunction

assira/src/main/java/net/ranides/assira/collection/lists/IntListUtils.java

@@ -15,6 +15,8 @@ import java.util.function.IntPredicate;
 import java.util.function.IntUnaryOperator;
 import net.ranides.assira.collection.IntCollectionUtils;
 import net.ranides.assira.collection.iterators.IntListIterator;
+import net.ranides.assira.functional.IntProjectionFunction;
+import net.ranides.assira.functional.ProjectionIntFunction;
 
 /**
  *
@@ -111,6 +113,66 @@ public final class IntListUtils {
 			}
 		};
     }
+    
+    public static <T> List<T> map(IntList values, IntProjectionFunction<T> function) {
+		return new VirtualList<T>() {
+			@Override
+			public T get(int index) {
+				return function.apply(values.getInt(index));
+			}
+
+			@Override
+			public int size() {
+				return values.size();
+			}
+
+            @Override
+            public T set(int index, T element) {
+                return function.apply(values.set(index, function.invertInt(element)));
+            }
+
+            @Override
+            public void add(int index, T element) {
+                values.add(index, function.invertInt(element));
+            }
+
+            @Override
+            public T remove(int index) {
+                return function.apply(values.removeInt(index));
+            }
+            
+		};
+    }
+    
+    public static <R> IntList map(List<R> values, ProjectionIntFunction<R> function) {
+		return new AIntList() {
+			@Override
+			public int getInt(int index) {
+				return function.applyInt(values.get(index));
+			}
+
+			@Override
+			public int size() {
+				return values.size();
+			}
+
+            @Override
+            public int set(int index, int element) {
+                return function.applyInt(values.set(index, function.invert(element)));
+            }
+
+            @Override
+            public void add(int index, int element) {
+                values.add(index, function.invert(element));
+            }
+
+            @Override
+            public int removeInt(int index) {
+                return function.applyInt(values.remove(index));
+            }
+            
+		};
+    }
 
     public static IntList produce(int size, IntUnaryOperator function) {
         return new IntVirtualList() {

assira/src/main/java/net/ranides/assira/collection/lists/ListUtils.java

@@ -7,7 +7,6 @@
 
 package net.ranides.assira.collection.lists;
 
-import java.util.AbstractList;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.function.Function;
@@ -15,6 +14,7 @@ import java.util.function.IntFunction;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import net.ranides.assira.collection.CollectionUtils;
+import net.ranides.assira.functional.ProjectionFunction;
 
 /**
  *
@@ -63,7 +63,7 @@ public final class ListUtils {
 	}
 	
 	public static <S,T> List<T> map(List<S> values, Function<S,T> function) {
-		return new AbstractList<T>() {
+		return new VirtualList<T>() {
 			@Override
 			public T get(int index) {
 				return function.apply(values.get(index));
@@ -75,6 +75,37 @@ public final class ListUtils {
 			}
 		};
     }
+    
+    public static <S,T> List<T> map(List<S> values, ProjectionFunction<S,T> function) {
+        return new VirtualList<T>() {
+			@Override
+			public T get(int index) {
+				return function.apply(values.get(index));
+			}
+
+			@Override
+			public int size() {
+				return values.size();
+			}
+
+            @Override
+            public T set(int index, T element) {
+                S prev = values.set(index, function.invert(element));
+                return null==prev ? null : function.apply(prev);
+            }
+
+            @Override
+            public void add(int index, T element) {
+                values.add(index, function.invert(element));
+            }
+
+            @Override
+            public T remove(int index) {
+                return function.apply(values.remove(index));
+            }
+            
+		};
+    }
 
     public static <Q> List<Q> produce(int size, IntFunction<Q> function) {
         return new VirtualList<Q>() {

assira/src/main/java/net/ranides/assira/functional/CoIntFunction.java

@@ -0,0 +1,35 @@
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.functional;
+
+import java.util.function.IntFunction;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public interface CoIntFunction<T> extends CoFunction<T, Integer> {
+
+    @Override
+    default T invert(Integer value) {
+        return invert(value.intValue());
+    }
+    
+    T invert(int value);
+    
+    static CoIntFunction<Integer> identity() {
+        return (v) -> v;
+    }
+    
+    static <T> CoIntFunction<T> inverted(IntFunction<T> f) {
+        return (v) -> f.apply(v);
+    }
+    
+    static <T> IntFunction<T> inverted(CoIntFunction<T> f) {
+        return (v) -> f.invert(v);
+    }
+}

assira/src/main/java/net/ranides/assira/functional/IntCoFunction.java

@@ -7,7 +7,6 @@
 package net.ranides.assira.functional;
 
 import java.util.function.Function;
-import java.util.function.IntFunction;
 
 /**
  *

assira/src/main/java/net/ranides/assira/functional/ProjectionIntFunction.java

@@ -0,0 +1,42 @@
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.functional;
+
+import java.util.function.Function;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public interface ProjectionIntFunction<T> extends Function<T, Integer>, CoIntFunction<T> {
+
+    @Override
+    default Integer apply(T element) {
+        return applyInt(element);
+    }
+    
+    int applyInt(T element);
+    
+    static ProjectionIntFunction<Integer> identity() {
+        return produce((v)->v, (v)->v);
+    }
+    
+    static <T> ProjectionIntFunction<T> produce(Function<T, Integer> f, CoIntFunction<T> cf) {
+        return new ProjectionIntFunction<T>() {
+            @Override
+            public int applyInt(T value) {
+                return f.apply(value);
+            }
+
+            @Override
+            public T invert(int value) {
+                return cf.invert(value);
+            }
+        };
+    }
+    
+}