标签: implicit

最近引入了方法的重载,应用程序开始失败.最后跟踪它,新的方法被调用,我没想到它.

我们有

setValue( const std::wstring& name, const std::wstring& value );

std::wstring avalue( func() );
setValue( L"string", avalue );
std::wstring bvalue( func2() ? L"true", L"false" );
setValue( L"bool", bvalue );
setValue( L"empty", L"" );

它被更改为当存储bool值时我们使用相同的字符串(字符串的内部数据存储)

setValue( const std::wstring& name, const std::wstring& value );
setValue( const std::wstring& name, const bool& value );

std::wstring avalue( func() );
setValue( L"string", avalue );
setValue( L"bool", func2() );
setValue( L"empty", L"" ); << --- this FAILS!?!

L""的问题在于它是隐式转换,之前它很高兴成为std :: wstring,但它不喜欢是bool.MSVC编译器没有抱怨或提出警告,所以我担心即使我"修复"了setValue(L"空",L""); 成为

setValue( L"empty", std::wstring() );

别人可能会稍后来,只需使用setValue(L"空",L""); 并且必须再次追踪这个问题. …

该sum方法的签名TraversableOnce如下:

def sum[B >: A](implicit num: Numeric[B]): B = foldLeft(num.zero)(num.plus)

我可以这样使用它:

scala> (1 to 10).sum
res0: Int = 55

在这种情况下,编译器会注入Numeric[B]自身,因此在范围内必须有这种类型的明确隐式值.如果我Predef.implicitly自己注射它,会发生这种情况:

scala> (1 to 10).sum(implicitly)
<console>:6: error: ambiguous implicit values:
 both method conforms in object Predef of type [A]<:<[A,A]
 and method stringCanBuildFrom in object Predef of type => scala.collection.generic.CanBuildFrom[String,Char,String]
 match expected type T
   (1 to 10).sum(implicitly)
                 ^

为什么这个含糊不清？

我可以使模糊性消失

scala> (1 to 10).sum(implicitly[Numeric[Int]])
res2: Int = 55

要么

scala> (1 to 10).sum[Int](implicitly)
res3: …

我最近开始研究游戏和反应性mongo.引用了响应式mongo文档来创建SimpleAlbum.当我运行播放应用程序时,我收到一个错误,如"隐式修饰符不能用于顶级对象".我为什么要这个？帮助我解决问题.谢谢

package models

import org.joda.time.DateTime
import reactivemongo.bson._


case class SimpleAlbum(
                    title: String,
                    releaseYear: Int,
                    hiddenTrack: Option[String],
                    allMusicRating: Option[Double])

implicit object SimpleAlbumWriter extends BSONDocumentWriter[SimpleAlbum] {
def write(album: SimpleAlbum): BSONDocument = BSONDocument(
   "title" -> album.title,
   "releaseYear" -> album.releaseYear,
   "hiddenTrack" -> album.hiddenTrack,
   "allMusicRating" -> album.allMusicRating)
}

implicit object SimpleAlbumReader extends BSONDocumentReader[SimpleAlbum] {
def read(doc: BSONDocument): SimpleAlbum = {
SimpleAlbum(
  doc.getAs[String]("title").get,
  doc.getAs[Int]("releaseYear").get,
  doc.getAs[String]("hiddenTrack"),
  doc.getAs[Double]("allMusicRating"))
 }
}

我使用Scala隐式类来扩展我经常使用的对象.作为一个例子,我有一个类似于Spark上定义的方法DataFrame:

implicit class DataFrameExtensions(df: DataFrame) {
  def deduplicate: Boolean = 
    df.groupBy(df.columns.map(col): _*).count
}

但是如果类已经定义了相同的方法,则不会调用隐式defs.如果我以后升级到定义DataFrame#deduplicate方法的新版Spark,会发生什么？客户端代码将静默切换到新的实现,这可能会导致细微的错误(或明显的错误,这些问题较少).

使用反射,如果在我的隐式定义它之前已经定义,我可以抛出运行时错误.从理论上讲,如果我的隐式方法与现有方法冲突,我可以检测它并重命名我的隐式版本.但是,一旦我升级Spark,运行应用程序并检测问题,使用IDE重命名旧方法为时已晚,因为现在任何引用都引用了本机Spark版本.我将不得不恢复我的Spark版本,通过IDE重命名该方法,然后再次升级.不是世界末日,而是一个伟大的工作流程.DataFramededuplicatedf.deduplicate

有没有更好的方法来处理这种情况？如何安全地使用"皮条客我的图书馆"模式？

为了使我的枚举更加类型安全,我一直在使用宏生成的重载运算符来禁止将枚举与除了相同类型的枚举之外的任何内容进行比较:

#include <boost/static_assert.hpp>

#define MAKE_ENUM_OPERATOR_TYPESAFE(enumtype, op) \
  template<typename T> \
  inline bool operator op(enumtype lhs, T rhs) \
  { \
    BOOST_STATIC_ASSERT(sizeof(T) == 0); \
    return false; \
  } \
  \
  template<> \
  inline bool operator op(enumtype lhs, enumtype rhs) \
  { \
    return static_cast<int>(lhs) op static_cast<int>(rhs); \
  }

#define MAKE_ENUM_TYPESAFE(enumtype) \
  MAKE_ENUM_OPERATOR_TYPESAFE(enumtype, ==) \
  MAKE_ENUM_OPERATOR_TYPESAFE(enumtype, !=) \
  MAKE_ENUM_OPERATOR_TYPESAFE(enumtype, >) \
  MAKE_ENUM_OPERATOR_TYPESAFE(enumtype, <) \
  MAKE_ENUM_OPERATOR_TYPESAFE(enumtype, >=) \
  MAKE_ENUM_OPERATOR_TYPESAFE(enumtype, <=)

// Sample usage:
enum ColorType { NO_COLOR, RED, BLUE, GREEN };
MAKE_ENUM_TYPESAFE(ColorType) …

根据标准的Android文档,启动服务(启动服务)的首选方法是使用如下的显式意图:

// Using explicit intent:
Intent serviceIntent = new Intent(getApplicationContext(), MyService.class);
// or:
Intent serviceIntent = new Intent(this, MyService.class);
startService(serviceIntent);

您还可以使用带有清单中指定的操作字符串的隐式intent来启动/停止服务,如下所示:

// Using implicit intent:
static final String serviceAction = "com.example.my.app.services.MYSERVICE";
Intent serviceIntent = new Intent(serviceAction);
startService(serviceIntent);

// AndroidManifest.xml:
<service android:name="com.example.my.app.services.MyService"
   android:exported="false" android:process=":services" >
   <intent-filter>
      <!-- Start/Stop service -->
      <action android:name="com.example.my.app.services.MYSERVICE" />
   </intent-filter>
</service>

当服务仅在本地使用时(不允许第三方应用程序启动或绑定它),文档说明您不应在清单服务标记中包含intent-filter,并且应将导出的标记设置为false.

注意:活动和服务在不同的进程(:application和:services进程)中运行.活动和服务之间的通信是通过实现AIDL接口完成的(这样做是因为只有AIDL远程接口允许我在需要同时处理IPC的服务中进行多线程,不仅在活动之间,而且主要在以下运行的服务之间进行:服务流程).

我的问题是:

问题1:当我在我的应用程序中使用的活动和服务在两个不同的进程中运行时,我是否需要使用隐式意图而不是显式意图来启动和停止服务？

Q2:当:应用程序进程消失(销毁,不再在内存中)并且:服务进程在后台运行时,如何再次从新的:应用程序进程连接到已运行的:services进程？不知何故,我需要再次获得对:services进程的引用,以便我可以在该进程中停止正在运行的服务.使用AIDL afaik无法做到这一点.

问题是Android可以并且将在资源不足时轻松破坏:应用程序进程,只要:services进程继续运行,我就可以了.(是的,我知道通过将服务设置为前台服务等来影响流程,我也可以阅读手册;)但这不是我的问题).

当活动和服务处于分离的进程中并使用AIDL时,我无法找到与我的问题相关的任何信息或答案,并且当:应用程序进程需要在Android被杀死之后再次"找到":服务进程时用户再次进入应用程序(之后他/她离开应用程序).

欢迎任何专家级的建议.

假设我有两组类,第一组继承自Foo,第二组继承自Bar.

class Foo
class Baz extends Foo
class Bar
class Qux extends Bar

我想创建一个通用的隐式转换函数,将任何Foo转换为Bar,因为范围内有隐式转换器类型.

trait Converter[A <: Foo, B <: Bar] {
  def convert(a : A) : B
}

implicit object BazToQuxConverter extends Converter[Baz, Qux] {
  def convert(a : Baz) : Qux = new Qux
}

implicit def FooToBar[A <: Foo, B <: Bar](a : A)(implicit converter : Converter[A, B]) : B = converter.convert(a)

不幸的是,这似乎不像我期望的那样有效.当我将以下行插入REPL时:

val a : Baz = new Baz
val b : Qux = a

...我收到以下错误:

<console>:17: …

我一直在阅读有关Scala类型级编程的一些内容.主要是Apocalisp博客,也是Alexander Lehmann的youtube演讲.

我有点卡在我认为可能非常基本的东西上,这是使用隐式比较两种类型,如下所示:

implicitly[Int =:= Int]

Apocalisp博客上的Mark说:

这对于捕获范围内的隐式值并且具有类型T非常有用.

我知道如何使这项工作,但我不知道为什么它的工作,所以不想继续前进.

在上面的情况下,在范围内有一个隐式的"Int"类型,"隐式"从以太中获取,允许代码编译？这与'function1'的返回类型如何相符？

res0: =:=[Int,Int] = <function1>

此外,这隐含的来自哪里？在我的特质'Foo'的情况下,为什么呢

implicitly[Foo =:= Foo] 

编译？在这种情况下,'Foo'隐含在哪里？

如果这是一个非常愚蠢的问题,请提前道歉,并感谢您的帮助!

有没有办法为两个不同的类定义相同的隐式排序？

我尝试沿着以下几行做一些事情,但它没有检测到排序.

abstract class Common
case class A extends Common
case class B extends Common

implicit val KeyOrdering = new Ordering[Common] {
    override def compare(x: Common, y: Common): Int = {
      x.toString.compareTo(y.toString)
   }
}

Ctrl + Q 找到隐式转换

Shift + Cmd + P 找到隐式参数实例的位置

如何找到隐含值/ def的使用位置？