So various polymorphism in Scala

SO VARIOUS
POLYMORPHISM
IN SCALA
Boris Trofimov
@ Sigma Software
@b0ris_1

AGENDA
WHY
SCALA
CONTEXT
MAP
POLYMORPHISM
DEFINITION
BASIC
DEGREE
BACHELOR
DEGREE
MAST
DEGR
Why Scala?
Context Map
Polymorphism Definition
Basic Degree
Bachelor degree
Master degree
Ph.D

DO YOU ACCEPT
SAPIR–WHORF
HYPOTHESIS?
WHY
SCALA
CONTEXT
MAP
POLYMORPHISM
DEFINITION
BASIC
DEGREE
BACHELOR
DEGREE
MAST
DEGR
WHY
SCALA
AGENDA

WHY
SCALA
CONTEXT
MAP
POLYMORPHISM
DEFINITION
BASIC
DEGREE
BACHELOR
DEGREE
MAST
DEGR
AGENDA
 Object-Oriented Meets Functional
 Strongly Functional
 It makes you love your code again
 Scalable grammar
 Hello Domain Specific Languages (DSL)
 Inexhaustible language for every day

SCALA JAVA
class A (p: String) class A {
final String p;
public A(String p) {
this.p = p;
}
}
val variable = "string" final String variable = "string" ;
def func (p: String): String = {...} String func (String p) { ... }
trait A { def run() } interface A {
void run() ;
}
сlass A[B <: C] { … } class A <B extends C> { ... }
object A { … } Class - Singleton definition
CONTEXT
MAP
POLYMORPHISM
DEFINITION
BASIC
DEGREE
BACHELOR
DEGREE
MAST
DEGR
CONTEXT
MAP
WHY
SCALA
AGENDA

CONTEXT
MAP
POLYMORPHISM
DEFINITION
BASIC
DEGREE
BACHELOR
DEGREE
MAST
DEGR
POLYMORPHISM
DEFINITION
WHY
SCALA
AGENDA
 Ability of language to handle data of different types in the same way.
 Provision of a single interface to entities of different types.
 Particular code is able to handle data of different types.
 Way to change code behavior via input parameters without direct
modification (respecting Open-Closed Principle)
Polymorphic code will be
highlighted in a frame

AD-HOC SUBTYPING
PARAMETRIC
POLYMORPHISM
REFLECTION
SUBTYPING
FUNCTIONAL
SUBTYPING
abstract class A{
def method() {
...
this.doSomething
...
}
// abstract method
def doSomething
}
class B extends A{
override def doSomething { … }
}
class B extends C{
override def doSomething { … }
}

AD-HOC SUBTYPING
PARAMETRIC
POLYMORPHISM
REFLECTION
SUBTYPING
FUNCTIONAL
SUBTYPING
trait A
class B extends A
class C extends A
class List {
def add(a : A) = {
...
}
}
SUBTYPINGAD-HOC

AD-HOC SUBTYPING
PARAMETRIC
POLYMORPHISM
REFLECTION
SUBTYPING
FUNCTIONAL
SUBTYPING
AD-HOC
class MyClass {
def addItem[A](a: A): List[A] = {
val list = new ListBuffer[A]
list += a
list.toList()
}
// B should be inheritor of ParentClass
def addItem[B <: ParentClass] (b: B) : List[A] = {
val list = new ListBuffer[B]
list += b
list.toList()
}
}
PARAMETRIC
POLYMORPHISM

AD-HOC SUBTYPING
PARAMETRIC
POLYMORPHISM
REFLECTION
SUBTYPING
FUNCTIONAL
SUBTYPING
AD-HOC
REFLECTION
SUBTYPING
class MyClass {
def doSomething(a: Object) = {
...
val method = a.getClass().getMethod("run", Int)
method.invoke(a, 1)
...
}
}

AD-HOC SUBTYPING
PARAMETRIC
POLYMORPHISM
REFLECTION
SUBTYPING
FUNCTIONAL
SUBTYPING
AD-HOC
FUNCTIONAL
SUBTYPING
class List[A] {
...
def sort(data : (A, A) => Int ) : List[A] = {
...
}
}
object Application extends App{
val list = List(7,8,5,4)
list.sort( (a,b) => a – b ) // _-_
}

DUCK
SUBTYPING
CAKE
PATTERN
CHAINING
POLYMORPHISM
When I see a bird that walks like a duck and swims like a duck and quacks
like a duck, I call that bird a duck
class MyClass {
def doSomething(a : type { def run(i : Int) } ) = {
...
a.run(1)
...
}
}
class DuckClass {
def run(i : Int) {
...
}
}
new MyClass().doSomething( new DuckClass() )
Caution: Reflection!

CAKE
PATTERN
CHAINING
POLYMORPHISM
DUCK
SUBTIPING
CAKE
PATTERN
trait ComponentA {
def doThis() : String
}
trait ComponentB {
def doThat() : String
}
class OurComponent extends ComponentA with ComponentB {
def doSomething() = doThis() + doThat()
}

CAKE
PATTERN
CHAINING
POLYMORPHISM
DUCK
SUBTIPING
CAKE
PATTERN
trait ComponentA {
}
trait ComponentB {
}
}
trait ComponentAImpl extends ComponentA {
def doThis() = "hello Component A"
}
trait ComponentBImpl extends ComponentB {
def doThat() = "hello Component B"
}

CAKE
PATTERN
CHAINING
POLYMORPHISM
DUCK
SUBTIPING
CAKE
PATTERN
trait ComponentA {
}
trait ComponentB {
}
}
trait ComponentAImpl extends ComponentA {
def doThis() = "hello Component A"
}
trait ComponentBImpl extends ComponentB {
def doThat() = "hello Component B"
}
object Main extends App{
val obj = new OurComponent with ComponentAImpl with ComponentBImpl
println( obj.doSomething() )
}

CAKE
PATTERN
CHAINING
POLYMORPHISM
DUCK
SUBTIPING
CHAINING
POLYMORPHISM
trait AbstractOperation { def run() }
class SaveToDataBaseOperation extends AbstractOperation {
override def run(): Unit = {
println("Save it to database")
}
}

CAKE
PATTERN
CHAINING
POLYMORPHISM
DUCK
SUBTIPING
CHAINING
POLYMORPHISM
}
}
// decorating with audit
trait AuditDecorator extends AbstractOperation {
abstract override def run(): Unit = {
println("Entering AuditDecorator")
super.run()
println("Leaving AuditDecorator")
}
}
// decorating with caching
trait CachingDecorator extends AbstractOperation {
println("Caching something")
super.run()
}
}

CAKE
PATTERN
CHAINING
POLYMORPHISM
DUCK
SUBTIPING
CHAINING
POLYMORPHISM
}
}
// decorating with audit
trait AuditDecorator extends AbstractOperation {
println("Entering AuditDecorator")
super.run()
println("Leaving AuditDecorator")
}
}
// decorating with caching
trait CachingDecorator extends AbstractOperation {
println("Caching something")
super.run()
}
}
object MyApp extends App {
val operation =
new SaveToDataBaseOperation with CachingDecorator with AuditDecorator
operation.run()
}
OUTPUT:
>Entering AuditDecorator
>Caching something
>Save it to database
>Leaving AuditDecorator

TYPE CLASSES
RETROACTIVE
POLYMORPHISM
IMPLICIT DI
TYPE
CONSTRUCTORS
object Test{
println( Arithmetics.add("Hello", " World") ) // returns “Hello World”
println( Arithmetics.add(2,3) ) // returns 5
// Compile Error, could not find corresponding implicit object
println( Arithmetics.add(123.0, -45.345) )
}
F-BOUNDED
POLYMORPHISM

TYPE CLASSES
RETROACTIVE
POLYMORPHISM
IMPLICIT DI
TYPE
CONSTRUCTORS
object Test{
println( Arithmetics.add("Hello", " World") ) // returns “Hello World”
println( Arithmetics.add(2,3) ) // returns 5
// Compile Error, could not find corresponding implicit object
println( Arithmetics.add(123.0, -45.345) )
}
trait NumericLike[T] {
def plus(x : T, y: T) : T
}
implicit object TInteger extends NumericLike[Int]{
def plus(x : Int, y: Int) : Int = x + y
}
implicit object TString extends NumericLike[String]{
def plus(x : String, y: String) : String = x + y
}
object Arithmetics{
// generalized `add` method
def add[T : NumericLike](x:T, y:T): T = {
val engine = implicitly[NumericLike[T]]
engine.plus(x, y)
}
}
Type Class Pattern
F-BOUNDED
POLYMORPHISM
Type Class can be
treated as an advocate
for specific type T

TYPE CLASSES
RETROACTIVE
POLYMORPHISM
IMPLICIT DI
TYPE
CONSTRUCTORS
F-BOUNDED
POLYMORPHISM
RETROACTIVE
POLYMORPHISM
TYPE CLASSES
https://github.com/spray/spray-json
import spray.json._
import DefaultJsonProtocol._
// from json
val source = """{ "some": ["JSON source"] }"""
val ast = source.parseJson
val myObject = ast.convertTo[Map[String, Array[String]]]
// to json
val jsonAst = Map(Array("1"), Array("1")).toJson // to ast
val json = jsonAst.prettyPrint // or .compactPrint
class Color(val name: String, val red: Int, val green: Int, val blue: Int)
// custom serializer via type class
object MyJsonProtocol extends DefaultJsonProtocol {
implicit object ColorJsonFormat extends RootJsonFormat[Color] {
def write(c: Color) = . . .
def read(value: JsValue) = ...
}
}
import MyJsonProtocol._
val json = Color("CadetBlue", 95, 158, 160).toJson
val color = json.convertTo[Color]
The ability to extend functionality of a library without modifying its source is known
as Retroactive Extension

TYPE CLASSES
RETROACTIVE
POLYMORPHISM
IMPLICIT DI
TYPE
CONSTRUCTORS
F-BOUNDED
POLYMORPHISM
IMPLICIT DI
RETROACTIVE
POLYMORPHISM
trait Future[+T] extends Awaitable[T] {
…
def filter(pred: T => Boolean) (implicit executor: ExecutionContext):
Future[T] =
map {
r => if (pred(r)) r else throw new
NoSuchElementException("Future.filter predicate is not satisfied")
}
def map[S](f: T => S) (implicit executor: ExecutionContext): Future[S] = {
// transform(f, identity)
val p = Promise[S]()
onComplete { v => p complete (v map f) }
p.future
}
}
TYPE CLASSES
Dependency Injection per
method

TYPE CLASSES
RETROACTIVE
POLYMORPHISM
IMPLICIT DI
TYPE
CONSTRUCTORS
F-BOUNDED
POLYMORPHISM
IMPLICIT DI
RETROACTIVE
POLYMORPHISM
…
Future[T] =
map {
}
p.future
}
}
...
import scala.concurrent.ExecutionContext.Implicits.global
val future = Future { 12345 }. map { x => x + 1} // _ + 1
TYPE CLASSES
method

TYPE CLASSES
RETROACTIVE
POLYMORPHISM
IMPLICIT DI
TYPE
CONSTRUCTORS
F-BOUNDED
POLYMORPHISM
IMPLICIT DI
RETROACTIVE
POLYMORPHISM
…
Future[T] =
map {
}
p.future
}
}
...
import scala.concurrent.ExecutionContext.Implicits.global
val future = Future { 12345 }. map { x => x + 1} // _ + 1
// test code
implicit val executionContext = mock[ExecutionContext]
val future = Future { 12345 }. map { _ + 1}
TYPE CLASSES
method

TYPE CLASSES
RETROACTIVE
POLYMORPHISM
IMPLICIT DI
TYPE
CONSTRUCTORS
F-BOUNDED
POLYMORPHISM
TYPE
CONSTRUCTORS
TYPE CLASSES
More about motivation and examples
http://adriaanm.github.io/files/higher.pdf
Way to build generalized
types to take generics as
a parameter

TYPE CLASSES
RETROACTIVE
POLYMORPHISM
IMPLICIT DI
TYPE
CONSTRUCTORS
F-BOUNDED
POLYMORPHISM
TYPE
CONSTRUCTORS
TYPE CLASSES
object Test{
Operations.tupleize(Some(1), Some(2)) // returns Some( (1,2) )
Operations.tupleize(List(1,3), List (2,4)) //returns List( (1,2) , (3,4) )
}

TYPE CLASSES
RETROACTIVE
POLYMORPHISM
IMPLICIT DI
TYPE
CONSTRUCTORS
F-BOUNDED
POLYMORPHISM
TYPE
CONSTRUCTORS
TYPE CLASSES
object Test{
}
trait ContainerHandler[M[_]] {
def put[A](x: A): M[A]
def get[A](m: M[A]): A
}
object Operations{
def tupleize[M[_]: ContainerHandler, A, B](fst: M[A], snd: M[B]) = {
val engine = implicitly[ContainerHandler[M]]
engine.put( Pair(engine.get(fst), engine.get(snd)) )
}
}

TYPE CLASSES
RETROACTIVE
POLYMORPHISM
IMPLICIT DI
TYPE
CONSTRUCTORS
F-BOUNDED
POLYMORPHISM
TYPE
CONSTRUCTORS
TYPE CLASSES
object Test{
}
trait ContainerHandler[M[_]] {
def put[A](x: A): M[A]
def get[A](m: M[A]): A
}
object Operations{
def tupleize[M[_]: ContainerHandler, A, B](fst: M[A], snd: M[B]) = {
val engine = implicitly[ContainerHandler[M]]
engine.put( Pair(engine.get(fst), engine.get(snd)) )
}
}
implicit val listHandler =
new ContainerHandler[List]{ def put[A](x: A) = List(x); def get[A](m: List[A]) = m.head
}
implicit val optionHandler =
new ContainerHandler[Some]{ def put[A](x: A) = Some(x); def get[A](m: Some[A]) = m.get
}

trait Account[T <: Account[T] ] {
def addFunds(amount: BigDecimal): T
}
class CheckingAccount(total: BigDecimal, trxMaxCount: Int)
extends Account[CheckingAccount] {
def addFunds(amount: BigDecimal) : CheckingAccount =
new CheckingAccount(total + amount, trxMaxCount)
}
class SavingAccount(total: BigDecimal) extends Account[SavingAccount] {
def addFunds(amount: BigDecimal) : SavingAccount =
new SavingAccount(total + amount)
}
TYPE CLASSES
RETROACTIVE
POLYMORPHISM
IMPLICIT DI
TYPE
CONSTRUCTORS
F-BOUNDED
POLYMORPHISM
F-BOUNDED
POLYMORPHISM
TYPE CLASSES
How to define function that, though defined in terms of a supertype, will when
passed a value of some subtype will always return a value of the same subtype as
its argument?
trait Account {
def addFunds(amount: BigDecimal): Account //???
}

TYPE CLASSES
RETROACTIVE
POLYMORPHISM
IMPLICIT DI
TYPE
CONSTRUCTORS
F-BOUNDED
POLYMORPHISM
F-BOUNDED
POLYMORPHISM
TYPE CLASSES
object Account {
val feePercentage = BigDecimal("0.02")
val feeThreshold = BigDecimal("10000.00")
def deposit[T <: Account[T]](amount: BigDecimal, account: T): T = {
if (amount < feeThreshold) account.addFunds(amount - (amount * feePercentage))
else account.addFunds(amount)
}
http://logji.blogspot.com/2012/11/f-bounded-type-polymorphism-give-up-now.html

TYPE CLASSES
RETROACTIVE
POLYMORPHISM
IMPLICIT DI
TYPE
CONSTRUCTORS
F-BOUNDED
POLYMORPHISM
F-BOUNDED
POLYMORPHISM
TYPE CLASSES
object Account {
val feePercentage = BigDecimal("0.02")
val feeThreshold = BigDecimal("10000.00")
def deposit[T <: Account[T]](amount: BigDecimal, account: T): T = {
if (amount < feeThreshold) account.addFunds(amount - (amount * feePercentage))
else account.addFunds(amount)
}
def debitAll(amount: BigDecimal, accounts: List[T forSome { type T <: Account[T] }]):
List[T forSome { type T <: Account[T] }] = {
accounts map { _.addFunds(-amount) }
}
}
object Test {
val list = List[T forSome { type T <: Account[T] }](
new CheckingAccount(BigDecimal("0"), 10),
new SavingAccount(BigDecimal("0")))
Account.debitAll(BigDecimal("10.00"), list)
}
The second frame uses
trick with existential
types to store in one
collection
http://logji.blogspot.com/2012/11/f-bounded-type-polymorphism-give-up-now.html

Scala Puzzle
def gen2(i: Int): Stream[Int] = Stream(i) append gen2(i+1)
println(gen2(0).take(10).to[List])
// > List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
def gen(i: Int): Stream[Int] = Stream(i) ++ gen(i+1)
println(gen(0).take(10).to[List])
// > List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
(2) The first fails, the second
succeeds
(1) Both will fail with
StackOverflowError
(4) The second fails, the first
succeeds
(3) Both will succeed
1
2

TYPE CLASSES
POLYMORPHIC
FUNCTIONS
RETROACTIVE
POLYMORPHISM
We treat type aliases like
abstract virtual functions
passing and returning types, for
instance:
def Prev : Nat
def Plus(A: Nat) : Nat
VIRTUAL TYPES
object Factorial extends App {
trait Nat {
type Prev <: Nat
type Plus[A <: Nat] <: Nat
type Times[A <: Nat] <: Nat
type Factorial <: Nat
}
trait _0 extends Nat {
type Prev = _0
type Plus[A <: Nat] = A
type Times[A <: Nat] = _0
type Factorial = _1
}
trait Succ[N <: Nat] extends Nat {
type This = Succ[N]
type Prev = N
type Times[A <: Nat] = A#Plus[N#Times[A]]
type Plus[A <: Nat] = N#Plus[Succ[A]]
type Factorial = This#Times[Prev#Factorial]
}
type _1 = Succ[_0]
type _2 = Succ[_1]
type _3 = Succ[_2]
type _4 = Succ[_3]
type _5 = Succ[_4]
type _6 = Succ[_5]
type _7 = Succ[_6]
type _8 = Succ[_7]
type _9 = Succ[_8]
// Calculate 3! = 6
implicitly[_3#Factorial =:= _6]
}
https://gist.github.com/mkleen/9290750

TYPE CLASSES
POLYMORPHIC
FUNCTIONS
VIRTUAL TYPES
POLYMORPHIC
FUNCTIONS
https://github.com/milessabin/shapeless/wiki/Feature-overview:-shapeless-2.0.0
 Scala function values are monomorphic due to interface Function1[U,V] { .. }
 Shapeless library allows to avoid this limitation
 Polymorphic functions allow to process heterogeneous collections (HLists)
import poly._
// choose is a function from Sets to Options with no type specific cases
object choose extends (Set ~> Option) {
def apply[T](s : Set[T]) = s.headOption
}
scala> choose(Set(1, 2, 3))
res0: Option[Int] = Some(1)
scala> choose(Set('a', 'b', 'c'))
res1: Option[Char] = Some(a)
scala> val sets = Set(1) :: Set("foo") :: HNil
scala> val opts = sets map choose // map selects cases of choose for each HList element
opts: Option[Int] :: Option[String] :: HNil = Some(1) :: Some(foo) :: HNil
Define polymorphic function

TYPE CLASSES
POLYMORPHIC
FUNCTIONS
VIRTUAL TYPES
POLYMORPHIC
FUNCTIONS
import poly._
}
It behaves like an usual function

TYPE CLASSES
POLYMORPHIC
FUNCTIONS
VIRTUAL TYPES
POLYMORPHIC
FUNCTIONS
import poly._
}
HList runs polymorphic function
It behaves like an usual function

REFERENCES
 http://adriaanm.github.io/files/higher.pdf
 http://twitter.github.io/scala_school/advanced-types.html
 http://logji.blogspot.com/2012/11/f-bounded-type-polymorphism-give-up-
now.html
 http://danielwestheide.com/blog/2013/02/06/the-neophytes-guide-to-scala-
part-12-type-classes.html
 https://gist.github.com/mkleen/9290750
 http://apocalisp.wordpress.com/2010/06/08/type-level-programming-in-
scala/

So various polymorphism in Scala

More Related Content

What's hot

Viewers also liked

Similar to So various polymorphism in Scala

More from b0ris_1

Recently uploaded

So various polymorphism in Scala