thinking functional-in-scala

1

Thinking Functional inScala

Vikas HazratiKnoldus Software LLP

(c) 2014-15 Knoldus Software 2

agenda

● Introduction● Referential

Transparency● Substitution Model● Exception Handling


agenda




impure

Scala is an impure functional programming language


no side effects

Mutation

I/O

Exceptions

printing to consoleas well


side-effect

If the function does something other than just providing result➔ Modifying a variable➔ Modifying a data structure in place➔ Setting a field on an object➔ Throwing an exception or halting with an error➔ Printing to the console or reading user input➔ Reading from or writing to a file➔ Drawing on the screen


benefits of a pure function

Easy to

Test

Reuse

Parallelise

Generalize

Reason


a pure function

● A function f with input type A and output type B (written in Scala as a single type: A => B , pronounced “ A to B ” or “ A arrow B ”) is a computation that relates every value a of type A to exactly one value b of type B such that b is determined solely by the value of a .

● Any changing state of an internal or external process is irrelevant to computing the result f(a)

● A function intToString having type Int => String will take every

integer to a corresponding string. Furthermore, if it really is a function, it will do nothing else


a pure function

Referential Transparency

Substitution Model

Not contextdependent


agenda




referential transparency

What is the difference between 2 code blocks?


referential transparency

What is the difference between 2 code blocks?

If the expression can be replaced by its value and vice versa AND nothing changes then it is called Referential Transparency.

This model of substituting values for expressions is called Substitution Model.


agenda




substitution model

What do you expect the output to be?


substitution model



substitution model

Now, let us replace money2 with referntial transparency. Hence money2 becomes Money1.add(20)

Your sum1 is Money(60)Your sum2 is Money(90)

Why?


substitution model

Ok, let us change the way Money works



substitution model

Ok, let us change the way Money works


Your sum1 is GoodMoney(40)Your sum2 is GoodMoney(40)


substitution model

And now lets apply the referential transparency



another example


another example

Ideally we should be able to callany listIngredients with coffee


side effect

What is the side effect here ?


Functional Exception Handling


Exceptions are not type safe

What is the datatype of this ?

How would the caller know that there is an exception which can occur?

How was it better in Java?


Exception break RT

Exceptions introduce context dependence

What would be the output?

What would be the output once we introduce RT?


Exception break RT

After introducing RT

What would be the output?


How should we work with Exceptions?


sentinel value

● Return a Sentinel value

Sentinel value

Silent error propagationBoilerplate codeTyped methods would not know valueDemands special handling at caller end


other options?

Explicit return that function may not always have a value

What would you do?


other options?

Explicit return that function may not always have a value

What would you do? Option


option

When exception could be thrown, wrap the result in an Option


wrapping exception throwing api's

● Lifting methods

f(A=>B)

def lift[A,B](f: A => B): Option[A] => Option[B] = _ map f

Example : val k = lift(math.abs)


wrapping exception throwing api's

● Any number of parameters


converting non option methods


return exceptions

Sometimes we do want to tell the caller that an exception has occured and pass the exception


return exceptions

Sometimes we do want to tell the caller that an exception has occured and pass the exception

Either


Let us wrap our method

println(divideWithError(10,1).fold(a=>a,b=>b+1))

println(divideWithError(10,0).fold(a=>a,b=>b+1))


That's It !

;)

thinking functional-in-scala

Technology

substitution modelok

substitution modelwhat

output type b

substitution modeland

substitution modelnow

value b of type b

referential transparencywhat

input type