Functional Programming

(Using Python)

Software Engineer at Pesto Tech

@salman_arfat

 

Presented at PyDelhi

Life is too short for imperative programming

-- John Hughes (One of the designers of Haskell)

A little bit of History!

Main Programming Paradigms

A paradigm describes distinct concepts or thought patterns some scientific discipline.

  • Imperative Programming
  • Functional Programming
  • Logic Programming
  • Object Oriented Programming

Imperative programming 

  • modifying mutable variables
  • using assignments
  • and control structures such as if-else, loops, break, continue, return

uses statements that change a program's state.

The most common way (informal) way to understand imperative programs is as instruction sequences to a von Neumann Computer

Given a numeric string, get the next character that comes after it.

There's a strong correspondence between

  • Mutable variables ≈ memory cells
  • Variable dereferences ≈ load instructions
  • Variable Assignments ≈ Store instructions
  • Control Structures ≈ Jumps

Problem: How can we avoid conceptualising programs words by word?

Functional Programming

treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data.

It's a paradigm of programming where fundamental operation is the application of functions to arguments.

  • In restricted sense, FP is programming without mutable variables, assignments, loops, and other imperative control structures
  • In a wider sense, focusing on functions
  • Functions are values that can be produced, consumed, and composed.

Example: QuickSort

class QuickSort 
{ 
    int partition(int arr[], int low, int high) 
    { 
        int pivot = arr[high];  
        int i = (low-1); // index of smaller element 
        for (int j=low; j<high; j++) 
        { 
            if (arr[j] <= pivot) 
            { 
                i++; 
  
                int temp = arr[i]; 
                arr[i] = arr[j]; 
                arr[j] = temp; 
            } 
        } 
  
        int temp = arr[i+1]; 
        arr[i+1] = arr[high]; 
        arr[high] = temp; 
  
        return i+1; 
    } 
  
    void sort(int arr[], int low, int high) 
    { 
        if (low < high) 
        { 
            int pi = partition(arr, low, high); 
            sort(arr, low, pi-1); 
            sort(arr, pi+1, high); 
        } 
    }
}

FP combines the flexibility and power of abstract mathematics with the intuitive clarity of abstract mathematics.

-- xkcd

Why is it Useful?

There are many possible answers to this question, but generally speaking:

  • The abstract nature of functional programming leads to considerably simpler programs;
  • It also supports a number of powerful new ways to structure and reason about programs.
total = 0;
for (i = 1; i <= 10; ++i)
   total = total+i;

sum [1..10]

What is a function?

A function is a 

  • relation

  • between input values 

  • to output values

Functional Programs have

  • Pure Functions
  • Immutability
  • No Side effects
  • First Class Functions
  • Higher Order Functions
  • Function Composition
  • and much more ...

Side Effects

A side effect is any application state change that is observable outside the called function other than its return value. Side effects include:

  • Modifying any external variable or object property (e.g., a global variable, or a variable in the parent function scope chain)
  • Logging to the console
  • Writing to the screen
  • Writing to a file
  • Writing to the network
  • Triggering any external process
  • Calling any other functions with side-effects

Stateless programs

  • Idempotent (pure) functions
  • Order of evaluation not defined
  • Lazy evaluation possible
  • Optimizations
  • Concurrent processing
  • Easier to test and debug
  • Side effects can’t be eliminated, but can be isolated

Higher Order Functions

A function is called higher-order if it takes a function as an argument or returns a function as a result.

The Map Function

The higher-order library function called map applies a function to every element of a list.

map :: (a -> b) -> [a] -> [b]

> map (+1) [1,3,5,7]

[2,4,6,8]

Reduce

def nextCharFromNumberString(numStr):
    trimmed = numStr.strip()
    number = int(trimmed)
    number = number + 1
    return chr(number)

result = nextCharFromNumberString('   64    ')
print(result)
def nextCharFromNumberString2(numStr):
    return map(
        chr,
        map(
            lambda num: num + 1,
            map(
                lambda stripped: int(stripped), 
                map(
                    lambda string: string.strip(), 
                    [numStr]
                )
            )
        )
    )

Example

  • We have a dict of colors with their hex values.
  • We want to remove the hash sign 
  • and turn the string to uppercase.
def findColor(name):
    colors = {
        'red': '#ff4444', 
        'blue': '#3b5998', 
        'yellow': '#fff68f'
    }
    return colors.get(name)

Left or Right

Either = Right || Left

Enforce a null check with composable code branching using Either

Either doesn't actually come into play. It will just refer to one of these two types.

Usually, we don't know if we have a Right or a Left. We don't know which one it is.

class Left:
    def __init__(self, x):
        self.x = x
    def map(self, f):
        return Left(self.x)
    def fold(self, f, _):
        return f(self.x)
    def __str__(self):
        return 'Left(%s)' % self.x


class Right:
    def __init__(self, x):
        self.x = x
    def map(self, f):
        return Right(f(self.x))
    def fold(self, _, g):
        return g(self.x)
    def __str__(self):
        return 'Right(%s)' % self.x
Made with Slides.com