#46

assira.core/src/main/java/net/ranides/assira/collection/query/CQuery.java

@@ -178,9 +178,9 @@ public interface CQuery<T> extends Iterable<T> {
     
     boolean matchNone(Predicate<? super T> predicate);
 
-    <R> R apply(Function<CQuery<T>, R> function);
+    <R> R apply(Function<? extends CQuery<? super T>, R> function);
 
-    boolean apply(Predicate<CQuery<T>> function);
+    boolean apply(Predicate<? extends CQuery<? super T>> function);
 
     class WrapBuilder<F> {
 

assira.core/src/main/java/net/ranides/assira/collection/query/CQueryAbstract.java

@@ -16,6 +16,7 @@ import net.ranides.assira.collection.sets.OpenSet;
 import net.ranides.assira.functional.Consumers.EachConsumer;
 import net.ranides.assira.functional.FunctionUtils;
 import net.ranides.assira.functional.Functions.EachFunction;
+import net.ranides.assira.functional.PredicateUtils;
 import net.ranides.assira.functional.Predicates.EachPredicate;
 import net.ranides.assira.functional.special.Fold;
 import net.ranides.assira.generic.CompareUtils;
@@ -376,13 +377,13 @@ public abstract class CQueryAbstract<T> implements CQuery<T> {
     }
 
     @Override
-    public <R> R apply(Function<CQuery<T>, R> function) {
-        return function.apply(this);
+    public <R> R apply(Function<? extends CQuery<? super T>, R> function) {
+        return (R)FunctionUtils.raw(function).apply(this);
     }
 
     @Override
-    public boolean apply(Predicate<CQuery<T>> function) {
-        return function.test(this);
+    public boolean apply(Predicate<? extends CQuery<? super T>> predicate) {
+        return PredicateUtils.raw(predicate).test(this);
     }
 
     protected static class CQCollection<T> extends CQueryAbstract<T> {

assira.core/src/main/java/net/ranides/assira/collection/query/CQueryPredicate.java

@@ -0,0 +1,6 @@
+package net.ranides.assira.collection.query;
+
+import java.util.function.Predicate;
+
+public interface CQueryPredicate<T> extends Predicate<CQuery<T>> {
+}

assira.core/src/main/java/net/ranides/assira/functional/PredicateUtils.java

@@ -0,0 +1,50 @@
+package net.ranides.assira.functional;
+
+import lombok.experimental.UtilityClass;
+
+import net.ranides.assira.functional.Predicates.EachPredicate;
+import net.ranides.assira.functional.Predicates.Predicate0;
+import net.ranides.assira.functional.Predicates.Predicate1;
+import net.ranides.assira.functional.Predicates.Predicate2;
+import net.ranides.assira.functional.Predicates.Predicate3;
+import net.ranides.assira.functional.Predicates.Predicate4;
+
+import java.util.Optional;
+import java.util.function.BiFunction;
+import java.util.function.BiPredicate;
+import java.util.function.BooleanSupplier;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+@UtilityClass
+public class PredicateUtils {
+
+    public static Predicate0 raw(BooleanSupplier predicate) {
+        return predicate::getAsBoolean;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <R> Predicate1<R> raw(Predicate<?> predicate) {
+        Predicate<R> ready = Predicate.class.cast(predicate);
+        return ready::test;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T, U> Predicate2<T, U> raw(BiPredicate<?, ?> predicate) {
+        BiPredicate<T, U> ready = BiPredicate.class.cast(predicate);
+        return ready::test;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A, B, C> Predicate3<A, B, C> raw(Predicate3<?, ?, ?> predicate) {
+        return Predicate3.class.cast(predicate);
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A, B, C, D> Predicate4<A, B, C, D> raw(Predicate4<?, ?, ?, ?> function) {
+        return Predicate4.class.cast(function);
+    }
+
+}

assira.core/src/test/java/net/ranides/assira/collection/query/CQueryFunctionTest.java

@@ -7,6 +7,7 @@ import org.junit.Test;
 import net.ranides.assira.collection.IntComparator;
 
 import java.util.Arrays;
+import java.util.List;
 import java.util.function.Function;
 
 import static org.junit.Assert.assertEquals;
@@ -22,8 +23,41 @@ public class CQueryFunctionTest {
             .sort(IntComparator.DESC);
 
         CQuery<String> input = CQuery.from().values("1,2,8", "o,t,h,er", "6 9 4", "q", "7;3");
+        List<Integer> list1 = input.apply(filter).list();
+        assertEquals(Arrays.asList(9,8,7,6,4,3,2,1), list1);
+
+        List<Integer> list2 = CQuery.from()
+            .values("hello", "world", "end", "here", "!")
+            .map(String::length)
+            .map(String::valueOf)
+            .apply(filter)
+            .list();
+        assertEquals(Arrays.asList(5, 5, 4, 3, 1), list2);
+    }
+
+    @Test
+    public void generic() {
+        CQueryFunction<CharSequence, Integer> f1 = CQueryFunction.<CharSequence>prepare().map(s -> Integer.valueOf(s.toString()));
+        CQueryFunction<Text, Integer> f2 = CQueryFunction.<Text>prepare().map(s -> Integer.valueOf(s.toString()));
+        CQueryFunction<TextValue, Integer> f3 = CQueryFunction.<TextValue>prepare().map(s -> Integer.valueOf(s.text.toString()));
+
+        CQuery<CharSequence> s1 = CQuery.from().values("1", "2", "5", "8");
+        CQuery<Text> s2 = CQuery.from().values("1", "2", "5", "8").map(TextValue::new);
+        CQuery<TextValue> s3 = CQuery.from().values("1", "2", "5", "8").map(TextValue::new);
+
+        List<Integer> expect = Arrays.asList(5, 5, 4, 3, 1);
+
+        assertEquals(expect, s1.apply(f1));
+//        assertEquals(expect, s1.apply(f2)); // compilation error expected
+//        assertEquals(expect, s1.apply(f3)); // compilation error expected
+
+        assertEquals(expect, s2.apply(f1));
+        assertEquals(expect, s2.apply(f2));
+//        assertEquals(expect, s2.apply(f3)); // compilation error expected
 
-        assertEquals(Arrays.asList(9,8,7,6,4,3,2,1), input.apply(filter).list() );
+        assertEquals(expect, s3.apply(f1));
+        assertEquals(expect, s3.apply(f2));
+        assertEquals(expect, s3.apply(f3));
     }
 
     private interface Text extends CharSequence {