标签: implicit

在我看来,隐式本地化优于显式本地化的优势在于,如果您有一个以上的属性可以为给定控件进行本地化,那么这是一种更经济的语法.

在你只需要本地化一些文本的情况下,我使用asp:Localize控件,它只有一个属性(Text)呈现给UI.是否有理由使用其中一个？任何风格偏好？有速度差异吗？

含蓄

<asp:Localize ID="Localize1" runat="server" meta:resourcekey="Something" />

VS

明确的

<asp:Localize ID="Localize1" runat="server" Text="<%$ Resources:Something %>" />

为什么Scala无法优化以下内容:

一个.

implicit def whatever[A](a: A) = new { ... }

至:

湾

class some$generated$name(a: A) {
  ...
}
implicit def whatever[A](a: A) = new some$generated$name(a)

？

为什么在这种情况下必须使用结构类型？我希望Scala编译器能够执行这种优化,因为写入样式b太丑了(因为,1.逻辑的局部性丢失了,2.你必须不必要地为这些额外的显式类创建名称),而且a的性能要差得多比b.

我好奇.大多数Perl隐式调用的子例程必须以全部大写字母命名.TIESCALAR,DESTROY等实际上perldoc perltoot说

如果构造函数可以有任意名称,那么为什么不使用析构函数呢？因为虽然显式调用了构造函数,但析构函数不是.破坏通过Perl的垃圾收集(GC)系统自动发生,这是一个快速但有些懒惰的基于参考的GC系统.要知道要调用什么,Perl坚持将析构函数命名为DESTROY.Perl关于调用析构函数的正确时间的概念目前还没有明确定义,这就是为什么你的析构函数在被调用时不应该依赖它们的原因.

为什么DESTROY全部上限？Perl有时会使用纯大写的函数名作为约定来表示Perl会以某种方式自动调用该函数.隐式调用的其他函数包括BEGIN,END,AUTOLOAD,以及perltie中描述的绑定对象使用的所有方法.

那么为什么import子程序是小写的呢？有没有人对此有很好的了解？

我想放宽对特征类型参数的约束,而是将它们以证据参数的形式强加给方法.鉴于一些骨架设置:

trait State[Repr]
object Observer {
  def apply[Repr <: State[Repr]](reader: Reader[Repr]): Observer[Repr] = 
    new Observer[Repr] {}
}
trait Observer[A]
trait Reader  [A]

这有效:

trait StateX[Repr <: StateX[Repr]] extends State[Repr] { 
  protected def reader: Reader[Repr]
  def observe: Observer[Repr] = Observer(reader)
}

而这不是:

trait StateY[Repr] extends State[Repr] { 
  protected def reader: Reader[Repr]
  def observe(implicit ev: Repr <:< State[Repr]): Observer[Repr] = Observer(reader)
}

随着消息"inferred type arguments [Repr] do not conform to method apply's type parameter bounds [Repr <: State[Repr]]".由于证据ev表明这种构象,我想知道如何 …

这是我为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批注来提供更好的编译器错误？

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

我试图弄清楚如何编写一个适用于任何函数的函数交换函数Traversable[_],给定一个集合和交换索引.我想出了以下内容:

def swap[A, CC <% Traversable[A]](xs: CC, i: Int, j: Int): Traversable[A] = {
  xs.slice(0, i) ++ 
    xs.slice(j, j+1) ++ 
    xs.slice(i+1, j) ++ 
    xs.slice(i, i+1) ++ 
    xs.slice(j+1, xs.size)
}

swap(List(1,2,3,4,5), 0, 4) // => List(5,2,3,4,1)

我想知道如何将它变成Traversable的隐式扩展,让我可以调用它List(1,2,3,4,5).swap(0, 4).我能得到的最接近的是:

import language.implicitConversions
class RichTraversable[A, B <% Traversable[A]](xs: B) {
  def swap(i: Int, j: Int): Traversable[A] = {
    xs.slice(0, i) ++ 
      xs.slice(j, j+1) ++ 
      xs.slice(i+1, j) ++ 
      xs.slice(i, i+1) ++ 
      xs.slice(j+1, xs.size)
  }
} 
implicit def richTraversable[A, B <% Traversable[A]](ys: …

假设我有代码:

class A(implicit s:String = "foo"){println(s)}

object X {
   implicit val s1 = "hello"
}
object Y {
   import X._
   // do something with X
   implicit val s2 = "hi"
   val a = new A
}

我收到错误:

<console>:14: error: ambiguous implicit values:
 both value s2 in object Y of type => String
 and value s1 in object X of type => String
 match expected type String
           val a = new A

有什么办法,我可以告诉斯卡拉利用价值s2的Y？(如果我重新命名s2到s1,它工作正常,但是这不是我想要的). …

如果你像我一样,你偶尔想要为Scala集合或序列编写增强的方法,但是你想要绑定集合类型以及元素类型,而不仅仅是向Seq [T]进行upcast.

给出以下代码:

val javaLong: java.lang.Long = null
val opt: Option[Long] = Option(javaLong)

我期望选择,None但出于某种原因,它是Some(0).我也发现了这个bug,看来隐式转换发生在option的apply方法之前.我认为这仍然是一个错误,因为人们不会期望这种行为,我想知道是否有任何解决方法或一些更好的方法来包装空值.

更新:上面的代码只是一个简化的部分.真实的例子是这样的:

Person(Option(doc.getLong()))

人是:

 case class Person(id: Option[Long])

和方法doc.getLong()是返回java.lang.Long的java方法