Scala's Implicit Conversions and Parameters
Implicit
Conversions and
Parameters in Scala
Abraham Peediakal and Henry Dyer
The
implicit
keyword
What does it do?
•
Provides type conversions to the compiler
•
Infer parameters when they aren’t given directly
•
Useful for integrating outside code
An Example:
JButton
val
button =
new
JButton
button.addActionListener(
new ActionListener {def
actionPerformed
(event:
ActionEvent): Unit = {println(
“pressed!”
)
}
}
)
// I’m supposed to read this?
An Example:
JButton
val
button =
new
JButton
button.addActionListener(
(_: ActionEvent) =>
println(
“pressed!”
)
)
// function != ActionListener
implicit def
function2ActionListener
(f: ActionEvent =>
Unit
): ActionListener =
new ActionListener {def
actionPerformed
(event: ActionEvent):
Unit
=
f(event)
}
An Example:
JButton
val
button =
new
JButton
button.addActionListener(
(_: ActionEvent) =>
println(
“pressed!”
)
)
// now it works!
Implicit Conversion Rules
1.
Marking Rule
•
Only definitions marked
implicit
are considered
Implicit Conversion Rules
2. Scope Rule
•
An implicit definition must be in scope to be used
•
Import
•
Extends
•
Note: Only needs brought into scope once
Implicit Conversion Rules
3. One-at-a-Time Rule
•
Compiler won’t apply multiple conversions at once
Implicit Conversion Rules
4. Explicits-first Rule
•
If the code works, the compiler won’t fix it
An Example:
Ints and
Doubles
val
i:
Int
=
3.5
// that’s illegal!
An Example:
Ints and
Doubles
implicit def
doubleToInt
(x:
Double
) =
x.toInt
// now it works!
val
i:
Int
=
3.5
// i: Int = 3
An Example:
Rationals
val
oneHalf =
new
Rational(1, 2)
// oneHalf: Rational = 1/2
oneHalf + oneHalf
// 1/1
oneHalf +
1
// 3/2
1
+ oneHalf
// that’s illegal!
An Example:
Rationals
implicit def
intToRational(x:
Int
) =
new
Rational(x, 1)
1
+ oneHalf
// intToRational(1) + oneHalf
// 1/1 + 1/2
// = 3/2
Adding syntax to preexisting classes is easy!
Map
(
1
->
“one”
,
2
->
“two”
,
3
->
“three”
)
^ Hey… how do the arrows work?
Adding syntax to preexisting classes is easy!
package
scala
object
Predef {class
ArrowAssoc[
A
](x:
A
) {def
-> [
B
](y:
B
): Tuple2[
A
,
B
] = Tuple2(x, y)
}
implicit def
any2ArrowAssoc
[
A
](x:
A
):
ArrowAssoc[
A
] = new ArrowAssoc(x)
}
And now…
Implicit Classes
An Example:
Rectangles
case class
Rectangle(width:
Int
,
height:
Int
)
// shapes are great
// constructors are lame
// can we make this easier?
An Example:
Rectangles
implicit class
RectangleMaker
(width:
Int
) {def
x(height:
Int
) =
Rectangle(width, height)
}
// automatically generates implicit
conversion from int to RectangleMaker
Scala's implicit keyword allows for type conversions by the compiler, inferring parameters when not directly stated, and is useful for integrating external code. Implicit conversion rules include marking, scope, one-at-a-time, and explicits-first rules. This guide provides examples and insights into leveraging implicit conversions effectively in Scala programming.
Download Presentation
Please find below an Image/Link to download the presentation.
The content on the website is provided AS IS for your information and personal use only. It may not be sold, licensed, or shared on other websites without obtaining consent from the author. Download presentation by click this link. If you encounter any issues during the download, it is possible that the publisher has removed the file from their server.
E N D
Presentation Transcript
Implicit Conversions and Parameters in Scala Abraham Peediakal and Henry Dyer
The implicit keyword What does it do? Provides type conversions to the compiler Infer parameters when they aren t given directly Useful for integrating outside code
val button = new JButton button.addActionListener( new ActionListener { def actionPerformed(event: ActionEvent): Unit = { An Example: JButton println( pressed! ) } } ) // I m supposed to read this?
val button = new JButton button.addActionListener( An Example: JButton (_: ActionEvent) => println( pressed! ) ) // function != ActionListener
implicit def function2ActionListener(f: ActionEvent => Unit): ActionListener = new ActionListener { def actionPerformed(event: ActionEvent): Unit = f(event) }
val button = new JButton button.addActionListener( An Example: JButton (_: ActionEvent) => println( pressed! ) ) // now it works!
Implicit Conversion Rules 1. Marking Rule Only definitions marked implicit are considered
Implicit Conversion Rules 2. Scope Rule An implicit definition must be in scope to be used Import Extends Note: Only needs brought into scope once
Implicit Conversion Rules 3. One-at-a-Time Rule Compiler won t apply multiple conversions at once
Implicit Conversion Rules 4. Explicits-first Rule If the code works, the compiler won t fix it
An Example: Ints and Doubles val i: Int = 3.5 // that s illegal!
implicit def doubleToInt(x: Double) = x.toInt An Example: Ints and Doubles // now it works! val i: Int = 3.5 // i: Int = 3
val oneHalf = new Rational(1, 2) // oneHalf: Rational = 1/2 oneHalf + oneHalf An Example: Rationals // 1/1 oneHalf + 1 // 3/2 1 + oneHalf // that s illegal!
implicit def intToRational(x: Int) = new Rational(x, 1) An Example: Rationals 1 + oneHalf // intToRational(1) + oneHalf // 1/1 + 1/2 // = 3/2
Adding syntax to preexisting classes is easy! Map(1 -> one , 2 -> two , 3 -> three ) ^ Hey how do the arrows work?
Adding syntax to preexisting classes is easy! package scala object Predef { class ArrowAssoc[A](x: A) { def -> [B](y: B): Tuple2[A, B] = Tuple2(x, y) } implicit def any2ArrowAssoc[A](x: A): ArrowAssoc[A] = new ArrowAssoc(x) }
And now Implicit Classes
case class Rectangle(width: Int, height: Int) An Example: Rectangles // shapes are great // constructors are lame // can we make this easier?
implicit class RectangleMaker(width: Int) { An Example: Rectangles def x(height: Int) = Rectangle(width, height) } // automatically generates implicit conversion from int to RectangleMaker
