标签: implicit

在我阅读时会出现几个问题.3.3.2从Joshua的Scala深度捕获类型约束.摘自本书的例子:

scala> def peek[C, A](col: C)(implicit ev: C <:< Traversable[A]) = (col.head, col)
peek: [C, A](col: C)(implicit ev: <:<[C,Traversable[A]])(A, C)

scala> peek(List(1, 2, 3))
res9: (Int, List[Int]) = (1,List(1, 2, 3))

通过第一个参数列表C发现它似乎很简单List[Int].如何<:<通过方差强制类型约束在本书中进行了解释.但我不太明白这有多大帮助A.

我的理解是,从第一个参数列表,scala发现C: List[Int],然后它寻找implicit ev: <:<[List[Int], Traversable[A]].目前A仍然未知.它"拉动"两个暗示conforms[List[Int]]并conforms[Traversable[A]]匹配ev.在任一情况下,以满足方差,List[Int] <: Traversable[A]必须被满足,这导致这一发现A是Int.

它是否像我在这里描述的那样工作？特别是关于如何/何时A推断.

假设我有这个:

class String2(val x:String) {
    def *(times:Int) : String = {
        val builder = new StringBuilder()
        for( i <- 0 until times) {
            builder.append(x)
        }
        builder.toString()
    }
}

现在,如果我添加这个隐含:

implicit def gimmeString2(y:String) = new String2(y)

我会得到一个编译错误,因为stringWrapper也添加了这个隐式.有没有办法说编译器"忽略其他含义,使用它",这样我就不必实例化一个String2对象并对其进行处理？

我承认示例代码可能不是最合适的(对于这个问题),但我认为它会做.

我正在阅读有关提到隐式对象的类型类:

object Math {
  trait NumberLike[T] {
    def plus(x: T, y: T): T
    def divide(x: T, y: Int): T
    def minus(x: T, y: T): T
  }
  object NumberLike {
    implicit object NumberLikeDouble extends NumberLike[Double] {
      def plus(x: Double, y: Double): Double = x + y
      def divide(x: Double, y: Int): Double = x / y
      def minus(x: Double, y: Double): Double = x - y
    }
    implicit object NumberLikeInt extends NumberLike[Int] {
      def plus(x: Int, y: Int): Int …

我已经看到有两种方法(其中一个比另一个更小)的声明implicit为类型类模式在Scala中.

implicit val instance1 = new Typeclass { def do = ??? }
implicit object instance2 extends Typeclass { def do = ??? }

他们有什么不同？在某些时候,人们应该更喜欢一个吗？我找到implicit val了比implicit object我更常用的东西,而且我还没有找到很多资源implicit object.

以下 C# 程序以静默方式隐式调用显式小数到长整型转换运算符，从而丢失精度。

我不明白为什么会发生这种情况。据我了解，在 C# 中，显式运算符不应由语言隐式调用。特别是在这种情况下，静默显式转换正在失去精度（1.1M => 1L）。

这种奇怪的行为实际上导致了我的程序中的错误。

这是简化的代码：

// Custom number class
struct Num
{
    long Raw;
    public static implicit operator Num(long v) => new Num { Raw = v };
}

class Program
{
    static void Main()
    {
        decimal d = 1.1m;
        // The following line implicitly converts d to long (silently losing precision), 
        // then calls Num.op_Implicit(long)
        Num num = (Num)d;  // <=== should not compile???
    }
}

这是生成的 IL。您可以看到它System.Decimal::op_Explicit被调用了，即使它从未被要求过。 …

我对Ruby有点新鲜,虽然我发现它是一种非常直观的语言,但我很难理解隐式返回值的行为方式.

我正在开发一个小程序来grep Tomcat日志并从相关数据生成管道分隔的CSV文件.这是我用来从日志条目生成行的简化示例.

class LineMatcher
  class << self
    def match(line, regex)
      output = ""
      line.scan(regex).each do |matched|
        output << matched.join("|") << "\n"
      end
      return output
    end        
  end
end


puts LineMatcher.match("00:00:13,207 06/18 INFO  stateLogger - TerminationRequest[accountId=AccountId@66679198[accountNumber=0951714636005,srNumber=20]",
                       /^(\d{2}:\d{2}:\d{2},\d{3}).*?(\d{2}\/\d{2}).*?\[accountNumber=(\d*?),srNumber=(\d*?)\]/)

当我运行这段代码时,我得到了以下内容,这是显式返回输出值时的预期结果.

00:00:13,207|06/18|0951714636005|20

但是,如果我将LineMatcher更改为以下内容并且不显式返回输出:

    class LineMatcher
      class << self
        def match(line, regex)
          output = ""
          line.scan(regex).each do |matched|
            output << matched.join("|") << "\n"
          end
        end        
      end
    end

然后我得到以下结果:

00:00:13,207
06/18
0951714636005
20

显然,这不是理想的结果.感觉我应该能够摆脱输出变量,但不清楚返回值的来源.此外,欢迎任何其他可读性的建议/改进.

我想知道为什么链接器不能简单地通过查询获得实际实现代码的实际.dll文件中的信息来完成它们的工作？我的意思是为什么链接器仍然需要.lib文件来进行隐式链接？

不是这种链接的导出和相对地址表足够吗？

无论如何,只使用.dll而没有.lib存根/代理文件的人可以进行隐式链接？

我认为Windows可执行加载器只是代表程序执行LoadLibrary/LoadLibraryEx调用(因此名称隐式链接),这是显式链接的主要区别.如果这是真的,那么在没有.lib的情况下明确地执行它应该表明它是可行的,如果没有隐式,对吧？或者我只是说非感觉？

任何帮助表示赞赏,非常感谢:)

geeko

scala> class A(implicit a: Int);
defined class A

scala> class B()(implicit a: Int);
defined class B

scala> new A()(1)
res1: A = A@159d450

scala> new B()(1)
res2: B = B@171f735

scala> new A(1)
<console>:7: error: too many arguments for constructor A: ()(implicit a: Int)A
       new A(1)

为什么Scalac在类声明中提供的隐式参数列表之前插入一个空参数列表？

从scalac来源的评论来看,这似乎是一个特征,而不是一个错误:

//如果它是唯一的参数部分,则将(隐式...)转换为()(隐式...)

我很想知道为什么这样做.我觉得这很令人惊讶.

declare @str_datetime varchar(50)
set @str_datetime='30-04-2012 19:01:45' -- 30th April 2012
declare @dt_datetime datetime
select @dt_datetime=@str_datetime

这会产生以下错误:

消息242,级别16,状态3,行4
将varchar数据类型转换为日期时间数据类型导致超出范围的值.

我的问题是SQL Server如何决定使用哪种格式进行隐式日期时间转换？

对于非重载和重载方法,Scala如何解析"Magnet Pattern"的隐式转换有很大差异.

假设存在如下实现的特征Apply("磁体模式"的变体).

trait Apply[A] {
 def apply(): A
}
object Apply {
  implicit def fromLazyVal[A](v: => A): Apply[A] = new Apply[A] {
    def apply(): A = v
  }
}

现在我们创建一个Foo具有单个apply实例的特征,Apply因此我们可以将任意类型的值传递给它,A因为存在隐式转换A => Apply[A].

trait Foo[A] {
  def apply(a: Apply[A]): A = a()
}

我们可以确保它使用REPL按预期工作,并使用此解决方法来减少Scala代码.

scala> val foo = new Foo[String]{}
foo: Foo[String] = $anon$1@3a248e6a

scala> showCode(reify { foo { "foo" } }.tree)
res9: String =    
$line21$read.foo.apply( …