隐式解决失败？
我一直在研究冈崎密集二进制数字系统的“无形风格”实现。 它只是一个类型级别的链接列表; 一种二进制Digit的HList 。 我已经完成了我的操作的初稿，其中包括您对自然数字所期望的标准数学运算。 现在我才意识到编码中存在一个大问题。 我如何修改Induction示例中的隐式分辨率？ 随意将整个代码片段粘贴到REPL中。 在这个例子中，无形的唯一依赖是DepFn1和DepFn2 。
import shapeless.{ DepFn1, DepFn2 }
sealed trait Digit
case object Zero extends Digit
case object One extends Digit
sealed trait Dense { type N <: Dense }
final case class ::[+H <: Digit, +T <: Dense](digit: H, tail: T) extends Dense {
type N = digit.type :: tail.N
}
sealed trait DNil extends Dense {
type N = DNil
}
case object DNil extends DNil
/* ops */
trait IsDCons[N <: Dense] {
type H <: Digit
type T <: Dense
def digit(n: N): H
def tail(n: N): T
}
object IsDCons {
type Aux[N <: Dense, H0 <: Digit, T0 <: Dense] = IsDCons[N] {
type H = H0
type T = T0
}
def apply[N <: Dense](implicit ev: IsDCons[N]): Aux[N, ev.H, ev.T] = ev
implicit def isDCons[H0 <: Digit, T0 <: Dense]: Aux[H0 :: T0, H0, T0] =
new IsDCons[H0 :: T0] {
type H = H0
type T = T0
def digit(n: H0 :: T0): H = n.digit
def tail(n: H0 :: T0): T = n.tail
}
}
// Disallows Leading Zeros
trait SafeCons[H <: Digit, T <: Dense] extends DepFn2[H, T] { type Out <: Dense }
trait LowPrioritySafeCons {
type Aux[H <: Digit, T <: Dense, Out0 <: Dense] = SafeCons[H, T] { type Out = Out0 }
implicit def sc1[H <: Digit, T <: Dense]: Aux[H, T, H :: T] =
new SafeCons[H, T] {
type Out = H :: T
def apply(h: H, t: T) = h :: t
}
}
object SafeCons extends LowPrioritySafeCons {
implicit val sc0: Aux[Zero.type, DNil, DNil] =
new SafeCons[Zero.type, DNil] {
type Out = DNil
def apply(h: Zero.type, t: DNil) = DNil
}
}
trait ShiftLeft[N <: Dense] extends DepFn1[N] { type Out <: Dense }
object ShiftLeft {
type Aux[N <: Dense, Out0 <: Dense] = ShiftLeft[N] { type Out = Out0 }
implicit def sl1[T <: Dense](implicit sc: SafeCons[Zero.type, T]): Aux[T, sc.Out] =
new ShiftLeft[T] {
type Out = sc.Out
def apply(n: T) = Zero safe_:: n
}
}
trait Succ[N <: Dense] extends DepFn1[N] { type Out <: Dense }
object Succ {
type Aux[N <: Dense, Out0 <: Dense] = Succ[N] { type Out = Out0 }
def apply[N <: Dense](implicit succ: Succ[N]): Aux[N, succ.Out] = succ
implicit val succ0: Aux[DNil, One.type :: DNil] =
new Succ[DNil] {
type Out = One.type :: DNil
def apply(DNil: DNil) = One :: DNil
}
implicit def succ1[T <: Dense]: Aux[Zero.type :: T, One.type :: T] =
new Succ[Zero.type :: T] {
type Out = One.type :: T
def apply(n: Zero.type :: T) = One :: n.tail
}
implicit def succ2[T <: Dense, S <: Dense]
(implicit ev: Aux[T, S], sl: ShiftLeft[S]): Aux[One.type :: T, sl.Out] =
new Succ[One.type :: T] {
type Out = sl.Out
def apply(n: One.type :: T) = n.tail.succ.shiftLeft
}
}
/* syntax */
val Cons = ::
implicit class DenseOps[N <: Dense](val n: N) extends AnyVal {
def ::[H <: Digit](h: H): H :: N = Cons(h, n)
def safe_::[H <: Digit](h: H)(implicit sc: SafeCons[H, N]): sc.Out = sc(h, n)
def succ(implicit s: Succ[N]): s.Out = s(n)
def digit(implicit c: IsDCons[N]): c.H = c.digit(n)
def tail(implicit c: IsDCons[N]): c.T = c.tail(n)
def shiftLeft(implicit sl: ShiftLeft[N]): sl.Out = sl(n)
}
/* aliases */
type _0 = DNil
val _0: _0 = DNil
val _1 = _0.succ
type _1 = _1.N
val _2 = _1.succ
type _2 = _2.N
/* test */
trait Induction[A <: Dense]
object Induction{
def apply[A <: Dense](a: A)(implicit r: Induction[A]) = r
implicit val r0 = new Induction[_0] {}
implicit def r1[A <: Dense](implicit r: Induction[A], s: Succ[A]) =
new Induction[s.Out]{}
}
Induction(_0)
Induction(_1)
Induction(_2) // <- Could not find implicit value for parameter r...
这是问题跟进的链接
这是一个有点不完整的答案，但希望它会让你失去...
我认为你的问题在这里是r1的定义，
object Induction{
def apply[A <: Dense](a: A)(implicit r: Induction[A]) = r
implicit val r0 = new Induction[_0] {}
implicit def r1[A <: Dense](implicit r: Induction[A], s: Succ[A]) =
new Induction[s.Out]{}
}
当你要求Induction(_2)你希望r1适用，并且s.Out被固定为_2 ，并且这将在r1的隐式参数块中推动从右向左的推理过程。
不幸的是，这不会发生。 首先， s.Out不会被固定为_2因为它不是一个类型变量。 所以你至少不得不重写这个，因为，
implicit def r1[A <: Dense, SO <: Dense]
(implicit r: Induction[A], s: Succ.Aux[A, SO]): Induction[SO] =
new Induction[SO]{}
对于r1甚至是适用的。 ，这不会让你更进一步，但是因为SO只是约束为等于类型的成员Out的s ...它没有起到挑选一个角色Succ实例s 。 我们不能从另一端取得任何进展，因为在这一点上，就类型分析而言， A是完全不确定的。
所以恐怕你不得不重新考虑这一点。 我认为你最好的方法是定义一个Pred操作符，它可以让你定义这些行的内容，
implicit def r1[S <: Dense, PO <: Dense]
(implicit p: Pred.Aux[S, PO], r: Induction[PO]): Induction[S] =
new Induction[S]{}
现在，当你问Induction(_2) S会立即解决的_2 ，该Pred例如_2将得到解决，产生的溶液_1为PO这使得它所需要解决的感应下一步typechecker。
注意一般策略是从结果类型（ Induction[S] ）开始修复初始类型变量，然后从左到右在隐式参数列表中工作。
另请注意，我已将显式结果类型添加到隐式定义中：您应该几乎总是这样做（此规则极少有例外）。
链接地址: http://www.djcxy.com/p/87089.html