标签: implicit-conversion

如何表达(隐式conv:String => A)作为视图绑定

我问自己什么是视图绑定相当于

(implicit conv: String => A)
Run Code Online (Sandbox Code Playgroud)

我的第一次尝试是简单地声明类型参数A,如下所示:

[String <% A]
Run Code Online (Sandbox Code Playgroud)

但Scala编译器抱怨"未找到:类型A".

有什么建议?

scala implicit-conversion implicits view-bound

3
推荐指数
1
解决办法
410
查看次数

键入(变量)vs(Type)变量

可能重复:(
类型)值和类型(值)之间有什么区别?

我主要是一个C#开发人员,因此使用以下语法进行大量显式转换:(type)variable以with (int)100.0004d为例.因此,在用C++编写代码时,我经常使用相同的语法.然而,我看到(甚至使用)在同样的铸造是使用语法实现其他情况下的代码type(variable)与int(100.0004)作为一个例子.

我很好奇这两种方法之间的区别是什么,以及使用一种方法是否有任何影响.

例:

double someDouble = 100.00456;

// Cast the double using the (type)variable syntax
int firstCastValue = (int)someDouble;

// Cast the double using the type(variable) syntax
int secondCastValue = int(someDouble);
Run Code Online (Sandbox Code Playgroud)

c++ casting type-conversion implicit-conversion

3
推荐指数
1
解决办法
268
查看次数

Scala 2.9中定义的Numeric和Double之间的隐式转换在哪里?

我一直在研究一些编译得很好的scala代码,但不知怎的,我已经打破了隐含的转换,我无法弄清楚我做错了什么.将它归结为一个非常简单的情况,这段代码不能编译,原因似乎是我没有导入Double和Numeric [Double]之间的隐式转换:

import scala.math.Numeric
import scala.math.Numeric._
import scala.math.Numeric.Implicits._
import Ordering.Implicits._

object ImplicitNumericConversions {
  val v: Numeric[Double] = 3.0
}
Run Code Online (Sandbox Code Playgroud)

我可以通过提供自己的功能来轻松解决这个问题:

import scala.math.Numeric

object ImplicitNumericConversions {
  def convertDoubleToNumeric(d: Double)(implicit num: Numeric[Double]): Numeric[Double] = num

  val v: Numeric[Double] = convertDoubleToNumeric(3.0)
}
Run Code Online (Sandbox Code Playgroud)

如果我隐式转换函数,那么我得到我正在寻找的东西:

import scala.math.Numeric

object ImplicitNumericConversions {

  implicit def convertDoubleToNumeric(d: Double)(implicit num: Numeric[Double]): Numeric[Double] = num

  val v: Numeric[Double] = 3.0
}
Run Code Online (Sandbox Code Playgroud)

...但为什么scala.math.Numeric的导入不能为我做这个?

我正在处理的实际问题如下:

class NumericRange[T <% Numeric[T]](val lower: T, val upper: T) { ... }

object NumericRange {

  def apply[T](lower: T, …
Run Code Online (Sandbox Code Playgroud)

scala numeric implicit-conversion

3
推荐指数
1
解决办法
1559
查看次数

没有隐式视图可用于部分应用的方法

所以我有以下方法包装一个类似Seq的对象Option.

def noneIfEmpty[S <% Seq[_]](seq: S): Option[S] = {
  if (seq.isEmpty) None else Some(seq)
}
Run Code Online (Sandbox Code Playgroud)

我希望能够使用这种方法来转换包含在中的计算结果Try.说我这样做List[Int]:

scala> val tryList = Try(List(1,2,3))
tryList: scala.util.Try[List[Int]] = Success(List(1, 2, 3))
Run Code Online (Sandbox Code Playgroud)

我应该可以noneIfEmpty用来映射Try[List[Int]]到a Try[Option[List[Int]]].如果我使用匿名函数并明确地将列表传递给noneIfEmpty...,这可以正常工作

scala> tryList map (list => noneIfEmpty(list))
res1: scala.util.Try[Option[List[Int]]] = Success(Some(List(1, 2, 3)))
Run Code Online (Sandbox Code Playgroud)

...但是如果我尝试noneIfEmpty作为部分应用函数传递它会中断.

scala> tryList map noneIfEmpty _
<console>:40: error: No implicit view available from S => Seq[_].
              tryList map noneIfEmpty _
                          ^
Run Code Online (Sandbox Code Playgroud)

如果我缩小 …

scala implicit implicit-conversion

3
推荐指数
1
解决办法
3202
查看次数

Scala - 定义自己的中缀运算符

采用单个参数的方法可以写为Scal中的中缀运算符.即添加*(other:C) = foo(this, other)到C类,将允许我们写c1 * c2而不是foo(c1,c2).但是有没有办法在现有的类上定义中缀操作符,而这些操作符无法修改?

例如,如果我想写c1 + c2而不是xor(c1,c2),在哪里c1,c2:Array[Byte],我显然无法修改Array-Class.

我发现了这个并尝试过

implicit class Bytearray(a1:Array[Byte]) extends Anyval {
    def +(a2:Array[Byte]) = xor(a1,a2)
}
Run Code Online (Sandbox Code Playgroud)

但这似乎不起作用(c1 + c2).

类型不匹配,预期:字符串,实际:数组[字节]

我想也许这个问题是我使用的+,所以我交换了它,xor 但c1 xor c2只是导致了

无法解析符号xor

有什么建议?

UPDATE

有趣.我有一个class Foo与object Foo它下面的定义中,包含隐含的类.这导致上述错误.

但是,删除对象,而是将隐式类放入a trait BytearrayHandling然后扩展它(class Foo extends BytearrayHandling)似乎工作.这是为什么?

scala operators infix-notation infix-operator implicit-conversion

3
推荐指数
1
解决办法
2478
查看次数

隐式转换如何与运算符重载一起使用?

比方说,如果我出于某种原因在float类型周围创建一个薄包装器,如下所示:

public class WrappedFloat
{

    private float value;

    public WrappedFloat(float value)
    {
        this.value = value;
    }

    public static implicit operator float(WrappedFloat wrapped)
    {
        return wrapped.value;
    }

    public static implicit operator WrappedFloat(float value)
    {
        return new WrappedFloat(value);
    }

}
Run Code Online (Sandbox Code Playgroud)

这段代码显然是完全有效的:

new WrappedFloat(4.0F) + new WrappedFloat(3.0F)
Run Code Online (Sandbox Code Playgroud)

由于WrappedFloat没有定义任何算术运算符,因此必须有一些关于它的隐式转换以float允许它.但是运算符重载只是方法的语法糖,对吧?这不像我可以调用方法(即CompareTo)WrappedFloat因为float有它们.那么这里的运营商有什么特别之处呢?允许这样做的规则是什么?

c# operator-overloading implicit-conversion

3
推荐指数
1
解决办法
186
查看次数

Scala:如何用隐式参数定义匿名函数?

我想以这样的方式定义一个带隐式参数的函数:

// imports to add scope of A

{
  implicit a: A => {
    // some action
  }
}.apply()

// somewhere in the code           

class A

val a: A = new A
Run Code Online (Sandbox Code Playgroud)

但是我的Scala编译器没有编译它.它说:Cannot resolve reference apply with such signature.但是,参数是隐式的,所以我猜编译器应该在范围内查找并找到一个合适的对象.

这是真的吗?如果没有,那么我该如何解决呢?

scala implicit-conversion

3
推荐指数
1
解决办法
2076
查看次数

为什么不对转换构造函数进行隐式转换?

所以我有这个代码:

struct Foo {
    Foo() { cout << "default\n"; }
    Foo(const long long) { cout << "implicit\n"; }
};

struct Bar {
    Bar(const short param) : param(param) {}
    operator long long() const { return static_cast<long long>(param); }
    const short param;
};
Run Code Online (Sandbox Code Playgroud)

我本以为Foo foo = Bar(13)会使用我的隐式转换然后转换构造函数.但它错误:

错误:从请求转换Bar为非标量类型Foo

这工作正常:Foo foo(Bar(13)).为什么我的隐式转换用于显式转换构造,而不用于隐式转换构造?

我从https://en.cppreference.com/w/cpp/language/copy_initialization获得的规则说:

转换的结果,如果使用转换构造函数,则是prvalue表达式,然后用于直接初始化对象

c++ constructor implicit-conversion typecast-operator explicit-conversion

3
推荐指数
1
解决办法
75
查看次数

使C++自动将int转换为double

当我有一个数字类型,它定义operator<为double,但不是int,与int literals的比较不起作用.这是一个问题,作为标准库的一部分,即std::complex包含int文字.

在使用类型时,我可以使编译器将int文字视为double吗?

简化示例:

// the defined operator
template<typename T>
bool operator<(const Type<T> &lhs, const T &rhs);

complex<Type<T>> complex_number;
1.0 / complex_number; // this fails
Run Code Online (Sandbox Code Playgroud)

失败发生在at 的_Div方法中std::complex

template<class _Other> inline
void _Div(const complex<_Other>& _Right)
    // ...
    else if ((_Rightimag < 0 ? -_Rightimag : +_Rightimag)
Run Code Online (Sandbox Code Playgroud)

这会导致错误:

error C2678: binary '<': no operator found which takes a left-hand operand of type 'Type<T>' (or there is no acceptable conversion)
(...)
complex(665): note: while trying to …
Run Code Online (Sandbox Code Playgroud)

c++ implicit-conversion ceres-solver

3
推荐指数
1
解决办法
520
查看次数

我可以防止将参数隐式转换为赋值运算符

我正在实现一个类型(TParameter),该类型必须是布尔值(以指示该值是否有效)和任意类型的数据值。

想法是,如果方法采用某种类型的参数,则可以将其设置为false,以指示该值无效。

像这样:

someVariable = 123;   // use the value 123
someVariable = false; // mark variable as invalid/to-be-ignored
Run Code Online (Sandbox Code Playgroud)

我的代码的简化版本:

template <class T>

class TParameter
{
  public:
    TParameter()
    : m_value(),
      m_valid(false)
    {}

    // assignment operators
    TParameter& operator= (const T& value)
    {
      m_value = value;
      m_valid = true;
      return *this;
    }

    TParameter& operator= (bool valid)
    {
      m_valid = valid;
      return *this;
    }

  private:
    T m_value;
    bool m_valid;
};

  void test()
  {
    TParameter<int16_t> param;

    param = false;
    param …
Run Code Online (Sandbox Code Playgroud)

c++ templates implicit-conversion

3
推荐指数
1
解决办法
92
查看次数