CSC/ECE 517 Fall 2010/ch1 1e bb

Functional Programming

Functional programming treats computation as the evaluation of mathematical functions and avoids state and mutable data. It emphasizes on the application of functions, also called applicative programming. Functional programming decomposes a problem into a set of functions. Ideally, functions only take inputs and produce outputs, and don't have any internal state that affects the output produced for a given input. Well-known functional languages include the ML family (Standard ML, OCaml, and other variants) and Haskell. In a functional program, input flows through a set of functions. Each function operates on its input and produces some output A more practical benefit of functional programming is that it forces you to break apart your problem into small pieces. Small functions are also easier to read and to check for errors, thus debugging is easier. Functional Programming discourages the use of variables.

 fun factorial (0 : int) : int = 1
 | factorial (n : int) : int = n * factorial (n-1)

The above code snippet is a functional code written in ML to compute factorial of an integer recursively. In the first line, the fun factorial keyword defines a function. The notation (0: int) can be read as ‘0 is of type int’ and : int =1 means that the default return value is 1 when 0 is passed as an argument.

In the second line, (n: int) sets the argument n to integer. int = n * factorial (n-1) means the return value of recursive computation is an integer.

We can observe here that no additional variables are used here, no state information is maintained and there are no side-effects to any variables.

Object Oriented Programming

Object-oriented programming (OOP) is a programming language model that uses objects which are discrete bundles of functions and procedures, often relating to a particular real-world concept such as a bank account holder or hockey player, together with they relate to each other.

Java, Python, C++, Visual Basic .NET and Ruby are the most popular OOP languages today.

     public class Factorial
     {
     public int fact;
     public int factorial(int n)
     {
     if (n <= 1)  
     {
      return 1;
     }
     else 	      
     {
     return n * factorial(n-1);
     }
     }
     }

The above code is written in JAVA to compute factorial of an integer. The method public int factorial (int n) computes the factorial of variable n. If the value of argument n<=1 then 1 is returned. Otherwise, the statement return n* factorial(n-1) calls the function recursively.

A point to note here is that we can maintain various states of the variable private int fact in the above code. If we create 3 instances of the above class (f1, f2 and f3), then the below code in main can maintain 3 states of the variable private int fact.

    public static void main(String argv[])
    {
     Factorial f1 = new Factorial();	//instance 1
     Factorial f2 = new Factorial();	//instance 2 
     Factorial f3 = new Factorial();	//instance 3
     f1.fact = f1.factorial(5);	//state 1 of int fact
     f2.fact = f2.factorial(9);	//state 2 of int fact
     f3.fact = f3.factorial(12);	//state 3 of int fact
    }

Thus an object oriented approach can be used to maintain state information of a variable, which is completely opposite to the functional approach.

Mixing functional and object oriented code

Functional programming is a programming paradigm that uses the functions in their real mathematical sense. Functional programming also provides powerful features such as Lambda Calculus, immutability, powerful pattern matching and continuations that every programmer should benefit. But at the same time, Object oriented paradigm is crucial in programming current industrial applications. A large enterprise software is based on object oriented approach because of better modularity in design, easier maintenance and easy extensibility (addition of features) Because of the individual features of both programming approaches, many new programming languages enable the coders to mix the object oriented and functional code together. While the software design can be based on object oriented approach, its inner functionality can be supported using functional code. Using Lambda Calculus inside the object oriented code Lambda calculus which is an integral part of functional programming, is a formal system designed to investigate function definition, function application and recursion. Lambda calculus can be used to define a computable function and can used to develop a formal set theory. A Lambda function can be passed as an argument to other functions. There is another concept called curried functions when using lambda functions in which, the function reduces the term and returns another function with the normal form. The lambda calculus has only functions of one argument. In the curried function systems, a function with multiple arguments is expressed using a function whose result is another function. Every argument is reduced by default and returns a function. This is a pure functional approach, but Lambdas can be embedded inside the object oriented code so as to make the code more clear, concise and state-less.

 class Array
 def iterate!(code)
   self.each_with_index do |n, i|
     self[i] = code.call(n)
   end
 end
 end
 array = [1, 2, 3, 4]
 array.iterate!(lambda { |n| n ** 2 })
 puts array.inspect

The above code is written in Ruby, to calculate the squares of the given numbers of an array. A class called class Array is defined which contains iterate method. This is a pure object oriented approach. The method iterate iterates through 1 to n. Inside the loop, self[i] = code.call(n) calls the lambda construct for each array member for computing its square. The statement: array.iterate!(lambda { |n| n ** 2 }) is a lambda construct with a single argument n. The value of n is squared using n**2 and is returned back to the calling construct. This demonstrates a functional approach in the same code. In the above program, we observe here that the basic functionality of squaring the number was implemented by a functional code, while the basic design of the program is still object-oriented. Functional code can thus be used to fill up important gaps in the object oriented code and provides a way to implement the functionality in a more clear and concise manner.