Add ideas as comments

Treiblesschorle · ctrueden · commit d090bba95a31 · 2019-04-18T12:02:50.000-05:00
diff --git a/src/main/java/org/scijava/ops/math/Add.java b/src/main/java/org/scijava/ops/math/Add.java
@@ -64,6 +64,26 @@ public Iterable<Double> apply(Iterable<Double> i1, Iterable<Double> i2) {
 		}
 
 	}
+
+	// Do we want to have generic types ops?
+	// Would be cool if someone is looking for an op that expects double and we give him the generic op which works on all numbers.
+	// Currently, the op calss itself can't have type arguments (possible bug in Types.satisfies) however it works with wildcards 
+	// when there is only an upper bound needed. See below.
+	
+//	@Plugin(type = MathAddOp.class, priority = Priority.HIGH)
+//	@Parameter(key = "iter1")
+//	@Parameter(key = "iter2")
+//	@Parameter(key = "resultArray", type = ItemIO.OUTPUT)
+//	public static class MathPointwiseAddIterablesFunction
+//			implements MathAddOp, BiFunction<Iterable<? extends Number>, Iterable<? extends Number>, Iterable<Double>> {
+//		@Override
+//		public Iterable<Double> apply(Iterable<? extends Number> i1, Iterable<? extends Number> i2) {
+//			Stream<? extends Number> s1 = Streams.stream(i1);
+//			Stream<? extends Number> s2 = Streams.stream(i2);
+//			return () -> Streams.zip(s1, s2, (e1, e2) -> e1.doubleValue() + e2.doubleValue()).iterator();
+//		}
+//	}
+
 	// --------- Computers ---------
 			
 	@Plugin(type = MathAddOp.class)
diff --git a/src/main/java/org/scijava/ops/util/Functions.java b/src/main/java/org/scijava/ops/util/Functions.java
@@ -30,6 +30,15 @@ public static <I, O> Function<I, O> unary(final OpService ops, final Class<? ext
 	public static <I1, I2, O> BiFunction<I1, I2, O> binary(final OpService ops, final Class<? extends Op> opClass,
 			final Nil<I1> input1Type, final Nil<I2> input2Type, final Nil<O> outputType,
 			final Object... secondaryArgs) {
+
+		// Parameterize special type corresponding to this method with in/out types. Then we do not have to specify them
+		// explicitly anymore? Also, outside of this 'Functions' convenience thing, one could just search for the deeply
+		// typed (having all type variables bound to a specific type) special type. As we are using Types.satisfies, this 
+		// should be type safe. Hence, we could allow to not specify the ins/outs if the special type does not contain
+		// type variables.
+		// ParameterizedType parameterizedBiFuncType = Types.parameterize(BiFunction.class,
+		//	new Type[] { input1Type.getType(), input2Type.getType(), outputType.getType() });
+
 		return ops.findOp( //
 				opClass, //
 				new Nil<BiFunction<I1, I2, O>>() {
