Question

我正在使用scala类型课程，并遇到了以下问题。我用多种方法创建了一个类。每种方法都有一个隐含参数 B ，并返回一个[ A ， B ]。

类型 B 是一个转换器，调用者可以根据需要提供自定义对象来包装响应。

所以这是代码

  case class A( var value:String){

  }

  case class Converter[A]( value : (Map[String, String] ) => A )

  object Converter{
     implicit val AConverter = new Converter[A]( (x:Map[String, String]) => new A("Hello World") )
     implicit val IntConverter = new Converter[Int]( (x:Map[String, String]) => 10 )
  }

  class API{

    def method1[B : Converter] : Either[A, B] = {
      Right( implicitly[Converter[B]].value(Map.empty))
    }

    def method2[B : Converter](name:String) : Either[A, B] = {
      Right( implicitly[Converter[B]].value(Map.empty))
    }

    def method3[B : Converter](id:Int) : Either[A, B] = {
      Right( implicitly[Converter[B]].value(Map.empty))
    }

  }

现在这是我的麻烦。我想继续跟随

每个方法都应该是可调用的，而不必担心隐式参数 B ，因为应该在某处定义默认实现。

所以我在伴侣对象中定义了一些含义，但这根本无法解决我的问题！

  // Works due implicit definiton
  println( new API().method1[A])
  // Works due implicit definiton
  println( new API().method1[Int])
  // Works not but should
  println( new API().method1)

我想说方法1的 B 类型为转换器[A] ，方法2的 B 类型为转换器[Int] 如果调用者没有提供它。

  // Implementation should use my default Converter[A]
  println( new API().method1)

我在这里遇到了这个问题

https://stackoverflow.com/a/29205892/452265

那么如果类型本身没有像示例那样传递给方法，那么如何提供默认类型呢？每个方法我都不需要这种方法。

Answer 1

这可能不是问题的答案，而是解决问题的解决方案。

如果你想调用new API().method1，那么为什么不定义一个没有类型参数的函数method1，而不是寻找一种指定默认类型参数的方法呢？

case class A( var value:String){

}

case class Converter[A]( value : (Map[String, String] ) => A )

object Converter{
  implicit val AConverter = new Converter[A]( (x:Map[String, String]) => new A("Hello World") )
  implicit val IntConverter = new Converter[Int]( (x:Map[String, String]) => 10 )
}

class API{

  def method1: Either[A, A] = {
    Right(Converter.AConverter.value(Map.empty))
  }

  def method1[B : Converter] : Either[A, B] = {
    Right( implicitly[Converter[B]].value(Map.empty))
  }

  def method2[B : Converter](name:String) : Either[A, B] = {
    Right( implicitly[Converter[B]].value(Map.empty))
  }

  def method3[B : Converter](id:Int) : Either[A, B] = {
    Right( implicitly[Converter[B]].value(Map.empty))
  }

}

val undefined = new API().method1
val defined = new API().method1[Int]

这可以调用new API().method1。但是，有一些限制。例如。类型推断可能无法正常工作：

val defined: Either[A, Int] = new API().method1

无法编译。

Answer 2

我和你一样思考并最终遇到了这个解决方案。它有点开销，但似乎按照我需要的方式工作！

class A(  val value:String){
     val success = true;
  }

  class B(  value:String) extends A(value){
     override val success = false;
  }

  class C(  override val value:String = "Doo") extends A(value){
     override val success = false;
  }

  case class Converter[A]( value : (Map[String, String] ) => A ){

  }

  object Converter{
     implicit lazy val method1Converter  = new Converter[B]( (x:Map[String, String]) => new B("foo") )
     implicit lazy val method2Converter  = new Converter[C]( (x:Map[String, String]) => new C() )
  }

  trait method1Impl{

    def method1 : Either[A, B] = {
      Right( Converter.method1Converter.value( Map.empty ) )
    }

    def method1[B : Converter] : Either[A, B] = {
      Right( implicitly[Converter[B]].value(Map.empty))
    }
  }

  trait method2Impl{

    def method2 : Either[A, C] = {
      Right( Converter.method2Converter.value( Map.empty ) )
    }

    def method2[B : Converter]( name:String) : Either[A, B] = {
      Right( implicitly[Converter[B]].value(Map.empty))
    }
  }

  class API extends method1Impl with  method2Impl {



  }


  // Works not but should
  println( new API().method1)

  println( new API().method2[C]("Hello"))

为scala generic

2 个答案: