标签: implicit

有没有办法在org.spec2.time中排除隐式时间转换并使用自己的?

我正在尝试使用specs2,我有隐式转换的问题,这些转换与我从scala.concurrent.duration._中导入的转换混合,是否有任何方法可以从范围中排除隐含的转换?

import org.specs2.mutable.Specification
import scala.concurrent.duration._

class StatisticsSampleCacheSpec extends Specification {

    val map: Map[Long, Duration] = Map(
        1L -> 5.minute,
        3L -> 3.day,
        5L -> 5.day,
        7L -> 30.day)
}
Run Code Online (Sandbox Code Playgroud)

scala implicit implicit-conversion specs2

5
推荐指数
1
解决办法
664
查看次数

J中隐性编程的优缺点

作为JI的初学者,我常常遇到隐性程序,与更熟悉的显式形式相比,它们看起来相当拜占庭.

现在只是因为我发现解释困难并不意味着默会形式是错误的或错误的.通常,默认形式比显式形式短得多,因此更容易在视觉上同时看到所有形式.

专家提问:这些隐性形式是否表达了更好的结构感,并可能提炼出潜在的计算机制?还有其他好处吗?

我希望答案是肯定的,对于一些非平凡的例子也是如此......

explicit implicit j tacit-programming

5
推荐指数
2
解决办法
417
查看次数

用于互操作的 Scala 隐式类到 Java 静态方法?

是否可以从隐式类定义自动生成用于互操作的配套 Java 静态方法?

例如:

class Foo()
object FooOps {
    implicit class FooOps(foo: Foo) extends AnyVal {
      def baz = "hello"
    }
}
Run Code Online (Sandbox Code Playgroud)

可以作为new Foo().baz. 然而,这在 Java 中是相当不方便和不惯用的。是否可以为 Java 自动生成(例如通过宏)静态方法,就像 Kotlin 为扩展方法所做的那样?例如:

object FooOps {
    @MagicAnnotation 
    implicit class FooOps(foo: Foo) extends AnyVal {
      def baz(n: Int) = "hello"
    }
    // generated:
    def baz(foo: Foo, n: Int) = foo.baz(n)
}
Run Code Online (Sandbox Code Playgroud)

scala implicit scala-java-interop

5
推荐指数
0
解决办法
445
查看次数

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

在下面的例子中,有没有办法避免隐式分辨率选择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 …
Run Code Online (Sandbox Code Playgroud)

scala implicit type-members

5
推荐指数
1
解决办法
606
查看次数

如何在Scala中找到隐式的来源?

简短问题:

有没有办法让scala编译器告诉我程序中给定点使用的某个隐式声明在哪里?

如果没有,是否可以手动遵循一种算法来找出隐式声明的位置?

长问题:

我正在遵循简单的Spray Crud 教程。

在下面的代码片段中(作为教程的此仓库):

pathEnd {
  post {
    entity(as[Question]) { question =>
      completeWithLocationHeader(
        resourceId = questionService.createQuestion(question),
        ifDefinedStatus = 201, ifEmptyStatus = 409)
      }
    }
} ~
Run Code Online (Sandbox Code Playgroud)

as接受一个隐式类型FromRequestUnmarshaller[T](此处为完整资料):

  def as[T](implicit um: FromRequestUnmarshaller[T]) = um
Run Code Online (Sandbox Code Playgroud)

当我问IntelliJ时,这个隐式是从哪里来的(使用CMD + SHIFT + P),我得到:

在此处输入图片说明 当我遵循第一个提示时,我得到了:

trait UnmarshallerLifting {

  implicit def fromRequestUnmarshaller[T](implicit um: FromMessageUnmarshaller[T]): FromRequestUnmarshaller[T] =
    new FromRequestUnmarshaller[T] {
      def apply(request: HttpRequest): Deserialized[T] = um(request)
    }
...
Run Code Online (Sandbox Code Playgroud)

这并不能帮助我确定隐式FromRequestUnmarshaller[T]函数的来源,因为如果我检查类层次结构,就无法确定特征是如何UnmarshallerLifting混合的QuestionResource …

scala intellij-idea implicit spray

5
推荐指数
1
解决办法
667
查看次数

如何在提取值时将参数注释为模式匹配中的隐式参数

我有一个类似的课程

case class A(a: Int, b: String)
Run Code Online (Sandbox Code Playgroud)

和一个功能

def f(a: Int)(implicit b: String) =???
Run Code Online (Sandbox Code Playgroud)

可以这样做吗?

val a = A(11, "hello")
a match {
  case A(a, implicit b) => f(a)
}
Run Code Online (Sandbox Code Playgroud)

如何在不提取后明确声明参数的情况下隐藏参数b.

scala implicit pattern-matching

5
推荐指数
1
解决办法
156
查看次数

在对象中没有定义的类型声明的含义是什么?

Scala允许使用type关键字定义类型,这些类型通常具有不同的含义和目的,具体取决于声明的时间。

如果type在一个对象或一个包对象内部使用,则应定义一个类型别名,即另一种类型的简称/简称:

package object whatever {
  type IntPredicate = Int => Boolean

  def checkZero(p: IntPredicate): Boolean = p(0)
}
Run Code Online (Sandbox Code Playgroud)

在类/特征中声明的类型通常打算在子类/子特征中被覆盖,并且最终也被解析为具体类型:

trait FixtureSpec {
  type FixtureType
  def initFixture(f: FixtureType) = ...
}

trait SomeSpec extends FixtureSpec {
  override type FixtureType = String

  def test(): Unit = {
    initFixture("hello")
    ...
  }
}
Run Code Online (Sandbox Code Playgroud)

抽象类型声明还有其他用途,但无论如何最终它们都会解析为某些具体类型。

但是,还有一个选项可以在对象内部声明抽象类型(即,没有实际定义):

object Example {
  type X
}
Run Code Online (Sandbox Code Playgroud)

与例如抽象方法相反,它可以编译:

object Example {
  def method: String  // compilation error
}
Run Code Online (Sandbox Code Playgroud)

由于无法扩展对象,因此永远无法将它们解析为具体类型。

我认为这样的类型定义可以方便地用作幻像类型。例如(使用Shapeless的标记类型):

import …
Run Code Online (Sandbox Code Playgroud)

types scala implicit abstract-type

5
推荐指数
1
解决办法
110
查看次数

在调用 combineReducers 时隐式实例化的函数类型中声明的类型参数缺少类型注释

我现在在 Redux 中的 combineReducers 上收到以下错误。

缺少类型注释A。A是在函数类型 [1] 中声明的类型参数,并在调用combineReducers[2] 时隐式实例化。

代码如下所示,但出现在我所有使用 combineReducers 的减速器中。

export default combineReducers({
  status: ((state: boolean = true, action: Action) => {
    switch (action.type) {
      case 'START_SESSION':
      case 'REFRESH_AUTH_SUCCEEDED':
      case 'SIGN_IN_FAILED':
      case 'SIGN_OUT':
        return false;
      default:
        return state;
    }
  }: Reducer<*>),
});
Run Code Online (Sandbox Code Playgroud)

我相信这是因为 Redux flow-types 中的这种类型定义


declare export function combineReducers<O: Object, A>(reducers: O): 
       CombinedReducer<$ObjMap<O, <S>(r: Reducer<S, any>) => S>, A>;

Run Code Online (Sandbox Code Playgroud)

我相信这与 Flow 的发布有关,版本 0.85.0 引入了一些与“隐式实例化”有关的东西。

我阅读了 Flow 自己的 Sam Goldman 在 Medium …

javascript instantiation implicit flowtype redux

5
推荐指数
1
解决办法
2645
查看次数

涉及隐式的“非法循环引用”的解释

在我的项目中,我有一个 type A,用于一些地方的参数,我希望一堆类型自动转换为该类型。我已经使用A. 我已经删除了触发问题所不需要的所有内容:

trait A
object A {
  implicit class SeqA[T](v: Seq[T])(implicit x: T => A) extends A
  implicit class IntA(v: Int) extends A
  implicit class TupleA(v: (Int, Int)) extends SeqA(Seq(v._1, v._2))
}
Run Code Online (Sandbox Code Playgroud)

但scalac由于非法循环引用而拒绝此代码:

$ scalac -version
Scala compiler version 2.12.8 -- Copyright 2002-2018, LAMP/EPFL and Lightbend, Inc.
$ scalac A.scala 
A.scala:5: error: illegal cyclic reference involving class TupleA
  implicit class TupleA(v: (Int, Int)) extends SeqA(Seq(v._1, v._2))
                 ^
one error found
Run Code Online (Sandbox Code Playgroud)

这里究竟有什么问题?什么是编译器绑定到涉及 …

scala implicit cyclic-reference

5
推荐指数
1
解决办法
745
查看次数

通过隐式类的泛型方法重载

当我尝试通过隐式类为该类创建扩展并重载现有的通用方法时,它会因编译错误而失败:

error: overloaded method value getAs with alternatives:
  (fieldName: String)String <and>
  (i: Int)String
 cannot be applied to (FooField.type)
       r.getAs[String](FooField)
Run Code Online (Sandbox Code Playgroud)

通过隐式重载正常(非泛型)方法时,效果很好。在Scala 2.12.10上试用。链接到scastie。我想念什么?代码:

trait Row {
    // Two overloads for `getAs[T]`
    def getAs[T](i: Int): T
    def getAs[T](fieldName: String): T

    // Two overloads for `get`
    def get(i: Int): String
    def get(fieldName: String): String
}

trait Field {
    def columnName: String
    def columnDescription: String
}
case object FooField extends Field {
    def columnName: String = "Foo"
  def columnDescription: String = "Foo desc" …
Run Code Online (Sandbox Code Playgroud)

generics scala implicit

5
推荐指数
0
解决办法
65
查看次数