精华内容
下载资源
问答
  • implicit

    2018-01-12 16:32:32
    当涉及到用户自定义的类时,可以在定义一个类时,使用implicit定义该类,之后就允许将该类的对象隐式转换为另一个类的实例对象。 举例: Digit是一个类,在该类中使用implicit,这样就允许将Digit类的对象...

    作用:

         用于隐式类型转换
        当涉及到用户自定义的类时,可以在定义一个类时,使用implicit定义该类,之后就允许将该类的对象隐式转换为另一个类的实例对象。
    
    举例:

         Digit是一个类,在该类中使用implicit,这样就允许将Digit类的对象隐式转换为一个double类型的对象。
    
    代码:

        class Digit
        {
            public Digit(double d) { val = d; } //构函
            public double val;   //变量
    
            // 这段代码,使Digit类的对象,能够按照指定的规则,隐式转换为一个Double类型的对象
            public static implicit operator double(Digit d)
            {
                return d.val;
            }
            //  这段代码,使double类的对象,能够按照指定的规则,隐式转换为一个Digit类型的对象
            public static implicit operator Digit(double d)
            {
                return new Digit(d);
            }
        }
    
    
     class Program
        {
            static void Main(string[] args)
            {
                Digit dig = new Digit(7);
                double num = dig; //Digit类型的对象隐式转换为double型对象
                Digit dig2 = 12;//double型对象隐式转换为Digit型对象
                Console.WriteLine("num = {0} dig2 = {1}", num, dig2.val);
                Console.ReadLine();
            }
        }









    展开全文
  • Scala implicit

    2016-11-14 14:49:13
    掌握implicit的用法是阅读spark源码的基础,也是学习scala其它的开源框架的关键,implicit 可分为:隐式参数隐式转换类型隐式调用函数1.隐式参数当我们在定义方法时,可以把最后一个参数列表标记为implicit,表示该...

    掌握implicit的用法是阅读spark源码的基础,也是学习scala其它的开源框架的关键,implicit 可分为:

    • 隐式参数
    • 隐式转换类型
    • 隐式调用函数

    1.隐式参数

    当我们在定义方法时,可以把最后一个参数列表标记为implicit,表示该组参数是隐式参数。一个方法只会有一个隐式参数列表,置于方法的最后一个参数列表。如果方法有多个隐式参数,只需一个implicit修饰即可。 当调用包含隐式参数的方法是,如果当前上下文中有合适的隐式值,则编译器会自动为改组参数填充合适的值。如果没有编译器会抛出异常。当然,标记为隐式参数的我们也可以手动为该参数添加默认值。def foo(n: Int)(implicit t1: String, t2: Double = 3.14)

    scala > def calcTax(amount: Float)(implicit rate: Float): Float = amount * rate
    scala > implicit val currentTaxRate = 0.08F
    scala > val tax = calcTax(50000F) // 4000.0
    • 1
    • 2
    • 3

    如果编译器在上下文没有找到第二行代码会报错

    2.隐式地转换类型

    使用隐含转换将变量转换成预期的类型是编译器最先使用 implicit 的地方。这个规则非常简单,当编译器看到类型X而却需要类型Y,它就在当前作用域查找是否定义了从类型X到类型Y的隐式定义 
    例子:

    scala> val i: Int = 3.5 //直接报错
    加上这句:
    scala> implicit def double2Int(d: Double) = d.toInt
    再运行,没报错
    scala> val i: Int = 3.5  //i=3
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    3.隐式调用函数

    隐式调用函数可以转换调用方法的对象,比如但编译器看到X .method,而类型 X 没有定义 method(包括基类)方法,那么编译器就查找作用域内定义的从 X 到其它对象的类型转换,比如 Y,而类型Y定义了 method 方法,编译器就首先使用隐含类型转换把 X 转换成 Y,然后调用 Y 的 method。 
    例子:

    class SwingType{
      def  wantLearned(sw : String) = println("兔子已经学会了"+sw)
    }
    object swimming{
      implicit def learningType(s : AminalType) = new SwingType
    }
    class AminalType
    object AminalType extends  App{
      import com.mobin.scala.Scalaimplicit.swimming._
      val rabbit = new AminalType
        rabbit.wantLearned("breaststroke")         //蛙泳
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    上例中编译器在rabbit对象调用时发现对象上并没有wantLearning方法,此时编译器就会在作用域范围内查找能使其编译通过的隐式视图,找到learningType方法后,编译器通过隐式转换将对象转换成具有这个方法的对象,之后调用wantLearning方法


    展开全文
  • <p>I combined the fit and fit_weighted functions for implicit factorizations, subsume mask_padding into sample_weights and create support for sample weights in to_sequence and implicit sequence. ...
  • 语法 class PreferredPrompt(val preference: String) object Greeter { ... def greet(name:String)(implicit prompt: PreferredPrompt) { println("Welcome, " + name + ". Thee systeme is ready.") ...

     

    语法

    
    class PreferredPrompt(val preference: String)
    
    object Greeter {
    
       def greet(name:String)(implicit prompt: PreferredPrompt) {
    
         println("Welcome, " + name + ". Thee systeme is ready.")  
         println(prompt.preference)
       }
    }
    
    implicit val prompt = new PreferredPrompt("Yes, master> ")
    
    Greeter.greet("Joe")

     

    应用

    RequestContext 传递

    java编程中有使用ThreadLocal来保存当前请求,避免每个方法都带上context;

    scala通过implict,减少boilerplate code 

    abstract class RequestHandler {
          def process(context:RequstContext)
    }
    
    //main handler class
    def dispatch(request:Request) {
       implicit val context = makeContext(request)
    
       handler1.process
       handler2.process
       handler3.process
    
    }
    
    

     

    SparkSession

    spark session 对象贯穿整个job/application,通过implicit 减少每个方法调用时显示传入

     

      def sql2df(sql:String, view:Option[String] = None, isCache:Boolean = true)(implicit spark:SparkSession):DataFrame = {
        println(sql)
        val df = spark.sql(sql)
    
        if(isCache)
          df.cache()
    
        if(view.isDefined)
          df.createOrReplaceTempView(view.get)
    
        df
      }

     

    展开全文
  • scala implicit conversion scala implicit conversion scala implicit conversion scala implicit conversion scala implicit conversion
  • Scala implicitimplicit基本含义在Scala中有一个关键字是implicit, 之前一直不知道这个货是干什么的,今天整理了一下。 我们先来看一个例子: def display(input:String):Unit = println(input)我们可以看到,...

    Scala implicit
    implicit基本含义
    在Scala中有一个关键字是implicit, 之前一直不知道这个货是干什么的,今天整理了一下。

    我们先来看一个例子:

    def display(input:String):Unit = println(input)
    我们可以看到,display函数的定义只是接受String类型的入参,因此调用display("any string")这样的函数是没问题的。但是如果调用display(1)这样的入参不是String类型的话,编译会出错的。

    如果我们想让display函数也能够支持Int类型的入参的话,除了我们重新定一个def display(input:Int):Unit = println(input)这样的函数以外,我们还可以在相同的作用域内用implicit关键字定义一个隐式转换函数,示例代码如下:

    object ImplicitDemo {

    def display(input:String):Unit = println(input)

    implicit def typeConvertor(input:Int):String = input.toString

    implicit def typeConvertor(input:Boolean):String = if(input) "true" else "false"

    // implicit def booleanTypeConvertor(input:Boolean):String = if(input) "true" else "false"

    def main(args: Array[String]): Unit = {

    display("1212")
    display(12)
    display(true)

    }

    }
    我们定义了2个隐式转换函数:

    implicit def typeConvertor(input:Int):String = input.toString

    implicit def typeConvertor(input:Boolean):String = if(input) "true" else "false"
    这样display函数就可以接受String、Int、Boolean类型的入参了。注意到上面我们的例子中注释的那一行,如果去掉注释的那一行的话,会在运行的时候出现二义性:

    Error:(18, 13) type mismatch;
    found : Boolean(true)
    required: String
    Note that implicit conversions are not applicable because they are ambiguous:
    both method typeConvertor in object ImplicitDemo of type (input: Boolean)String
    and method booleanTypeConvertor in object ImplicitDemo of type (input: Boolean)String
    are possible conversion functions from Boolean(true) to String

    display(true)
            ^

    得出的结论是:

    隐式转换函数是指在同一个作用域下面,一个给定输入类型并自动转换为指定返回类型的函数,这个函数和函数名字无关,和入参名字无关,只和入参类型以及返回类型有关。注意是同一个作用域。

    implicit的应用
    我们可以随便的打开scala函数的一些内置定义,比如我们最常用的map函数中->符号,看起来很像php等语言。
    但实际上->确实是一个ArrowAssoc类的方法,它位于scala源码中的Predef.scala中。下面是这个类的定义:

    final class ArrowAssocA extends AnyVal {

    // `__leftOfArrow` must be a public val to allow inlining. The val
    // used to be called `x`, but now goes by `__leftOfArrow`, as that
    // reduces the chances of a user's writing `foo.__leftOfArrow` and
    // being confused why they get an ambiguous implicit conversion
    // error. (`foo.x` used to produce this error since both
    // any2Ensuring and any2ArrowAssoc pimped an `x` onto everything)
    @deprecated("Use `__leftOfArrow` instead", "2.10.0")
    def x = __leftOfArrow
    
    @inline def -> [B](y: B): Tuple2[A, B] = Tuple2(__leftOfArrow, y)
    def →[B](y: B): Tuple2[A, B] = ->(y)

    }
    @inline implicit def any2ArrowAssocA: ArrowAssoc[A] = new ArrowAssoc(x)
    我们看到def ->B返回的其实是一个Tuple2[A,B]类型。
    我们定义一个Map:

    scala> val mp = Map(1->"game1",2->"game_2")
    mp: scala.collection.immutable.Map[Int,String] = Map(1 -> game1, 2 -> game_2)
    这里 1->"game1"其实是1.->("game_1")的简写。
    这里怎么能让整数类型1能有->方法呢。
    这里其实any2ArrowAssoc隐式函数起作用了,这里接受的参数[A]是泛型的,所以int也不例外。
    调用的是:将整型的1 implicit转换为 ArrowAssoc(1)
    看下构造方法,将1当作__leftOfArrow传入。
    ->方法的真正实现是生产一个Tuple2类型的对象(__leftOfArrow,y ) 等价于(1, "game_id")
    这就是一个典型的隐式转换应用。

    其它还有很多类似的隐式转换,都在Predef.scala中:
    例如:Int,Long,Double都是AnyVal的子类,这三个类型之间没有继承的关系,不能直接相互转换。
    在Java里,我们声明Long的时候要在末尾加上一个L,来声明它是long。
    但在scala里,我们不需要考虑那么多,只需要:

    scala> val l:Long = 10
    l: Long = 10
    这就是implicit函数做到的,这也是scala类型推断的一部分,灵活,简洁。
    其实这里调用是:

    val l : Long = int2long(10)
    更牛逼的功能
    为现有的类库增加功能的一种方式,用java的话,只能用工具类或者继承的方式来实现,而在scala则还可以采用隐式转化的方式来实现。

    隐式参数

    看一个例子再说:

    object ImplictDemo {

    object Context{

    implicit val ccc:String = "implicit"

    }

    object Param{

    def print(content:String)(implicit prefix:String){
      println(prefix+":"+content)
    }

    }

    def main(args: Array[String]) {

    Param.print("jack")("hello")
    
    import Context._
    Param.print("jack")

    }

    }
    程序运行结果为:

    hello:jack
    implicit:jack
    隐式转换扩展

    import java.io.File

    import scala.io.Source

    class RichFile(val file:File){
    def read = Source.fromFile(file.getPath()).mkString
    }

    object Context{
    implicit def file2RichFile(f:File)= new RichFile(f)
    }

    object ImplictDemo {

    def main(args: Array[String]) {

    import Context.file2RichFile
    println(new File("f:\\create.sql").read)

    }

    }
    上面的代码中调用的read方法其实就是RichFile中定义的read方法。

    最后的总结:

    记住隐式转换函数的同一个scop中不能存在参数和返回值完全相同的2个implicit函数。
    隐式转换函数只在意 输入类型,返回类型。
    隐式转换是scala的语法灵活和简洁的重要组成部分
    参考资料
    http://blog.csdn.net/oopsoom/article/details/24643869

    ==============================================================================本文转自被遗忘的博客园博客,原文链接:http://www.cnblogs.com/rollenholt/p/4118567.html,如需转载请自行联系原作者

    展开全文
  • Android implicit information flow demystified
  • implicit feedback

    千次阅读 2017-12-26 20:50:32
    在推荐系统的paper中经常出现的一个词是implicit feedback,中文是隐式反馈。对于推荐系统的数据来说,一般分为显式反馈和隐式反馈。显式反馈就是用户对item的打分。例如按照评分1-5来打分,不同的打分就代表用户对...
  • C# explicti和implicit详解

    2020-12-22 21:47:34
    C#语言有很多值得学习的地方,这里我们主要介绍C# explicti和implicit,包括介绍隐式转换可以让我们的代码看上去更漂亮、更简洁易懂等方面。  C# explicti和implicit的含义  ◆C# explicti和implicit属于转换...
  • scala implicit

    2017-04-13 17:46:25
    implicit 可用于变量 伴生对象 参数 方法 object Math { trait NumberLike[T] { def divide(x: T, y: Int): T } object NumberLikes { implicit object NumberLikeDouble extends NumberLike[Double] { def
  • 这个问题其实是很低级的问题,但是经常还是容易发生,翻译下就是函数的隐式说明 原因: 是因为函数没有在头文件(.h)定义,这就导致编译的时候没法正确生成.o文件 ...
  • implicit object

    2014-04-09 14:15:39
    When a Container translates the JSP into a servlet,the beginning of the service method is a pile of implicit object declarations and assignments. All of the implicit objects map to something from t...
  • Implicit conversions

    2016-07-30 18:03:41
    class A { def m (key:Int): Unit = { println(s"Calling the method m in Class A with key value $key") ...}implicit class B (a: A) { println("implicit transform Class A to Class B") def f (str:
  • Scala Implicit 详解

    千次阅读 2018-02-07 19:29:13
    Implicit 是 Scala 中一个很重要的特性,开始学习 Scala 之前一直以为它和 Java 差不多,然而真的看一些 Scala 的源码时却发现并没有想象中那么简单,所以准备写几篇文章来详解 Scala 中异于 Java 的特性,就从 ...
  • Scala implicit 隐式

    2019-03-07 09:54:54
    隐式存在三种基本使用方式: 隐式参数 def calcTax(amount: Float)(implicit rate: Float): Float = amount * rate ...//implicit val currentTaxRate2 = 0.18F // ambiguous implicit values ...
  • implicitIntents:隐含意图
  • amrex_implicit_interfaces

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 89,413
精华内容 35,765
关键字:

implicit