Permalink
Browse files

Revert "work around for 2.10. pattern matching on KNil now requires K…

…Nil()"

This reverts commit 2f726b3.

This commit caused "java.lang.Error: typeConstructor inapplicable for <none>" when running 'sxr'
  • Loading branch information...
1 parent b48c087 commit 2bb2aed1f63ab9920b516f06269a9b2d109293e2 @harrah committed Mar 18, 2012
Showing with 27 additions and 29 deletions.
  1. +14 −14 main/Structure.scala
  2. +1 −1 tasks/standard/System.scala
  3. +11 −13 util/collection/KList.scala
  4. +1 −1 util/collection/Types.scala
View
@@ -373,103 +373,103 @@ object Scoped
type Fun[M[_],Ret] = (M[A],M[B]) => Ret
def identityMap = map(mkTuple2)
protected def convertH[R](z: (A,B) => R) = hf2(z)
- protected def convertK[M[_],R](f: (M[A],M[B]) => R) = { case a :^: b :^: KNil() => f(a,b) }
+ protected def convertK[M[_],R](f: (M[A],M[B]) => R) = { case a :^: b :^: KNil => f(a,b) }
}
final class RichTaskable3[A,B,C](t3: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C])) extends RichTaskables(k3(t3))
{
type Fun[M[_],Ret] = (M[A],M[B],M[C]) => Ret
def identityMap = map(mkTuple3)
protected def convertH[R](z: Fun[Id,R]) = hf3(z)
- protected def convertK[M[_],R](f: Fun[M,R]) = { case a :^: b :^: c :^: KNil() => f(a,b,c) }
+ protected def convertK[M[_],R](f: Fun[M,R]) = { case a :^: b :^: c :^: KNil => f(a,b,c) }
}
final class RichTaskable4[A,B,C,D](t4: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D])) extends RichTaskables(k4(t4))
{
type Fun[M[_],Ret] = (M[A],M[B],M[C],M[D]) => Ret
def identityMap = map(mkTuple4)
protected def convertH[R](z: Fun[Id,R]) = hf4(z)
- protected def convertK[M[_],R](f: Fun[M,R]) = { case a :^: b :^: c :^: d :^: KNil() => f(a,b,c,d) }
+ protected def convertK[M[_],R](f: Fun[M,R]) = { case a :^: b :^: c :^: d :^: KNil => f(a,b,c,d) }
}
final class RichTaskable5[A,B,C,D,E](t5: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E])) extends RichTaskables(k5(t5))
{
type Fun[M[_],Ret] = (M[A],M[B],M[C],M[D],M[E]) => Ret
def identityMap = map(mkTuple5)
protected def convertH[R](z: Fun[Id,R]) = hf5(z)
- protected def convertK[M[_],R](f: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: KNil() => f(a,b,c,d,e) }
+ protected def convertK[M[_],R](f: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: KNil => f(a,b,c,d,e) }
}
final class RichTaskable6[A,B,C,D,E,F](t6: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F])) extends RichTaskables(k6(t6))
{
type Fun[M[_],Ret] = (M[A],M[B],M[C],M[D],M[E],M[F]) => Ret
def identityMap = map(mkTuple6)
protected def convertH[R](z: Fun[Id,R]) = hf6(z)
- protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: KNil() => z(a,b,c,d,e,f) }
+ protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: KNil => z(a,b,c,d,e,f) }
}
final class RichTaskable7[A,B,C,D,E,F,G](t7: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G])) extends RichTaskables(k7(t7))
{
type Fun[M[_],Ret] = (M[A],M[B],M[C],M[D],M[E],M[F],M[G]) => Ret
def identityMap = map(mkTuple7)
protected def convertH[R](z: Fun[Id,R]) = hf7(z)
- protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: KNil() => z(a,b,c,d,e,f,g) }
+ protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: KNil => z(a,b,c,d,e,f,g) }
}
final class RichTaskable8[A,B,C,D,E,F,G,H](t8: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H])) extends RichTaskables(k8(t8))
{
type Fun[M[_],Ret] = (M[A],M[B],M[C],M[D],M[E],M[F],M[G],M[H]) => Ret
def identityMap = map(mkTuple8)
protected def convertH[R](z: Fun[Id,R]) = hf8(z)
- protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: KNil() => z(a,b,c,d,e,f,g,h) }
+ protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: KNil => z(a,b,c,d,e,f,g,h) }
}
final class RichTaskable9[A,B,C,D,E,F,G,H,I](t9: (ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I])) extends RichTaskables(k9(t9))
{
type Fun[M[_],Ret] = (M[A],M[B],M[C],M[D],M[E],M[F],M[G],M[H],M[I]) => Ret
def identityMap = map(mkTuple9)
protected def convertH[R](z: Fun[Id,R]) = hf9(z)
- protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: i :^: KNil() => z(a,b,c,d,e,f,g,h,i) }
+ protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: i :^: KNil => z(a,b,c,d,e,f,g,h,i) }
}
final class RichTaskable10[A,B,C,D,E,F,G,H,I,J](t10: ((ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J]))) extends RichTaskables(k10(t10))
{
type Fun[M[_],Ret] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J]) => Ret
def identityMap = map(mkTuple10)
protected def convertH[R](z: Fun[Id,R]) = hf10(z)
- protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: i :^: j :^: KNil() => z(a,b,c,d,e,f,g,h,i,j) }
+ protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: i :^: j :^: KNil => z(a,b,c,d,e,f,g,h,i,j) }
}
final class RichTaskable11[A,B,C,D,E,F,G,H,I,J,K](t11: ((ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K]))) extends RichTaskables(k11(t11))
{
type Fun[M[_],Ret] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K]) => Ret
def identityMap = map(mkTuple11)
protected def convertH[R](z: Fun[Id,R]) = hf11(z)
- protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: i :^: j :^: k :^: KNil() => z(a,b,c,d,e,f,g,h,i,j,k) }
+ protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: i :^: j :^: k :^: KNil => z(a,b,c,d,e,f,g,h,i,j,k) }
}
final class RichTaskable12[A,B,C,D,E,F,G,H,I,J,K,L](t12: ((ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K], ScopedTaskable[L]))) extends RichTaskables(k12(t12))
{
type Fun[M[_],Ret] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K], M[L]) => Ret
def identityMap = map(mkTuple12)
protected def convertH[R](z: Fun[Id,R]) = hf12(z)
- protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: i :^: j :^: k :^: l :^: KNil() => z(a,b,c,d,e,f,g,h,i,j,k,l) }
+ protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: i :^: j :^: k :^: l :^: KNil => z(a,b,c,d,e,f,g,h,i,j,k,l) }
}
final class RichTaskable13[A,B,C,D,E,F,G,H,I,J,K,L,N](t13: ((ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K], ScopedTaskable[L], ScopedTaskable[N]))) extends RichTaskables(k13(t13))
{
type Fun[M[_],Ret] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K], M[L], M[N]) => Ret
def identityMap = map(mkTuple13)
protected def convertH[R](z: Fun[Id,R]) = hf13(z)
- protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: i :^: j :^: k :^: l :^: n :^: KNil() => z(a,b,c,d,e,f,g,h,i,j,k,l,n) }
+ protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: i :^: j :^: k :^: l :^: n :^: KNil => z(a,b,c,d,e,f,g,h,i,j,k,l,n) }
}
final class RichTaskable14[A,B,C,D,E,F,G,H,I,J,K,L,N,O](t14: ((ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K], ScopedTaskable[L], ScopedTaskable[N], ScopedTaskable[O]))) extends RichTaskables(k14(t14))
{
type Fun[M[_],Ret] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K], M[L], M[N], M[O]) => Ret
def identityMap = map(mkTuple14)
protected def convertH[R](z: Fun[Id,R]) = hf14(z)
- protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: i :^: j :^: k :^: l :^: n :^: o :^: KNil() => z(a,b,c,d,e,f,g,h,i,j,k,l,n,o) }
+ protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: i :^: j :^: k :^: l :^: n :^: o :^: KNil => z(a,b,c,d,e,f,g,h,i,j,k,l,n,o) }
}
final class RichTaskable15[A,B,C,D,E,F,G,H,I,J,K,L,N,O,P](t15: ((ScopedTaskable[A], ScopedTaskable[B], ScopedTaskable[C], ScopedTaskable[D], ScopedTaskable[E], ScopedTaskable[F], ScopedTaskable[G], ScopedTaskable[H], ScopedTaskable[I], ScopedTaskable[J], ScopedTaskable[K], ScopedTaskable[L], ScopedTaskable[N], ScopedTaskable[O], ScopedTaskable[P]))) extends RichTaskables(k15(t15))
{
type Fun[M[_],Ret] = (M[A], M[B], M[C], M[D], M[E], M[F], M[G], M[H], M[I], M[J], M[K], M[L], M[N], M[O], M[P]) => Ret
def identityMap = map(mkTuple15)
protected def convertH[R](z: Fun[Id,R]) = hf15(z)
- protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: i :^: j :^: k :^: l :^: n :^: o :^: p :^: KNil() => z(a,b,c,d,e,f,g,h,i,j,k,l,n,o,p) }
+ protected def convertK[M[_],R](z: Fun[M,R]) = { case a :^: b :^: c :^: d :^: e :^: f :^: g :^: h :^: i :^: j :^: k :^: l :^: n :^: o :^: p :^: KNil => z(a,b,c,d,e,f,g,h,i,j,k,l,n,o,p) }
}
// this doesn't actually work for mixed KLists because the compiler crashes trying to infer the bound when constructing the KList
@@ -54,7 +54,7 @@ object Transform
def uniform[T, D](tasks: Seq[Task[D]])(f: Seq[Result[D]] => Either[Task[T], T]): Node[Task, T] = new Node[Task, T] {
type Mixed = HNil
- val mixedIn = new KNil[Task]
+ val mixedIn = KNil
type Uniform = D
val uniformIn = tasks
def work(mixed: Results[HNil], uniform: Seq[Result[Uniform]]) = f(uniform)
@@ -13,7 +13,7 @@ import Types._
* For background, see
* http://apocalisp.wordpress.com/2010/11/01/type-level-programming-in-scala-part-8a-klist%C2%A0motivation/
*/
-sealed trait KList[M[_], HL <: HList]
+sealed trait KList[+M[_], HL <: HList]
{
type Raw = HL
/** Transform to the underlying HList type.*/
@@ -33,12 +33,12 @@ trait KFold[M[_],P[_ <: HList]]
def knil: P[HNil]
}
-final case class KCons[H, T <: HList, M[_]](head: M[H], tail: KList[M,T]) extends KList[M, H :+: T]
+final case class KCons[H, T <: HList, +M[_]](head: M[H], tail: KList[M,T]) extends KList[M, H :+: T]
{
def down(implicit f: M ~> Id) = HCons(f(head), tail down f)
def transform[N[_]](f: M ~> N) = KCons( f(head), tail transform f )
// prepend
- def :^: [G](g: M[G]) = KCons(g, this)
+ def :^: [N[X] >: M[X], G](g: N[G]) = KCons(g, this)
def toList = head :: tail.toList
def combine[N[X] >: M[X]]: (H :+: T)#Wrap[N] = HCons(head, tail.combine)
@@ -48,31 +48,29 @@ final case class KCons[H, T <: HList, M[_]](head: M[H], tail: KList[M,T]) extend
def foldr[P[_ <: HList],N[X] >: M[X]](f: KFold[N,P]) = f.kcons(head, tail foldr f)
}
-sealed case class KNil[M[_]]() extends KList[M, HNil]
+sealed class KNil extends KList[Nothing, HNil]
{
- def down(implicit f: M ~> Id) = HNil
- def transform[N[_]](f: M ~> N) = new KNil[N]
+ def down(implicit f: Nothing ~> Id) = HNil
+ def transform[N[_]](f: Nothing ~> N) = KNil
+ def :^: [M[_], H](h: M[H]) = KCons(h, this)
def toList = Nil
def combine[N[X]] = HNil
override def foldr[P[_ <: HList],N[_]](f: KFold[N,P]) = f.knil
override def toString = "KNil"
}
-object KNil
-{
- def :^: [M[_], H](h: M[H]) = KCons(h, new KNil[M])
-}
+object KNil extends KNil
+
object KList
{
- implicit def convert[M[_]](k: KNil.type): KNil[M] = KNil()
// nicer alias for pattern matching
val :^: = KCons
- def fromList[M[_]](s: Seq[M[_]]): KList[M, _ <: HList] = if(s.isEmpty) KNil() else KCons(s.head, fromList(s.tail))
+ def fromList[M[_]](s: Seq[M[_]]): KList[M, _ <: HList] = if(s.isEmpty) KNil else KCons(s.head, fromList(s.tail))
// haven't found a way to convince scalac that KList[M, H :+: T] implies KCons[H,T,M]
// Therefore, this method exists to put the cast in one location.
implicit def kcons[H, T <: HList, M[_]](kl: KList[M, H :+: T]): KCons[H,T,M] =
kl.asInstanceOf[KCons[H,T,M]]
// haven't need this, but for symmetry with kcons:
- implicit def knil[M[_]](kl: KList[M, HNil]): KNil[M] = KNil()
+ implicit def knil[M[_]](kl: KList[M, HNil]): KNil = KNil
}
@@ -7,7 +7,7 @@ object Types extends Types
{
implicit def hconsToK[M[_], H, T <: HList](h: M[H] :+: T)(implicit mt: T => KList[M, T]): KList[M, H :+: T] =
KCons[H, T, M](h.head, mt(h.tail) )
- implicit def hnilToK[M[_]](hnil: HNil): KNil[M] = KNil()
+ implicit def hnilToK(hnil: HNil): KNil = KNil
}
trait Types extends TypeFunctions

0 comments on commit 2bb2aed

Please sign in to comment.