标签: implicits

第一个示例成功找到了对方法的隐式转换foo(String),但是只要我添加一个类型参数(请参阅fails参考资料),编译就不再解析它了:

object works {
  class A {
    def foo(): String = ???
  }
  implicit class PimpedA(a: A) {
    def foo(i: String): String = ???
  }
  val a = new A()
  a.foo("test") //compiles
}

object fails { //same as `works`, but adds type parameter
  class A {
    def foo[T](): String = ???
  }
  implicit class PimpedA(a: A) {
    def foo[T](i: String): String = ???
  }
  val a = new A()
  PimpedA(a).foo("test") // compiles
  a.foo("test") // error: too …

我有以下通用的Interval类(由用户soc为我制定):

case class Interval[T](from: T, to: T)(implicit num: Numeric[T]) {
  import num.mkNumericOps // allows us to write from.toDouble and to.toDouble
  def mid: Double = (from.toDouble + to.toDouble) / 2.0
}

典型用例:Interval [Double]或Interval [Int].为了添加二元联合和交集运算符,我(implicit num: Numeric[T])在伴随对象中遵循了类似的模式:

object Interval {

  def union[T](interval1: Interval[T], interval2: Interval[T])(implicit num: Numeric[T]) = {
    import num.mkOrderingOps // allows interval1.from min
    Interval[T](interval1.from min interval2.from, interval1.to max interval2.to)
  }

  def intersect[T](interval1: Interval[T], interval2: Interval[T])(implicit num: Numeric[T]) = {
    import num.mkOrderingOps
    Interval[T](interval1.from max interval2.from, …

我正在使用Play框架的JSON库,它使用类型类来实现该Json.toJson功能.(我可能决定使用另一种静态类型较少的技术,比如反射;但是现在我想使用这个库,因为它帮助我学习了Scala类型系统.)

我有一些需要传递给它的简单case类toJson,所以我必须为Writes[T]它们中的每一个实现一个隐式对象.对于每个类,第一个剪切可能看起来像这样.

// An example class
case class Foo(title: String, lines: List[String])

// Make 'Foo' a member of the 'Writes' typeclass
implicit object FooWrites extends Writes[Foo] {
  def writes(f: Foo) : JsValue = {
    val fields = Seq("title" -> toJson(f.title), 
                     "lines" -> toJson(f.lines))                        
    JsObject(fields)
  }
}  

每个类都有一个类似的隐含值,所以我可以抽象出公共部分,如下所示.但是这不会编译,因为我不确定如何声明类型.

def makeSimpleWrites[C](fields: (String, C => T??)*) : Writes[C] = {
  new Writes[C] {
    def writes(c: C) : JsValue = {
      val jsFields = fields map { …

此示例的设置(Scala 2.10.3):

trait S[A]
trait T[A]
implicit class X[A : S](a: A) { def foo() { } }
implicit class Y[A : T](a: A) { def foo() { } }
implicit object I extends S[String]

这编译:

new X("").foo()

这不是:

new Y("").foo()

因为没有隐含的T[String].

could not find implicit value for evidence parameter of type T[String]
              new Y("").foo()
              ^

因此,我认为scalac可以毫不含糊地将隐式转换String应用于X:

"".foo()

但相反,我们得到:

type mismatch;
 found   : String("")
 required: ?{def foo: ?}
Note that implicit conversions are not …

让有课Fruit,Orange和Apple.

abstract class Fruit
class Orange extends Fruit
class Apple extends Fruit

现在,我想添加write的功能这两种类型Orange和Apple.使用类型类模式我可以执行以下操作:

trait Writer[T] {def write(t:T)}

implicit object AppleWriter extends Writer[Apple] {
   def write(a:Apple) {println("I am an apple!")} 
}

implicit object OrangeWriter extends Writer[Orange] {
   def write(o:Orange) {println("I am an orange!")} 
}

def write[T](t:T)(implicit w:Writer[T]){w.write(t)}

所以,好,但如果我想定义writeFruits怎么办？

def writeFruits(fruits:List[Fruit]) {for (fruit <- fruits) write(fruit)}

我想writeFruits给每一个write[Apple]或write[Orange]每个人打电话fruit.我发现它不起作用(我知道为什么)但也许 …

从Scala集合的设计中我理解如下:

scala> BitSet(1,2,3) map (_ + "a")
res7: scala.collection.immutable.Set[String] = Set(1a, 2a, 3a)

不构建中间数据结构:新的Set是在使用Builder迭代BitSet时构建的.事实上,在这种情况下很明显,因为字符串的位组没有意义.

列表中的地图怎么样？我很确定以下内容构建了一个中间列表:

scala> List(1,2,3) map (_ -> "foo") toMap
res8: scala.collection.immutable.Map[Int,java.lang.String] =
    Map(1 -> foo, 2 -> foo, 3 -> foo)

即清单List((1,foo), (2,foo), (3,foo)).如果没有,那怎么样？现在,以下怎么样？

scala> Map.empty ++ (List(1,2,3) map (_ -> "foo"))
res10: scala.collection.immutable.Map[Int,java.lang.String] =
    Map(1 -> foo, 2 -> foo, 3 -> foo)

这一次,从我似乎从以下类型的理解++:

def ++ [B >: (A, B), That]
       (that: TraversableOnce[B])
       (implicit bf: CanBuildFrom[Map[A, B], B, That]): That

我认为 …

我们考虑一下这段代码:

class A
object A{
  implicit def A2Int(implicit a:A)=1
  implicit def A2String(a:A)="Hello"
}

object Run extends App{
  implicit val a: A =new A

  import A.A2Int
  // without this import this code does not compile, why ?
  // why is no import needed for A2String then ?

  def iWantInt(implicit i:Int)=println(i)
  def iWantString(implicit s:String)=println(s)

  iWantInt
  iWantString(a)
}

它运行和打印:

1
Hello

现在,如果我们注释掉这条线

import A.A2Int

然后我们得到一个编译错误:

随着该系列的注释,为什么Scala无法找到A.A2String它是否能找到A.A2Int？

如何解决这个问题？

谢谢阅读.

假设我们有一个隐含的类,如:

implicit class RichString(str: String) {
  def sayHello(): String = s"Hello, ${str}!"
}

我们可以使用sayHello方法,就好像它是在String类中定义的一样

"World".sayHello

scala编译器是否将其优化为静态调用以避免构造RichString对象的开销？

有这个帖子,讨论implicits的链接,但我认为它不包括我的情况,因为我有通用implicits.演示此问题的示例项目位于此处.要重现这两条线应该被注释掉.

所以我对具体类型有许多含义,例如

implicit val ObjectIdColumnType: ColumnType[ObjectId] = MappedColumnType.base[ObjectId, Array[Byte]](
      { obj => obj.toByteArray }, { arr => new ObjectId(arr) }
    )

我希望所有这些都能自动生成GetResult[T]隐式val.因此我写了以下功能

implicit def getResultForTypedTypes[T](implicit bct: ColumnType[T]): GetResult[T] =
  GetResult[T](r => bct.getValue(r.rs, r.currentPos))

我希望这个功能与原型如

def << [T](implicit f: GetResult[T]): T = f(this)

能够接受 GetResult[ObjectId]

可悲的是我得到了错误

Error:(78, 20) could not find implicit value for parameter f: slick.jdbc.GetResult[org.bson.types.ObjectId]
      val id = r.<<[ObjectId]
                   ^

我启用了log-implicits,发现看似无关的隐式隐藏在某种程度上

Information:(78, 20) getResultForTypedTypes is not a valid implicit value for …

我是Spark 2.0的新手，并在我们的代码库中使用数据集。我注意到我需要import spark.implicits._在代码中的任何地方。例如：

File A
class A {
    def job(spark: SparkSession) = {
        import spark.implcits._
        //create dataset ds
        val b = new B(spark)
        b.doSomething(ds)
        doSomething(ds)
    }
    private def doSomething(ds: Dataset[Foo], spark: SparkSession) = {
        import spark.implicits._
        ds.map(e => 1)            
    }
}

File B
class B(spark: SparkSession) {
    def doSomething(ds: Dataset[Foo]) = {
        import spark.implicits._
        ds.map(e => "SomeString")
    }
}

我想问的是，是否有一种更清洁的方法

ds.map(e => "SomeString")

没有在我做地图的每个函数中导​​入隐式函数？如果不导入，则会出现以下错误：

错误：（53，13）无法找到数据集中存储的类型的编码器。导入spark.implicits。支持基本类型（Int，String等）和产品类型（案例类）。_在将来的版本中将添加对其他类型进行序列化的支持。