`T.raw` macro now works without needing `c.untypecheck`

1 files changed, 11 insertions, 4 deletions

diff --git a/src/main/scala/forge/package.scala b/src/main/scala/forge/package.scala
index f7635b9b..6a52d1a1 100644
--- a/src/main/scala/forge/package.scala
+++ b/src/main/scala/forge/package.scala
@@ -6,17 +6,24 @@ package object forge {
 
   val T = Target
   type T[T] = Target[T]
-  def zip[A](a: T[A]) = a
+  def zipMap[R]()(f: () => R) = T(f())
+  def zipMap[A, R](a: T[A])(f: A => R) = a.map(f)
+  def zipMap[A, B, R](a: T[A], b: T[B])(f: (A, B) => R) = zip(a, b).map(f.tupled)
+  def zipMap[A, B, C, R](a: T[A], b: T[B], c: T[C])(f: (A, B, C) => R) = zip(a, b, c).map(f.tupled)
+  def zipMap[A, B, C, D, R](a: T[A], b: T[B], c: T[C], d: T[D])(f: (A, B, C, D) => R) = zip(a, b, c, d).map(f.tupled)
+  def zipMap[A, B, C, D, E, R](a: T[A], b: T[B], c: T[C], d: T[D], e: T[E])(f: (A, B, C, D, E) => R) = zip(a, b, c, d, e).map(f.tupled)
+  def zip() = T(())
+  def zip[A](a: T[A]) = a.map(Tuple1(_))
   def zip[A, B](a: T[A], b: T[B]) = a.zip(b)
-  def zip[A, B, C](a: T[A], b: T[B], c: T[C]) = new Target[(A, B, C)]{
+  def zip[A, B, C](a: T[A], b: T[B], c: T[C]) = new T[(A, B, C)]{
     val inputs = Seq(a, b, c)
     def evaluate(args: Args) = (args[A](0), args[B](1), args[C](2))
   }
-  def zip[A, B, C, D](a: T[A], b: T[B], c: T[C], d: T[D]) = new Target[(A, B, C, D)]{
+  def zip[A, B, C, D](a: T[A], b: T[B], c: T[C], d: T[D]) = new T[(A, B, C, D)]{
     val inputs = Seq(a, b, c, d)
     def evaluate(args: Args) = (args[A](0), args[B](1), args[C](2), args[D](3))
   }
-  def zip[A, B, C, D, E](a: T[A], b: T[B], c: T[C], d: T[D], e: T[E]) = new Target[(A, B, C, D, E)]{
+  def zip[A, B, C, D, E](a: T[A], b: T[B], c: T[C], d: T[D], e: T[E]) = new T[(A, B, C, D, E)]{
     val inputs = Seq(a, b, c, d, e)
     def evaluate(args: Args) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4))
   }