HTML5 Paint

line width
fill

nil

line

nil

Scala : How functions are treated as objects

Hi friends,
        happy to share some interesting things studied from the on-line course Functional Programming Principles in Scala taken by the creator of Scala himself. Here I am trying to explain how functions are treated as primitive objects in Scala.

Consider Assignment of function

scala> def f(x:Int)=x*x  
f: (Int)Int

scala> var t:(Int)=>Int=f
t: (Int) => Int = <function>

We can also perform such an assignment as follows

scala> var t:Function[Int, Int]=f
t: (Int) => Int = <function>

similerly,

val y:Function2[Int,Int,Int]=(i:Int,j:Int)=>i+j
y: (Int, Int) => Int = <function> 

This gives insight to how functions are actually treated like objects in Scala.

In Scala, Traits Function1, Function2, ...Function22 are defined like follows

package scala
Trait Function1[T,F]
{
    def apply(x:T):F
} 

A function object of type (T) => F is an instance of subclass of Function1[T,F]
We can now define a function of type (Int)=>Int in this very basic way as follows.

class FunClass extends Function[Int,Int] {            
     def apply(x:Int):Int=x*x
}
defined class f

scala> val newFun=new FunClass()
newFun: FunClass = <function>

scala> newFun.apply(9)
res1: Int = 81

This is same as

scala> newFun(9)      
res2: Int = 81 

Now let us create an anonymous function

scala> val f= new Function[Int,Int] {
     | def apply(x:Int)=x*x
     | }

scala> f(9)
res2: Int = 81 

Now look at the apply() function.What happens if The apply itself a function object which with an apply() function as its member? It will lead to an infinite expansion when we create any function objects.

scala> def f(x:Int)=x*x                  
f: (Int)Int

scala> f.apply(9)
<console>:6: error: missing arguments for method f in object $iw;
follow this method with `_' if you want to treat it as a partially applied function
       f.apply(9)
       ^

Why we could not call apply() of object f? No its not. f is not a function object here. Now look back to our first try

scala> var t:Function[Int, Int]=f
t: (Int) => Int = <function>

Here a function object corresponds to f is generated which is an "anonymous function object" and is assigned to variable t while executing these kind of assignment statements. Here it is a simple definition for "eta expansion".

Scala:Type parameterization

Polymorphism in Scala can be achieved through type parameterization. Let us define class g with attributes x,y as integers as

scala> class g(val x:Int, val y:Int)
defined class g

We can use Type parameter like follows

scala> class g[T](val x:T, val y:T)
defined class g

scala> val obj=new g[Char]('a','b')
obj: g[Char] = g@a53564

scala> obj.x
res11: Char = a

scala> obj.y
res12: Char = b

We need not specify the type parameter explicitly like that, the Scala compiler  can infer the Type from function parameters

scala> val obj=new g('a','b')
obj: g[Char] = g@a53564

scala> obj.x
res3: Char = a
scala> val obj1=new g(1,2)
obj1: g[Int] = g@a53564

scala> obj1.y
res3: Char = 2

Now we can play a bit

scala> val obj=new g(1,true)          
obj: g[AnyVal] = g@11d95

scala> obj.x
res1: AnyVal = 1

scala> obj.y
res2: AnyVal = true

Notice that  val obj=new g(1,true) doesn't cause a type mismatch error even Value 1 is of type Int and true is of Boolean while both parameters are expected to be of same type. The reason is that, Boolean, Char, Int etc. are Subtypes of AnyValue.Here The compiler inferred the type as AnyValue looking at the parameters passed.

We can also have multiple Type parameters as follows

scala> class g[T,H](val x:T, val y:H)
defined class g

scala> val obj=new g('A',9)
obj: g[Char,Int] = g@14f7121

scala> obj.x
res10: Char = A

scala> obj.y
res11: Int = 9

We can define functions of parameterized type like follows

scala> def f[T](x:T):Unit=print(x)
f: [T](T)Unit

scala> f[Int](6)                  
6

scala> f(6)                  
6

scala> f("ssss")                  
ssss

Python Decorators

Python Decorator is a strategic use of functional programing facilities. Decoration stands for some kind of modifications. Let us consider one example. Consider , we have some function takes one integer and maps to some other integer, take a squaring function for now.

>>> def square(x):
...     return x*x

and we have to make a generalized function which accepts functions of the above kind as arguments and produce new function which do some further maping. take a doubling method for now.

>>> def double(x):
...     return x*2

Now let us make a function mofifier function

>>> def modify(f):
...     def g(x):
...             return double(f(x))
...     return g

now we can have a new function which performs the two mappings squaring and doubling together

command

>>> newFun=modify(square)
>>> newFun(2)
8

we can generalize the use of such function modifying functions with concept of decorators as

>>> @modify
... def square(x):
...     return x*x

 now we have a modified version of function square(x)

>>> square
<function g at 0x93dc64c>
>>> square(2)
8

Just after defining the function square, it is passed to modify() and the result returned is used instead of square().

>>> def decGenerate(mapping):
...     def modify(f):
...             def g(x):
...                     return mapping(f(x))
...             return g
...     return modify
... 
>>> @decGenerate(double)
... def square(x):
...     return x*x
... 
>>> square(2)
8

Here function decGenerator(mappingFunction) returns a function makung functio modify(f) which can be used as decorator

some magic with python

Here I am trying to discuss about some special method attributes in python.

we define a class like

>>> class myClass:
...     def __init__(self,value):
...             self.value=value
...             print 'object initialized'

And an object instantiation is done by

>>> a=myClass(10)
object initialized
>>> b=myClass(20)
object initialized

This seems usual but the magic is in evaluating the function myClass(value). an expression in the formmyClass(args) causes a call to __init__(self,args) defined inside class myClass.

let us make a new object c with its value attribute as sum of those of objects a and b.

>>> c=myClass(a.value+b.value)
object initialized
>>> c.value
30

It will be awesome if we can perform

>>> c=a+b
object initialized
>>> c.value
30

 We can make this possible by including a magic function __add__ to the class definition of myClass.

>>> class myClass:
...     def __init__(self,value):
...             self.value=value
...             print 'object initialized'
...     def __add__(self,obj):
...             c=myClass(self.value+obj.value)
...             return c

 Here c=a+b is evaluated as c=a.__add__(b)
There are more such methods enables operator overloading for arithmetic operators

Operator	Special method
-	__sub__(self, other)
//	__floordiv__(self, other)
/	__div__(self, other)
%	__mod_(self, other)
**	__pow__
<<	__lshift__(self, other)
&	__and__(self, other)
|	__or__(self, other)
^	__xor__(self, other)

There are corresponding reflected arithmetic operators too. If we use __radd__ instead of __add__ in above example, c=a+b will be evaluated as c=b.__radd__(a). We can define custom behavior for a lot of operations other than these arithmetic operators, like attribute assignments, comparisons, unary arithmetic operations like '+', '-' etc

Now let us look on some awesome special methods which enables creation of sequence types.

We have a class mySequence

>>> class mysequance:
...     def __init__(self,list):
...             self.value=list
...     def __iter__(self):
...             return iter(self.value)
...     def __getitem__(self,index):
...             return self.value[index]
...     def __len__(self):
...             return len(self.value)
... 
>>> s=mysequance([1,2,3,4,5,6])
 

Now we can perform some  list operations as follows

>>> len(s)
6
>>> s[1]
2
>>> it=iter(s)
>>> for i in it:
...     print i
... 
1
2
3
4
5
6

Python iterators, generators and list comprehension

Iterators

Iterators are objects which enables traversal of python sequence data structures like strings, tuples and lists which are so called iterable.

>>> list=[1,2,3,4]
>>> lit=iter(list)
>>> lit
<listiterator object at 0x96abd2c>

 we can use this iterator object to extract elements on the list one by one

>>> lit.next()
1
>>> lit.next()
2
>>> lit.next()
3
>>> lit.next()
4
>>> lit.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

Function next() raise Stopiteration exception when there is no more element in list to traverse.

 we can use iterator object instead of corresponding sequence variables in construct.

>>> tit=iter((1,2,3,4))
>>> tit
<tupleiterator object at 0x96abfcc>
>>> 3 in tit
True 

generators

>>> def listgen(n):
...     for i in range(n):
...             yield i
... 

Python interpret functions like above containing a yield statement in a special way unlike to other functions. When we call the function listgen(n)

>>> g=listgen(5)
>>> g
<generator object listgen at 0xb786af7c>

Instead of executing the function and returning the result, a generator object  corresponding to listgen() is returned. The use of generator object is similar to iterator object.

>>> g=listgen(3)
>>> g.next()
0
>>> g.next()
1
>>> g.next()
2
>>> g.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration 

List comprehension

squares=[i*i for i in range(10)  if i%2==1]
>>> squares
[1, 9, 25, 49, 81]

A list comprehension consists of brackets containing an expression followed by a for clause, then zero or more if clauses. This special construct returns a list. The above list comprehension statement gives same result as

>>> squares=[]
>>> for i in range(10):
...     if i%2==1:
...             squares.append(i*i)
... 

 or

>>>squares=map((lambda x: x*x),filter((lambda x:x%2==1), range(10)))

We can perform nested list comprehension like follows,

>>> matrix=[[1,2,3],[4,5,6],[7,8,9]]
>>> transpose=[[matrix[i][j] for i in range(len(matrix))] for j in range(len(matrix[0]))]
>>> transpose
[[1, 4, 7], [2, 5, 8], [3, 6, 9]] 

 

Functional programming with python

Even we cant depend completely on functional programming, we should employ this approach whenever possible. In that sense, Python is a good platform for mixing up different programming approaches in a most convenient way

Python functional programming facilities

We shall discuss python functional programming capabilities based on following examples

With Python object oriented programming, we can notate an arithmetic progression as

>>> class term:
 def __init__(self,a,d):
  self.value=a
  self.d=d
 def next(self): 
  self.value+=self.d
  return self 

>>> x=term(1,2)

Here x is capable of generating terms in an arithmetic progression with a=0 and common difference d=2, as follows.

>>> x.next() 
>>> x.value
3
>>> x.next() 
>>> x.value
5
>>> x.next()
>>> x.value
7 

We can perform such an abstraction with functional programming facilities as follows.

>>> def term(a,d):
...     return(lambda f: f(a,d))
... 
>>> def next(s):
...     return s(lambda a,d: term(a+d,d))
... 
>>> def value(s):
...     return s(lambda a,b:a)
... 

>>> x=term(1,2)
>>> value(x)
1
>>> x=next(x) 
>>> value(x)
3
>>> value(next(next(next(next(term(1,2))))))
9

Inside term(a,b) a nameless function is defined using lambda expression. The definition of this lambda function contain use of local variables of function term(). The closure property of functional languages facilitate this kind of definition of functions inside a function. Again, this lambda function accepts a function f of the form

f(a,b):
     return expression_on(a,b)

as its argument and apply f on local variables a and b of function term(a,b) then return the result. So this lambda function is a higher order function, that is a function accepts functions as arguments. What is returned by term function is a higher order function which has access on local variables of term(). This ability to use function as return value is called currying.

What's the benefit?

Functional programs contain no side-effects. that is, A function call can have no effect other than to compute its result.


Function term(a,b) returns a higher order function x with a,b as tis local variables. With special functions value(s) and next(s) we can have read access to the local variables. In the second case x is a function object with constant state. In other words state is strictly conserved. in first case, in this style of programming, state change for x occurs  as a side effect for each call to member function next().

Advantage of Eliminating side effects is "Referential transparency"

In first case

>>>x.next().value==x.next().value
False 

in second case

>>>value(next(x))==value(next(x))
True 

Here value(next(x)) returns same value at every time applied on x. That means we can replace this expression with a value whenever it occurs. This property is called referential transparency. No one feel any confusion because it is "Mathematically provable". In first case we can maintain referential transparency by adding some extra object replications instead of just returning a self. But in functional programming approach, it is an inherent characteristic.