Functional Programming Lecture Revision
Notes
1. Introduction to Functional Programming
Key Concepts:
Functions as first-class citizens
Immutability
Declarative programming style
Emphasis on what to do, not how to do it
Advantages:
Easier to reason about and test
Facilitates parallel processing
Reduces side effects and bugs
2. Pure Functions
Definition:
A function that always produces the same output for the same input and has no side effects.
Characteristics:
Deterministic
No state changes
No I/O operations
Example:
haskell
Copy
-- Pure function
add :: Int -> Int -> Int
add x y = x + y
-- Impure function (due to I/O)
getAndPrintNumber :: IO ()
getAndPrintNumber = do
num <- getLine
print (read num :: Int)
3. Immutability
Definition:
Once a value is created, it cannot be changed.
Benefits:
Prevents unexpected changes
Facilitates concurrent programming
Simplifies debugging
Example:
haskell
Copy
-- Immutable list operation
addToList :: [Int] -> Int -> [Int]
addToList xs x = xs ++ [x] -- Creates a new list
4. Higher-Order Functions
Definition:
Functions that take other functions as arguments or return functions.
Common Higher-Order Functions:
map
filter
fold (reduce)
Examples:
haskell
Copy
-- map example
doubleList :: [Int] -> [Int]
doubleList = map (*2)
-- filter example
evenNumbers :: [Int] -> [Int]
evenNumbers = filter even
-- fold example
sumList :: [Int] -> Int
sumList = foldl (+) 0
5. Recursion
Definition:
A method of solving problems by breaking them down into smaller, self-similar subproblems.
Types:
Direct recursion
Indirect recursion
Tail recursion
Example:
haskell
Copy
-- Factorial function using recursion
factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n * factorial (n - 1)
-- Tail-recursive version
factorialTail :: Integer -> Integer -> Integer
factorialTail acc 0 = acc
factorialTail acc n = factorialTail (acc * n) (n - 1)
6. Pattern Matching
Definition:
A mechanism for checking a value against a pattern and, optionally, binding variables to
successful matches.
Uses:
Function definitions
Case expressions
List comprehensions
Example:
haskell
Copy
-- Pattern matching in function definition
isZero :: Int -> Bool
isZero 0 = True
isZero _ = False
-- Pattern matching in list comprehension
firstElements :: [(a, b)] -> [a]
firstElements xs = [x | (x, _) <- xs]
7. Lazy Evaluation
Definition:
A strategy where expressions are only evaluated when their results are needed.
Benefits:
Can work with infinite data structures
Improves performance for unused computations
Enables separation of concerns in code
Example:
haskell
Copy
-- Infinite list of Fibonacci numbers
fibs :: [Integer]
fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
-- Taking first 10 Fibonacci numbers
first10Fibs = take 10 fibs
8. Algebraic Data Types
Definition:
Composite types formed by combining other types.
Types:
Sum types (OR)
Product types (AND)
Example:
haskell
Copy
-- Sum type
data Shape = Circle Float | Rectangle Float Float
-- Product type
data Person = Person { name :: String, age :: Int }
-- Recursive algebraic data type
data Tree a = Leaf a | Node (Tree a) a (Tree a)
9. Type Classes
Definition:
A way to define generic interfaces that provide a common feature set for various types.
Common Type Classes:
Eq
Ord
Show
Functor
Monad
Example:
haskell
Copy
class Sizeable a where
size :: a -> Int
instance Sizeable [a] where
size = length
instance Sizeable (Tree a) where
size (Leaf _) = 1
size (Node left _ right) = 1 + size left + size right
10. Monads
Definition:
A design pattern that allows structuring programs generically while automating away
boilerplate code needed by the program logic.
Key Concepts:
Wrapping computations in a context
Sequencing operations
Handling side effects safely
Example:
haskell
Copy
-- Maybe monad for handling potential failure
safeDivide :: Float -> Float -> Maybe Float
safeDivide _ 0 = Nothing
safeDivide x y = Just (x / y)
divideAndAdd :: Float -> Float -> Float -> Maybe Float
divideAndAdd x y z = do
result <- safeDivide x y
return (result + z)
11. Functional Data Structures
Characteristics:
Immutable
Often implemented using recursion
May use lazy evaluation
Common Structures:
Lists
Trees
Maps
Example:
haskell
Copy
-- Implementing a functional stack
type Stack a = [a]
push :: a -> Stack a -> Stack a
push x xs = x:xs
pop :: Stack a -> Maybe (a, Stack a)
pop [] = Nothing
pop (x:xs) = Just (x, xs)
12. Function Composition
Definition:
The act of combining two or more functions to produce a new function.
Operator:
In Haskell: (.)
Example:
haskell
Copy
-- Function composition
isEvenLength :: [a] -> Bool
isEvenLength = even . length
-- Equivalent to:
-- isEvenLength xs = even (length xs)
Remember:
Practice writing pure functions
Think recursively
Embrace higher-order functions and composition
Utilize pattern matching for cleaner code
Understand and use appropriate data structures
Functional Programming Revision Notes
1. Immutability
Definition: Immutability refers to the property of an object whose state cannot be modified
after it is created. In functional programming, data structures are typically immutable.
Importance:
Predictability: Easier to reason about code behavior since immutable objects do not
change.
Concurrency: Reduces issues related to shared state, minimizing race conditions.
Functional Purity: Encourages the use of pure functions that rely solely on their
input parameters.
2. First-class Functions
Definition: Functions are treated as first-class citizens, meaning they can be assigned to
variables, passed as arguments, and returned from other functions.
Importance:
Higher-order Functions: Enables functions that can take other functions as
arguments or return them, facilitating abstraction and code reuse.
Flexibility: Allows for dynamic and flexible code structures, enabling patterns like
callbacks and function composition.
Encapsulation: Functions can encapsulate behavior, leading to cleaner and more
modular code.
3. Pure Functions
Definition: A pure function is one that, given the same input, will always return the same
output and has no side effects (does not modify any external state).
Importance:
Testability: Easier to test since output is predictable and does not depend on
external state.
Debugging: Simplifies debugging as you can reason about the function's behavior
without considering external factors.
Referential Transparency: Allows functions to be replaced with their output without
changing the program's behavior.
4. Referential Transparency
Definition: A program is referentially transparent if an expression can be replaced with its
corresponding value without changing the program's behavior.
Importance:
Code Optimization: Enables compilers to optimize code more effectively by safely
replacing expressions with their values.
Simplified Reasoning: Makes reasoning about code easier, leading to clearer and
more maintainable code.
Functional Composition: Facilitates the composition of functions, allowing for more
modular and reusable code.
5. Lazy Evaluation
Definition: A programming technique where expressions are not evaluated until their values
are needed, improving performance and resource management.
Importance:
Efficiency: Improves performance by avoiding unnecessary calculations, especially
when not all data is needed.
Infinite Data Structures: Allows the creation and manipulation of infinite data
structures, as values are computed on demand.
Separation of Concerns: Encourages a separation between the definition of data and
its evaluation, leading to cleaner and more declarative code.
6. Higher-order Functions
Definition: Functions that can take other functions as arguments or return them as results.
Importance:
Abstraction: Allows for more abstract and reusable code.
Function Composition: Enables the combination of simple functions to build more
complex operations.
7. Function Composition
Definition: The process of combining two or more functions to produce a new function.
Importance:
Modularity: Promotes modular design by allowing small, reusable functions to be
combined.
Clarity: Enhances code clarity by expressing complex operations in a more
understandable way.
Summary
Functional programming emphasizes immutability, first-class functions, pure functions, referential
transparency, and lazy evaluation. These concepts contribute to writing efficient, maintainable, and
scalable code. Understanding these principles is crucial for leveraging the full power of functional
programming languages and paradigms.
