相关疑难解决方法(0)

据我所知,集合库中没有共享特征来定义map方法(很可能是因为有不同的签名map).

我有一个可观察的值(想想一个ui系统中的属性),它有一个change事件.可以使用map方法映射可观察值.

但是,当我们使用已经有map方法的类型时,我们应该能够使用内置方法map.

所以代替:

prop map { x => 
  x map { actualX =>
   //do something
  }
}

我想这样使用它:

prop map { actualX =>
  //do something
}

我有一个简化的测试用例.首先是我使用的不同部分:

// leaving out the observable part
trait ObservableValue[T] {
  def value: T
}

trait LowerPriorityImplicits {
  // default implementation that adds a regular map method
  implicit class RichObservableValue1[A](o: ObservableValue[A]) {
    def map[B](f: A => B): ObservableValue[B] = new ObservableValue[B] {
      def value …

正如我在阅读这篇关于JDK 7中新的invokedynamic字节码指令的帖子所理解的那样,它可以调用对象类中没有静态定义的对象上的方法,并将这些方法调用解析为某些具体的静态方法.其他类通过拦截方法调用目标分辨率(帖子给出一个例子).

这是否意味着Java 7类可以使用Scala之类的隐式方法？如果不是,Scala中的隐式方法解析与invokedynamic方法解析有何不同？

我正在尝试为Post请求编写测试

这是我的代码:

val request = CreateLinkRequest(token = Some(validToken),billing_ref_id = Some("123"), store_id = Some("123"), agent_id = Some("123"))

val endPoint = Uri(this.serverRootUrl + "path").toString
val post = Post(endPoint, request)
val pipeline = jsonAsStringPipeline(post)
val responseContents = Await.ready(pipeline, atMost = callMaxWaitDuration)

但这不编译,我不断收到此错误:

Error:(156, 20) could not find implicit value for evidence parameter of type spray.httpx.marshalling.Marshaller[CreateLinkSpec.this.CreateLinkRequest]
    val post = Post(endPoint, request)
               ^
Error:(156, 20) not enough arguments for method apply: (implicit evidence$1: 

spray.httpx.marshalling.Marshaller[CreateLinkSpec.this.CreateLinkRequest])spray.http.HttpRequest in class RequestBuilder.
Unspecified value parameter evidence$1.
    val post = Post(endPoint, …

在 Cats 2.1.x 中，类型类实例被引入范围内import cats.implicits._

scala> import cats.Show
import cats.Show

scala> Show[Int].show(42)
<console>:13: error: could not find implicit value for parameter instance: cats.Show[Int]
       Show[Int].show(42)
           ^

scala> import cats.implicits._
import cats.implicits._

scala> Show[Int].show(42)
res1: String = 42

然而在 Cats 2.2.0中，它无需import cats.implicits._例如

scala> import cats.Show
import cats.Show

scala> Show[Int].show(42)
val res0: String = 42

发生了什么变化以及从现在开始我们应该如何使用导入？

我在几个框架中发现了以下函数调用,在我看来,好像框架扩展了一些基类.一些例子:

within(500 millis)

要么

"Testcase description" in
  { .... }

第一个示例从akka返回持续时间为500毫秒的持续时间对象,第二个示例是从scalatest定义的测试用例.

我想知道如何实现这种行为以及如何调用它.

请考虑以下代码段.+ =不是java.lang.String的成员,所以我猜有某种隐式转换正在进行中.如何查找作用于String的此类预定义隐式转换的列表？

scala> var x = "asdf"
x: java.lang.String = asdf

scala> x += x

scala> x
res2: java.lang.String = asdfasdf

我尝试实现一些数字类型,我遇到了问题

mynum * 1

有效,但不是

1 * mynum

我试图定义这样的隐式转换

case class Num(v: Int) {
  def * (o: Int) = new Num(v*o)
}

implicit def int2Num(v: Int) = Num(v)

但它似乎不起作用,因为我总是得到以下错误:

scala> 1 * new Num(2)
<console>:14: error: overloaded method value * with alternatives:
  (x: Double)Double <and>
  (x: Float)Float <and>
  (x: Long)Long <and>
  (x: Int)Int <and>
  (x: Char)Int <and>
  (x: Short)Int <and>
  (x: Byte)Int
 cannot be applied to (Num)
              1 * new Num(2)
                ^

另一方面

1 * BigInt(1)

虽然我在查看代码时无法确定解决方案,但仍然有办法.

使其运作的机制是什么？

编辑:我用我遇到的实际问题创建了一个新问题, …

有时我需要通过映射另一个具有不同类型的集合来创建集合.例如,某些函数需要List[_]作为其参数类型,但我需要通过映射来生成IndexedSeq[_]:

val r = (1 to n).map { ... }
someFunction(r.toList)

虽然我可以通过调用履行IndexedSeq[_]的map方法首先,接着另一个调用toList,这将产生一个冗余中间收集.有什么方法可以避免这个冗余的步骤,同时仍然保持代码简洁？

我遇到了一个代码片段，但无法理解它。片段是：

  implicit val dummyVisit = Visit("", 1L, 1, 1, 1, 1L)
  implicit val dummyOrder = Order("", 1L, 1, 1, 1, 1L)

  def process[T](events : Array[T])(implicit t: T):Unit = {
    println(t)
    if(!events.isEmpty)
      t match {
        case r: Order => processOrder(events.asInstanceOf[Array[Order]])
        case r: Visit => processVisit(events.asInstanceOf[Array[Visit]]);
      }
  }

  def processOrder(arr: Array[Order]): Unit = { println(arr.size) }
  def processVisit(arr: Array[Visit]): Unit = { println(arr.size) }

变量, 要求&存在implicit。tdummyVisitdummyOrder

问题：

1. 这是正确的使用方法吗implicit parameter？

2. 有没有更好的方法来获取 的类类型T，而不使用隐式参数？

我有以下代码.我必须确认它是如何工作的方式.任何人都可以为此提供解释

object Implicits
{
  implicit class RichSeq[A](val xs:Seq[A])
  {
    def mapD[B](function:A => B):Seq[B] = xs.map(function)
  }
}

这就像地图上的抽象,我可以使用序列.因此,如果我导入此Implicits.RichSeq,我可以使用任何Seq [A]上的方法,因为这会将Seq [A]转换为RichSeq [A].

import Implicits.RichSeq._
val xs:Seq[Int] = Seq(22,33)
val output:Seq[Int] = xs.mapD(_+22)

我想知道它是如何工作的,因为当我在Seq [A]类型上使用mapD时,它将搜索从Seq [A]到RichSeq [A]的隐式转换.它会找到这个隐式转换,因为这是一个隐式类？

它是否将隐式类扩展为:

隐式def RichSeq [A](val xs:Seq [A])= new RichSeq(xs)

我想它可能在里面做这些东西.对此ne1知道吗？