标签: implicit-conversion

有人可以解释我在Scala中的隐式转换吗?

更具体地说,BigInt如何将convert int转换为BigInt?

在源代码中,它读取:

...
implicit def int2bigInt(i: Int): BigInt = apply(i)
...
Run Code Online (Sandbox Code Playgroud)

这个代码是如何被调用的?

我可以理解另一个样本:"日期文字"是如何工作的.

在.

val christmas = 24 Dec 2010  
Run Code Online (Sandbox Code Playgroud)

被定义为:

implicit def dateLiterals(date: Int) = new {
  import java.util.Date  
  def Dec(year: Int) = new Date(year, 11, date)
}
Run Code Online (Sandbox Code Playgroud)

当intget Dec使用intas参数传递消息时,系统会查找另一个可以处理请求的方法,在本例中Dec(year:Int)

Q1.我是否正确理解日期文字?

Q2.它如何适用于BigInt?

谢谢

scala implicit-conversion

10
推荐指数
2
解决办法
5285
查看次数

使用==比较整数和字符串时JavaScript中的隐式数据类型转换

代码:

var num = 20;

if(num == "20")
{
    alert("It works");
}
else
{
    alert("Not working");
}
Run Code Online (Sandbox Code Playgroud)

问题:

  1. 在C编程中,我们有一个规则名称数据类型提升,当存在混合数据类型时(例如:添加整数和浮点),整数将在执行加法之前首先转换为浮点.

  2. 上面的代码将提示我一个警告框,"It works"其中显示的消息显示if测试条件评估为true.

  3. 对于松散类型的JavaScript,我只是好奇:有没有像C这样的规则决定在哪种情况下执行哪个转换?除此之外,上面的JavaScript代码num在进行比较之前将变量值从整数值转换为字符串值,反之亦然?

javascript comparison-operators implicit-conversion

10
推荐指数
2
解决办法
2万
查看次数

Scala:类型参数类的隐式证据

这是一个带有两个特征的简单设置,一个具有由前一个特征限定的协变类型参数的类,另一个类具有由另一个类限定的类型参数.对于这两个类,只有当两个特征中的一个作为类型参数的基础时,才能使用特定方法(通过隐式证据).编译好:

trait Foo
trait ReadableFoo extends Foo {def field: Int}

case class Bar[+F <: Foo](foo: F) {
  def readField(implicit evidence: F <:< ReadableFoo) = foo.field
}

case class Grill[+F <: Foo, +B <: Bar[F]](bar: B) {
  def readField(implicit evidence: F <:< ReadableFoo) = bar.readField
}
Run Code Online (Sandbox Code Playgroud)

但是,由于Bar是协变的F,我不应该需要F参数Grill.我应该要求它B是一个子类型Bar[ReadableFoo].但是,这失败了:

case class Grill[+B <: Bar[_]](bar: B) {
  def readField(implicit evidence: B <:< Bar[ReadableFoo]) = bar.readField
}
Run Code Online (Sandbox Code Playgroud)

有错误:

error: Cannot prove that Any …
Run Code Online (Sandbox Code Playgroud)

scala implicit-conversion type-parameter

10
推荐指数
2
解决办法
5845
查看次数

我应该何时在C#中定义(显式或隐式)转换运算符?

C#的一个鲜为人知的特性是可以创建隐式或显式的用户定义类型转换.我已经写了6年的C#代码了,我从来没有用过它.所以,我担心我可能错过了很好的机会.

什么是用户定义转换的合法,良好用途?您是否有比仅定义自定义方法更好的示例?

-

事实证明,微软有一些关于转换的设计指南,其中最相关的是:

如果最终用户未明确预期此类转换,请勿提供转换运算符.

但什么时候转换"预期"?在玩具编号课程之外,我无法弄清楚任何真实世界的用例.


以下是答案中提供的示例摘要:

  • 弧度/度/双
  • 极地/的Point2D
  • 开尔文/华氏/摄氏度

模式似乎是:隐式转换大多数(仅?)在定义数值/值类型时很有用,转换由公式定义.回想起来,这是显而易见的.不过,我想知道非数字类是否也可以从隐式转换中受益..?

c# casting operator-overloading implicit-conversion explicit-conversion

10
推荐指数
2
解决办法
2214
查看次数

java operator + =中的隐式转换

我发现java编译使用int和float有关于赋值和自赋值语句的非期望行为.

以下代码块说明了错误.

    int i = 3;
    float f = 0.1f;

    i += f;              // no compile error, but i = 3
    i = i + f;           // COMPILE ERROR
Run Code Online (Sandbox Code Playgroud)
  • 在自我赋值中i += f,编译不会发出错误,但是exaluation的结果是带有值的int 3,并且变量i保持该值3.

  • 在i = i + f表达式中,编译器发出错误"错误:可能丢失精度"消息.

有人可以解释这种行为.

编辑:我已在https://compilr.com/cguedes/java-autoassignment-error/Program.java中发布此代码块

java compiler-errors implicit-conversion

10
推荐指数
1
解决办法
1267
查看次数

C# - 动态对象的隐式构造函数

鉴于以下内容class:

public class DataPair{
    public string Key { get; set; }
    public object Value { get; set; }

    public DataPair(string key, object value)
    {
        Key = key;
        Value = value;
    }
}
Run Code Online (Sandbox Code Playgroud)

有没有机会实现类似的东西

public static implicit operator DataPair(dynamic value)
{
    return new DataPair(value.Key, value.Value);
}
Run Code Online (Sandbox Code Playgroud)

所以我可以用这种方式创建一个新实例

DataPair myInstance = {"key", "value"};
Run Code Online (Sandbox Code Playgroud)

c# constructor dynamic implicit-conversion

10
推荐指数
2
解决办法
1594
查看次数

类型别名函数类型的隐式转换类无法在Scala中编译

在scala中,以下代码正确编译:

class a {}
class b {}

object Main {

  implicit class Conv[f, t](val v: f ? t) extends AnyVal {
    def conv = v
  }

  def main(args: Array[String]) {
    val m = (a: a) ? new b
    m.conv
  }
}
Run Code Online (Sandbox Code Playgroud)

但由于某种原因,以下无法编译:

class a {}
class b {}

object Main {
  type V[f, t] = f ? t

  implicit class Conv[f, t](val v: V[f, t]) extends AnyVal {
    def conv = v
  }

  def main(args: Array[String]) {
    val m = …
Run Code Online (Sandbox Code Playgroud)

scala implicit-conversion

10
推荐指数
1
解决办法
176
查看次数

链接通过最短路径牵连

问题

我有一组类型和一组转换.这听起来像DAG并且与它有一些相似之处.如果可行,我希望能够在任意两种类型之间计算隐式最短的转换路径.

我准备了一个简单的例子,表明我徒劳地试图宣布这样的含义.

final case class A(u : Int)
final case class B(u : Int)
final case class BB(u : Int)
final case class C(u : Int)
final case class D(u: Int)

trait Convert[F,T] {
  def convert(source : F) : T
}
Run Code Online (Sandbox Code Playgroud)

我介绍以下测试用例转化:A - > B,A - > BB,B - > C,B - > d,C - > d.

我尝试了两种方法,它们给了我不同的隐式分辨率错误.

过境链

trait ConcreteConvert[F,T] extends Convert[F,T]

class Transit[F,M,T](implicit fm : ConcreteConvert[F,M], mt : Convert[M,T]) extends Convert[F,T] {
  override def convert(source …
Run Code Online (Sandbox Code Playgroud)

scala implicit-conversion

10
推荐指数
1
解决办法
202
查看次数

将指向typed/size enum的指针转换为指向底层类型的指针是否安全?

以下代码:

void f(const uint8_t* a) {}  // <- this is an external library function
enum E : uint8_t { X, Y, Z };

int main(void) {
  E e = X;
  f(&e);  // <- error here
}
Run Code Online (Sandbox Code Playgroud)

产生以下错误:

/tmp/c.cc:10:3: error: no matching function for call to 'f'
  f(&e);
  ^
/tmp/c.cc:5:6: note: candidate function not viable: no known conversion from 'E *' to 'const uint8_t *' (aka 'const unsigned char *') for 1st argument
void f(const uint8_t* e) { }
Run Code Online (Sandbox Code Playgroud)

这对我来说是令人惊讶的,因为我认为: …

c++ enums pointers implicit-conversion c++11

10
推荐指数
2
解决办法
608
查看次数

为什么在(* x).into()中需要显式取消引用,而在x.my_into()中却不需要?

在阅读了方法调用表达式,解引用运算符,方法查找和自动解引用之后,我认为我对该主题有了很好的理解。但是后来我遇到了一种情况,我希望自动重新引用会发生,而实际上却没有发生。

示例如下。

#[derive(Clone, Copy, Debug)]
struct Foo();

impl Into<&'static str> for Foo {
    fn into(self) -> &'static str {
        "<Foo as Into>::into"
    }
}

fn vec_into<F: Copy + Into<T>, T>(slice: &[F]) -> Vec<T> {
    slice.iter().map(|x| (*x).into()).collect()
}

fn main() {
    let array = [Foo(), Foo(), Foo()];
    let vec = vec_into::<_, &'static str>(&array);
    println!("{:?}", vec);
}
Run Code Online (Sandbox Code Playgroud)

上面的代码有效,但是我认为不需要(*x).into()在函数中vec_into进行显式取消引用。我的理由是,因为x: &Foo,然后x.into()就试图找到接受类型的方法&Foo,&&Foo,&mut &Foo, …

traits dereference implicit-conversion rust

10
推荐指数
1
解决办法
151
查看次数