What is Functional Programming?

Functional Programming, often written as FP, is a programming paradigm where programs are built mainly by using functions.

In functional programming, we focus on writing functions that take input, process it, and return output without changing outside data unnecessarily.

In simple words, functional programming encourages us to write code like this:

INPUT → FUNCTION → OUTPUT

The goal is to make programs more predictable, easier to test, easier to debug, and easier to reuse.

Easy Real-Life Example

A good function in functional programming works similarly. It takes input, returns output, and avoids unnecessary side effects.

mangoes → makeJuice() → mango juice
apples  → makeJuice() → apple juice

Why Do We Need Functional Programming?

Functional programming is useful because large programs can become difficult to understand when data changes from many places.

When many parts of a program modify the same data, bugs become harder to find. Functional programming reduces this problem by encouraging pure functions and immutable data.

Important Terms in Functional Programming

Pure Functions

A pure function is one of the most important concepts in functional programming.

A function is called pure when:

Pure Function Example

/*
This is a pure function.
Same input always gives same output.
*/

FUNCTION add(a, b)
    RETURN a + b
END FUNCTION

ENTRY POINT
    DISPLAY add(5, 3)
END ENTRY POINT

Expected Output

8

The function add does not change anything outside itself. It simply returns the sum.

Impure Function

An impure function depends on or changes something outside itself.

Impure Function Example

/*
This is an impure function because it changes an external variable.
*/

DECLARE total AS INTEGER = 0

FUNCTION addToTotal(value)
    SET total = total + value
    RETURN total
END FUNCTION

This function changes the external variable total. Because of this, the result may depend on previous function calls.

Pure Function vs Impure Function

Immutability

Immutability means not changing existing data directly.

Instead of modifying old data, functional programming encourages creating new data with the required changes.

Mutable Style

/*
This changes the original list.
*/

numbers = [10, 20, 30]

ADD 40 TO numbers

numbers becomes [10, 20, 30, 40]

Immutable Style

/*
This creates a new list instead of changing the original list.
*/

oldNumbers = [10, 20, 30]

newNumbers = oldNumbers + [40]

oldNumbers remains [10, 20, 30]
newNumbers becomes [10, 20, 30, 40]

Side Effects

A side effect happens when a function changes something outside its own local work.

Side effects are not always bad. Real programs need input, output, files, databases, and network calls. Functional programming simply encourages keeping side effects controlled and separated from core logic.

First-Class Functions

In functional programming, functions can often be treated like values.

This means a function can be:

Conceptual Example

FUNCTION double(number)
    RETURN number * 2
END FUNCTION

SET operation = double

DISPLAY operation(5)

Expected Output

10

Here, double is treated like a value and assigned to operation.

Higher-Order Functions

A higher-order function is a function that either:

Higher-order functions are useful because they allow us to write flexible and reusable logic.

Conceptual Example

FUNCTION applyOperation(number, operation)
    RETURN operation(number)
END FUNCTION

FUNCTION square(x)
    RETURN x * x
END FUNCTION

ENTRY POINT
    DISPLAY applyOperation(5, square)
END ENTRY POINT

Expected Output

25

Here, applyOperation accepts another function as input.

Map, Filter, and Reduce

Map, filter, and reduce are common functional programming operations used with lists or collections.

Map Example

numbers = [1, 2, 3, 4]

double each number

Result:
[2, 4, 6, 8]

Filter Example

numbers = [1, 2, 3, 4, 5, 6]

keep only even numbers

Result:
[2, 4, 6]

Reduce Example

numbers = [1, 2, 3, 4]

sum all numbers

Result:
10

Example 1: Transform Student Marks Using Map

Suppose every student receives 5 bonus marks.

/*
This example creates a new list of updated marks.
*/

ENTRY POINT
    DECLARE marks AS LIST = [70, 80, 90]

    DECLARE updatedMarks AS LIST = MAP each mark IN marks:
        RETURN mark + 5

    DISPLAY updatedMarks
END ENTRY POINT

Expected Output

[75, 85, 95]

Example 2: Filter Passing Students

Suppose passing marks are 50 or above.

/*
This example filters only passing marks.
*/

ENTRY POINT
    DECLARE marks AS LIST = [35, 60, 48, 75, 90]

    DECLARE passingMarks AS LIST = FILTER each mark IN marks:
        RETURN mark >= 50

    DISPLAY passingMarks
END ENTRY POINT

Expected Output

[60, 75, 90]

Example 3: Reduce Marks to Total

/*
This example calculates total marks using reduce idea.
*/

ENTRY POINT
    DECLARE marks AS LIST = [80, 75, 90]

    DECLARE total AS INTEGER = REDUCE marks:
        ADD all marks together

    DISPLAY total
END ENTRY POINT

Expected Output

245

Function Composition

Function composition means combining multiple small functions to create a larger operation.

Instead of writing one big function, we write small functions and connect them.

Input Text
   ↓
trim()
   ↓
lowercase()
   ↓
validate()
   ↓
Result

Example: Clean User Input

FUNCTION trimText(text)
    RETURN text without extra beginning and ending spaces
END FUNCTION

FUNCTION convertToLowercase(text)
    RETURN lowercase version of text
END FUNCTION

FUNCTION cleanInput(text)
    RETURN convertToLowercase(trimText(text))
END FUNCTION

Here, cleanInput is built by combining smaller functions.

Recursion

Recursion means a function calls itself to solve a smaller version of the same problem.

Recursion usually needs:

Factorial Example

/*
Factorial of 5:
5 × 4 × 3 × 2 × 1 = 120
*/

FUNCTION factorial(n)
    IF n == 0 THEN
        RETURN 1
    ELSE
        RETURN n * factorial(n - 1)
    END IF
END FUNCTION

ENTRY POINT
    DISPLAY factorial(5)
END ENTRY POINT

Expected Output

120

Functional Programming vs Imperative Programming

Functional Programming vs Object-Oriented Programming

Functional programming and object-oriented programming are both useful paradigms.

Advantages of Functional Programming

Limitations of Functional Programming

Common Beginner Mistakes

Best Practices for Functional Programming

Prerequisites Before Learning Functional Programming

Students should understand the following topics before learning functional programming:

Trace Table Example: Map Operation

Let us trace a map operation that doubles each number.

numbers = [1, 2, 3]
result = MAP each number:
    RETURN number * 2

Final result is [2, 4, 6].

Practice Activity: Identify Pure and Impure Functions

Identify whether each function is pure or impure.

1. FUNCTION square(x)
       RETURN x * x
   END FUNCTION

2. FUNCTION addToGlobalTotal(x)
       globalTotal = globalTotal + x
       RETURN globalTotal
   END FUNCTION

3. FUNCTION calculateAverage(total, count)
       RETURN total / count
   END FUNCTION

4. FUNCTION printMessage(message)
       DISPLAY message
   END FUNCTION

Sample Answers

1. Pure
2. Impure
3. Pure
4. Impure because it performs output as a side effect

Mini Quiz

Interview Questions on Functional Programming

Quick Summary