标签: implicit

我试图创建从任何类型(比如Int)到String的隐式转换...

隐式转换为String意味着RichString方法(如反向)不可用.

implicit def intToString(i: Int) = String.valueOf(i)
100.toCharArray  // => Array[Char] = Array(1, 0, 0)
100.reverse // => error: value reverse is not a member of Int
100.length // => 3

隐式转换为RichString意味着String方法(如toCharArray)不可用

implicit def intToRichString(i: Int) = new RichString(String.valueOf(i))
100.reverse // => "001"
100.toCharArray  // => error: value toCharArray is not a member of Int
100.length // => 3

使用两个隐式转换意味着重复的方法(如长度)是不明确的.

implicit def intToString(i: Int) = String.valueOf(i)
implicit def intToRichString(i: Int) = new RichString(String.valueOf(i))
100.toCharArray  // => Array[Char] = Array(1, …

我正在使用新的Scala IDE(Eclipse 3.6.2 + Scala IDE 2.0.0 [Scala 2.9.0]),我尝试做一些像这样简单的事情:

(1 to 10).sum

这很好,但我最近也做了很多Groovy,我自动写道:

(1 to 10).sum()

第二个版本在IDE中给出了编译器错误,并显示以下消息:

方法总和的参数不够:(隐式数:数字[B])B.未指定的值参数num.

我在Scala API上看到有两个版本的sum,一个不带参数,另一个带上面隐含的.我是否必须在没有括号的情况下调用零参数方法？

假设我们只有局部范围的隐式参数查找:

trait CanFoo[A] {
  def foos(x: A): String
}

object Def {
  implicit object ImportIntFoo extends CanFoo[Int] {
    def foos(x: Int) = "ImportIntFoo:" + x.toString
  }
}

object Main {
  def test(): String = {
    implicit object LocalIntFoo extends CanFoo[Int] {
      def foos(x: Int) = "LocalIntFoo:" + x.toString
    }
    import Def._

    foo(1)
  }

  def foo[A:CanFoo](x: A): String = implicitly[CanFoo[A]].foos(x)
}

在上面的代码中,LocalIntFoo胜过ImportedIntFoo.有人可以使用"静态重载决策规则(§6.26.3)"来解释它是如何被认为更具体的吗？

编辑:

名称绑定优先级是一个引人注目的参数,但有几个问题尚未解决.首先,Scala语言参考说:

如果有几个符合条件的参数与隐式参数的类型匹配,则将使用静态重载决策的规则(第6.26.3节)选择最具体的参数.

其次,名称绑定优先级是关于在范围内有多个变量/方法/对象的情况下解析x特定成员的已知标识符.并且没有相同的名称.pkg.A.B.xxImportIntFooLocalIntFoo

第三,我可以证明单独的 …

我已经知道了:

• <: 是Scala语法类型约束
• while <:<是利用Scala隐式到达类型constrait的类型

例如:

object Test {
  // the function foo and bar can have the same effect

  def foo[A](i:A)(implicit ev : A <:< java.io.Serializable) = i
  foo(1) // compile error
  foo("hi")

  def bar[A <: java.io.Serializable](i:A) = i
  bar(1) // compile error
  bar("hi")
}

但我想知道什么时候需要使用<:和<:<？

如果我们已经拥有<:,我们为什么需要<:<？

谢谢!

我想使用java.time.LocalDate和java.time.LocalDateTime隐含的Ordered喜欢:

val date1 = java.time.LocalDate.of(2000, 1, 1)
val date2 = java.time.LocalDate.of(2010, 10, 10)
if (date1 < date2) ...

import scala.math.Ordering.Implicits._不起作用,因为LocalDate继承Comparable<ChronoLocalDate>而不是Comparable<LocalDate>.我怎样才能编写自己的imred命令来使用<,<=,>,> =运算符/方法进行比较LocalDate？

编辑:

我找到了一种使用隐式类的方法:

import java.time.{LocalDate}

object MyDateTimeUtils {
  implicit class MyLocalDateImprovements(val ld: LocalDate)
           extends Ordered[LocalDate] {
    def compare(that: LocalDate): Int = ld.compareTo(that)
  }
}

// Test

import MyDateTimeUtils._

val d1 = LocalDate.of(2016, 1, 1)
val d2 = LocalDate.of(2017, 2, 3)

if (d1 < d2) println("d1 …

考虑foo具有两个这样定义的构造函数的类:

class foo
{
public:
    foo(const std::string& filename) {std::cout << "ctor 1" << std::endl;}
    foo(const bool some_flag = false) {std::cout << "ctor 2" << std::endl;}
};

使用字符串文字实例化类,并猜测调用哪个构造函数？

foo a ("/path/to/file");

输出:

ctor 2

我不了解你,但我没有发现编程历史中最直观的行为.我打赌它有一些聪明的理由,但我想知道它可能是什么？

这是我的代码的一小部分.

   #include <stdio.h>
   #include <unistd.h>
   #include <stdlib.h>
   #include <time.h>
   #include <sys/stat.h>
   #include <sys/wait.h>
   #include <sys/types.h>
   #include <string.h>
   #include <sys/types.h>
   #include <sys/socket.h>
   #include <netinet/in.h>
   #include <arpa/inet.h>
    ...

   FILE * pipe;
    ...

   pipe = popen ("ls /tmp -1", "r");
    ...
   pclose(pipe);

blarg.c:106: warning: implicit declaration of function ‘popen’

blarg.c:106: warning: assignment makes pointer from integer without a cast

blarg.c:112: warning: implicit declaration of function ‘pclose’

blarg.c:118: warning: assignment makes pointer from integer without a cast

我真的不确定.我查了一下popen,它需要的是stdio.h.缺少什么,或者是我的其余代码中的问题(我真的不想显示更多的代码,因为它是一个赋值).

我希望接下来的三行代码是相同的:

public static void TestVarCoalescing(DateTime? nullableDateTime)
{
  var dateTimeNullable1 = nullableDateTime.HasValue ? nullableDateTime : DateTime.Now;
  var dateTimeNullable2 = nullableDateTime != null ? nullableDateTime : DateTime.Now;
  var dateTimeWhatType = nullableDateTime ?? DateTime.Now;
}

在所有情况下,我都分配nullableDateTime给新变量.我希望所有变量的类型都成为,DateTime?因为那是类型nullableDateTime.但令我惊讶的是,这种类型dateTimeWhatType只是变成了DateTime,所以不可空.

更糟糕的是,ReSharper建议用空合并表达式替换第二个语句,将其转换为表达式3.因此,如果我让ReSharper执行它的操作,变量的类型将从更改DateTime?为DateTime.

事实上,让我们说在方法的其余部分,我会使用

if (someCondition) dateTimeNullable2 = null;

那会编译得很好,直到我让ReSharper用空合并版本替换第二个表达式.

AFAIK,取代

somevar != null ? somevar : somedefault;

同

somevar ?? somedefault;

应该确实产生相同的结果.但是对于可空类型的隐式类型,编译器似乎威胁??就像它意味着一样.

somevar != null ? somevar.Value : somedefault;

所以我想我的问题是为什么隐藏类型在我使用时会被更改??,而且在文档中我可以找到关于此的信息. …

我是Scala的新手,当我查看不同的项目时,我看到两种处理隐式参数的样式

scala]]>def sum[A](xs:List[A])(implicit m:Monoid[A]): A = xs.foldLeft(m.mzero)(m.mappend)
sum:[A](xs:List[A])(implicit m:Monoid[A])A

和

scala]]>def sum[A:Monoid](xs:List[A]): A ={
     val m = implicitly[Monoid[A]]
     xs.foldLeft(m.mzero)(m.mappend)
   }
sum:[A](xs:List[A])(implicit evidence$1:Monoid[A])A

根据两种功能的类型,它们匹配.这两者有区别吗？为什么要隐式使用隐式参数？在这个简单的例子中,它感觉更加冗长.

当我在REPL中运行上面没有隐含的东西时,我得到以下错误

隐含的参数

<console>:11: error: could not find implicit value for parameter m: Monoid[String]

和

隐式地和a:Monoid

<console>:11: error: could not find implicit value for evidence parameter of type Monoid[String]

我正在使用ScalaTest为Spark编写测试用例.

import org.apache.spark.sql.SparkSession
import org.scalatest.{BeforeAndAfterAll, FlatSpec}

class ClassNameSpec extends FlatSpec with BeforeAndAfterAll {
  var spark: SparkSession = _
  var className: ClassName = _

  override def beforeAll(): Unit = {
    spark = SparkSession.builder().master("local").appName("class-name-test").getOrCreate()
    className = new ClassName(spark)
  }

  it should "return data" in {
    import spark.implicits._
    val result = className.getData(input)

    assert(result.count() == 3)
  }

  override def afterAll(): Unit = {
    spark.stop()
  }
}

当我尝试编译测试套件时,它会给我以下错误:

stable identifier required, but ClassNameSpec.this.spark.implicits found.
[error]     import spark.implicits._
[error]                  ^
[error] one error found
[error] (test:compileIncremental) …