Question

在以下示例中，有没有办法避免隐式分辨率选择for (int x = 0; x < 4; x++) { for (int i = daynow; i < 31; i++) { if (i == day1) { System.out.println(df.format(setDateofMonth(yearnow, monthnow + x + 1, day1))); } if (i == day2) { System.out.println(df.format(setDateofMonth(yearnow, monthnow + x + 1, day2))); } if (i == day3) { System.out.println(df.format(setDateofMonth(yearnow, monthnow + x + 1, day3))); } if (i == day4) { System.out.println(df.format(setDateofMonth(yearnow, monthnow + x + 1, day4))); } } }并使用$taxonomy = 'casestudies_category'; $post_terms = wp_get_object_terms( $post->ID, $taxonomy, array( 'fields' => 'ids' ) ); $separator = ', '; if ( !empty( $post_terms ) && !is_wp_error( $post_terms ) ) { $term_ids = implode( ',' , $post_terms ); $terms = wp_list_categories( 'title_li=&style=none&echo=0&taxonomy=' . $taxonomy . '&include=' . $term_ids ); $terms = rtrim( trim( str_replace( '<br />', $separator, $terms ) ), $separator ); echo $terms; }代替？代码后的更多背景信息：

defaultInstance

实际输出：

intInstance

期望的输出：

// the following part is an external fixed API

trait TypeCls[A] {
  def foo: String
}

object TypeCls {
  def foo[A](implicit x: TypeCls[A]) = x.foo

  implicit def defaultInstance[A]: TypeCls[A] = new TypeCls[A] {
    def foo = "default"
  }

  implicit val intInstance: TypeCls[Int] = new TypeCls[Int] {
    def foo = "integer"
  }
}

trait FooM {
  type A
  def foo: String = implicitly[TypeCls[A]].foo
}

// end of external fixed API

class FooP[A:TypeCls] { // with type params, we can use context bound
  def foo: String = implicitly[TypeCls[A]].foo
}

class MyFooP extends FooP[Int]

class MyFooM extends FooM { type A = Int }

object Main extends App {

  println(s"With type parameter: ${(new MyFooP).foo}")
  println(s"With type member:    ${(new MyFooM).foo}")
}

我正在与使用上述方案的第三方库一起提供＆＃34;默认＆＃34;类类With type parameter: integer With type member: default的实例。我认为上面的代码是一个演示我的问题的最小例子。

用户应该混合With type parameter: integer With type member: integer特征并实例化抽象类型成员TypeCls。问题是由于FooM调用A无法解析专用defaultInstance，而是提交(new MyFooM).foo这不是我想要的。

我使用类型参数添加了替代版本，称为intInstance（P =参数，M =成员），这避免了通过使用类型参数上的上下文绑定来解析defaultInstance。

对于类型成员，有没有相同的方法呢？

编辑：我的简化中有错误，实际上FooP不是defaultInstance而是foo，所以无法添加隐式参数。因此，目前的答案都不适用。

def

Answer 1

在这种特定情况下，最简单的解决方案是foo本身需要TypeCls[A]的隐式实例。唯一的缺点是它会在每次调用foo时传递，而不是在实例化时传递 FooM。因此，在每次致电foo时，您必须确保它们在范围内。虽然只要TypeCls实例在伴随对象中，您就不会有任何特殊要做。

trait FooM {
  type A
  def foo(implicit e: TypeCls[A]): String = e.foo
}

更新：在上面的回答中，我设法错过了FooM无法修改的事实。此外，该问题的最新修改提到FooM.foo实际上是val而不是def。

好消息是，您使用的API已经被破坏了。 FooM.foo wille无法返回任何有用的内容（无论TypeCls[A]的实际值如何，它始终会TypeCls.defaultInstance解析为A。唯一的出路是在已知foo的实际值的派生类中覆盖A，以便能够使用TypeCls的正确实例。幸运的是，这个想法可以与您使用具有上下文绑定的类（在您的情况下为FooP）的原始解决方法相结合：

class FooMEx[T:TypeCls] extends FooM {
  type A = T
  override val foo: String = implicitly[TypeCls[A]].foo
}

现在不要让您的课程直接延伸FooM，而是让他们扩展FooMEx：

class MyFoo extends FooMEx[Int]

FooMEx与原始FooP类之间的唯一区别是FooMEx 扩展FooM，因此MyFoo是FooM的正确实例，因此可以与固定API一起使用。

Answer 2

您可以从第三方库中复制代码吗？覆盖该方法可以解决问题。

class MyFooM extends FooM { type A = Int 
  override def foo: String = implicitly[TypeCls[A]].foo}

这是一个黑客，但我怀疑还有什么更好的。

我不知道为什么它的工作方式如此。它必须是在隐式表达式中替换类型别名的某种顺序。

只有语言规范的专家可以告诉你确切的原因。

类型成员的上下文边界或如何在成员实例化之前推迟隐式解析

2 个答案: