标签: implicit

就像是

public static class StringHelpers
{
    public static char first(this string p1)
    {
        return p1[0];
    }

    public static implicit operator Int32(this string s) //this doesn't work
    {
        return Int32.Parse(s);
    }
}

所以:

string str = "123";
char oneLetter = str.first(); //oneLetter = '1'

int answer = str; // Cannot implicitly convert ...

我有以下代码:

template <class T>
struct pointer
{
  operator pointer<const T>() const;
};


void f(pointer<const float>);

template <typename U>
void tf(pointer<const U>);

void g()
{
  pointer<float> ptr;
  f(ptr);
  tf(ptr);
}

当我用gcc 4.3.3编译代码时,我得到一个message(aaa.cc:17: error: no matching function for call to ‘tf(pointer<float>&)’),指示编译器调用'operator pointer<const T>'了非模板化函数f(),但没有用于模板化函数tf().为什么并且有没有解决方法没有使用const和非const版本重载tf()？

在此先感谢您的帮助.

SICP第3.5.3章 http://mitpress.mit.edu/sicp/full-text/book/book-ZH-24.html#%_sec_3.5.3

在章节中Streams as signals,SICP Implicit style of definition通过反馈循环给出了视听说明.但我想知道如何准确理解图表？什么是真正的优势,是否有任何背景知识？

再举一个例子,不是在Scheme中,而是在Haskell中:

fibs = fix (scanl (+) 0 . (1:))
fibs = fix ((0:) . scanl (+) 1)

我们还可以绘制两者的信号流图.我们如何利用这些图表？

感谢您的建议和信息!

我需要从Scala访问大量Java接口.这些接口有可能返回Null的方法,我想将它们转换为Option[T]

我找到了其他Option.apply()类似的答案

如何将可以为null或数组的值隐式包装到Scala选项中

选项化Java getter

但是,这要求对于每个Java接口,我手动创建一个Scala包装器.像这样...

class ScalaFoo extends JavaFoo {
  def bar = Option(super.bar)
}

这似乎很乱,很难维护,容易出错.我不希望所有那些无效的额外代码,我想自动包装所有Java接口,这样如果一个更改,包装器也会改变.

当然,有一种方法可以用implicits做到这一点,不是吗？

基本上,如果我想要这样的东西,

double b = sin(2.2);

但不小心写了这样的东西,

double b = sin(2.2f);

没有错误甚至是警告信息,即使这显然会导致不同的,不准确的,因此不正确的结果.通过强制编译器不执行float到double的任何隐式转换,可以防止这种类型的错误.有没有办法实现这一点,无论是通过编译开关(最好是在Visual Studio中),一些智能宏,还是一个行为像float/double变量并声明自己的运算符的类？

编辑:我也有兴趣使用运算符(例如double b = 2.2f*2.2f)或赋值(double b = 2.2f)解决类似的问题.

为什么scala不能在这里找到隐含的？

class A

class Foo {
  lazy val x = implicitly[A]
  implicit lazy val a = new A
}

错误:找不到参数e的隐含值:A

但这很好用:

class Foo {
  lazy val x = implicitly[A]
  implicit lazy val a: A = new A // note explicit result type
}

定义了类Foo

FWIW我在这个应用程序上遇到了Scala 2.10.此外,更换lazy val用def似乎并没有改变任何东西.

在我的实际应用程序中,我有一个文件,其中包含为各种域对象定义的一系列implicits,其中一些依赖于彼此.尝试以一种确保所有依赖关系都出现在各自家属之前的方式来安排它们似乎是一场噩梦,因此我将它们全部标记为lazy.必须明确声明每个val的类型混淆代码,似乎应该是不必要的.有什么方法吗？

case class Cat(name: String)

object CuterImplicits {
  implicit class CatCuteChecker(c: Cat) {
    def isCute(c: Cat) = true
  }
}

trait CuteChecker[A] {
  def isCute(a: A): Boolean
}

object CheckingForCuteness {
  def isItCute[A](a: A) = implicitly[CuteChecker[A]].isCute(a)
}

object Main extends App {
  CheckingForCuteness.isItCute[Cat](Cat("funny"))
}

怎么修:

错误:(17,37)找不到参数e的隐含值:CuteChecker [A] def isItCute [A](a:A)=隐式[CuteChecker [A]].isCute(a)^

这是我为jqGrid创建Json响应的代码,以及用于定义单元成员的新关键字,我收到以下消息"找不到隐式类型数组的最佳类型".

var resRows = results.Select(record => 
            new 
            {
                id = record.Reference,
                cell = **new** []
                {
                    record.Reference,
                    record.TradeDate.ToShortDateString(),
                    record.Currency1,
                    record.Currency2,
                    record.Notional.ToString(),
                    record.EffectiveDate.ToShortDateString(),
                    record.Quote.ToString()                        
                }
            }).ToArray();

我在这做错了什么？

我有一个方法,它采用带有隐式视图边界的类型参数.使用无效数据类型调用方法时,是否可以使用@implicitNotFound批注来提供更好的编译器错误？

该方法的文档是无用的,甚至源代码也无济于事,所有在线使用的例子都处于特征或类级别.

案例类在scala中似乎没有隐式排序.

scala> case class A(i:Int)
defined class A

scala> implicitly[Ordering[A]]
<console>:10: error: No implicit Ordering defined for A.
              implicitly[Ordering[A]]

我想知道是否总是为所有案例类定义一个隐式排序,如果不是,至少有一种方法可以为相同成员类型的案例类/案例类的每个arity定义隐式排序.