OCaml Recursion with Lists: Length and Sum Functions

Higher-order functions accept or return other functions. Map applies a function to every list element: map (*3) [1..10]. Filter creates lists with elements satisfying conditions. FoldL applies an operation from left to right across list elements: foldl (*) 1 [2,3,4,5] = 120. FoldR processes from right to left. List comprehensions provide declarative list generation: [x*3 | x <- [1..10]], [(x,y) | x <- [1..3], y <- ['a'..'c']].

OCaml provides powerful higher-order functions for list processing: List.iter applies a function to each element without returning a value (side effects); List.map transforms elements and returns a new list; List.fold_left and List.fold_right combine elements using a binary function with an accumulator; List.scan_left and List.scan_right produce intermediate accumulated results. These functions enable functional programming patterns like transformation, reduction, and accumulation.

Fold left and fold right are fundamental higher-order functions in Haskell's Prelude for list processing. Fold left processes lists from left to right, taking a binary function, initial value, and list, applying the function successively to the accumulator and each element. Fold right processes from right to left, with reversed argument order. Both have polymorphic type signatures: foldl :: (t1 -> t2 -> t1) -> t1 -> [t2] -> t1 and foldr :: (t2 -> t1 -> t1) -> t1 -> [t2] -> t1. They yield identical results only when the folding function is associative and commutative (like plus), but differ for non-associative functions (like minus). The map function is essentially a special case of fold right, where the accumulator is always an empty list. This demonstrates how fold operations provide a powerful abstraction for list transformations in functional programming.

Higher-order functions take other functions as parameters or return functions as results. Racket provides three key higher-order functions: filter (selects elements matching a predicate), map (applies a function to each element), and fold (reduces a list to a single value). Fold uses an accumulator that holds intermediate results. foldl processes left-to-right, foldr processes right-to-left. The initial value for the accumulator affects results, especially for operations like multiplication where 1 is neutral. Mixed types in lists can cause type errors if the accumulator and elements are incompatible.

The OCaml List module provides two fundamental higher-order functions for list iteration: fold_left and fold_right. fold_left applies a binary function to list elements from left to right, accumulating results by passing the previous result as the first argument to the next function call. fold_right applies the same function from right to left, passing the accumulated result as the second argument. Both functions are naturally recursive and can be implemented using pattern matching on the list structure. These functions are essential for functional programming as they enable elegant list transformations without explicit loops, supporting operations like summing elements, accumulating values, and applying custom transformations across list data structures.

After finding the mid point, merge sort recursively applies itself to the left half (from low to mid) and the right half (from mid+1 to high). This recursive division continues until the base case is reached.

The recursive implementation of Merge Sort uses a function that takes the array and its left and right boundaries. The function calculates the middle index, recursively calls itself on the left half and right half, then calls a merge function to combine the sorted halves. This recursive structure continues until base cases of single-element lists are reached.

This comprehensive segment covers the foundational list operations in OCaml: finding the last element, finding the last two elements, and accessing the nth element using pattern matching with cases for empty lists, single elements, and multiple elements. The instructor demonstrates recursive function declarations, handling edge cases, and using exceptions for out-of-bounds access. The segment then covers computing list length through recursive and tail-recursive approaches, explaining the critical difference in memory usage where standard recursion uses stack space proportional to list length while tail recursion passes an accumulator parameter for constant stack space. The segment concludes with reversing lists and checking palindromes by comparing original and reversed lists, demonstrating how to leverage previously solved problems and use functional transformations.

The pseudocode structure involves: (1) finding the middle index (mid = (low + high) // 2), (2) recursively calling merge_sort on the left half (low to mid), (3) recursively calling merge_sort on the right half (mid+1 to high), (4) then calling the merge function to combine the sorted halves. This recursive divide-and-conquer structure is the core of merge sort.

The recursive Merge Sort function takes an array with left and right indices defining the current subarray. The base case returns when left equals right (single element). Calculate mid = (left + right) // 2, then recursively call merge_sort on left half (left to mid) and right half (mid+1 to right). After recursion completes, a helper merge function combines the sorted halves. The initial call uses left=0 and right=len(nums)-1. This modular structure enables efficient recursive sorting.

This segment introduces type schemes as the solution to polymorphism. Type schemes use universal quantification (forall alpha.t) to allow functions to work with multiple independent type variables. The identity function should have type scheme forall alpha. alpha -> alpha, enabling it to be applied to any type. Multiple type variables can be quantified (alpha1 alpha2 ... alphaN . t). In OCaml, type schemes are always present but not printed by default—when you see 'alpha list -> int', it implicitly means 'forall alpha. alpha list -> int'. Programmers can manually write explicit quantification, but the compiler handles implicit quantification automatically, keeping type information concise while maintaining full polymorphic functionality.

OCaml encourages immutability as the norm while allowing imperative programming as exceptions. Key features include algebraic data types with pattern matching, higher-order functions, and Hindley-Milner type inference. Pattern matching enables elegant list processing without mutable variables—for example, calculating list length by recursively matching empty lists (return 0) and non-empty lists (return 1 plus rest length). The compiler infers polymorphic types, so the same function works for lists of integers, strings, or any data structure.

Polymorphic functions contain type variables (lowercase letters like a, b, c) that act as placeholders for any type. The length function has type [a] -> Int, working for lists of any type. Type variables must begin with lowercase letters, while concrete types begin with uppercase letters. Overloaded functions contain class constraints restricting valid types. The three main classes are: Num (numeric types like Int, Float), Eq (equality types), and Ord (ordered types). Functions can be overloaded to work with any type in a class. Best practices include writing types before implementing functions, as this helps define functions correctly and serves as documentation. The type inference system will check that declared types match calculated types. For polymorphic functions, class constraints must be included in type signatures.

In OCAML, anonymous functions are function expressions created using the 'fun' keyword followed by parameters and an arrow (->) to the body, and they can be given names by assigning them to variables; polymorphic functions are those that can accept parameters of any type as long as all parameters are of the same type, allowing the same function to work with integers, floats, strings, or characters without specifying types explicitly.

OCaml supports polymorphic functions that work across multiple types. The identity function 'fun x -> x' has type 'a -> 'a, meaning it works for any type. Polymorphism enables writing generic code that adapts to different data types, increasing code reuse and reducing duplication.