Pattern Matching with Lists | OCaml Programming Tutorial

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.

This section covers advanced OCaml concepts including higher-order functions and built-in list operations. Higher-order functions take other functions as arguments or return functions as results. List.fold_left applies a binary function to accumulate results from left to right, useful for operations like summing. List.fold_right processes lists from right to left. List.map applies a function to each element, creating a new transformed list. List.length returns the number of elements. The 'fun' keyword creates anonymous functions for inline use. Lists are immutable collections written with square brackets and semicolon-separated elements. The 'h :: t' pattern decomposes lists into head and tail. Custom types can be used in function parameters and return types. These higher-order functions enable concise, declarative list processing without explicit recursion.

This section introduces the filter abstraction, which creates new lists containing only elements satisfying a predicate function. The instructor shows how similar filter functions for even numbers and positive numbers share identical structure, motivating the filter abstraction. The section concludes by introducing the Edict of Decomposition—carving software at its joints by separating concerns into distinct abstractions. The instructor notes that OCaml's built-in list module provides these abstractions (map, filter, fold_right, fold_left), enabling programmers to use these patterns without reimplementing them.

Higher-order functions abstract common recursion patterns. Map applies a function to every element: map f [] = []; map f (x:xs) = f x : map f xs. Filter selects elements satisfying a predicate: filter _ [] = []; filter p (x:xs) | p x = x : filter p xs | otherwise = filter p xs. Foldl and foldr reduce lists by applying binary functions—foldl processes left-to-right, accumulating forward; foldr processes right-to-left, accumulating backward. These functions abstract recursion, replacing explicit pattern matching with function composition. Point-free style hides arguments entirely, though it's controversial for readability.

The 'map' function is a higher-order function that applies another function to every element of a list. It's implemented recursively: empty list returns empty list, non-empty applies function to head and recursively maps tail. Inline anonymous functions 'fun x -> x + 1' provide concise syntax for simple transformations. The map function can be used with named functions like factorial or on lists of lists to apply functions to each sublist.

Pattern matching supports guard clauses (using 'when') for conditional case matching, nested records for drilling into complex data structures, and type patterns that unify instanceof testing with variable binding. These features enable sophisticated data analysis while maintaining readability. The syntax allows extracting specific nested components while ignoring others using underscores, similar to JavaScript destructuring patterns.

Pattern matching can handle tuples and other composite data structures. The 'as' keyword allows capturing matched values into variables for later use. Guards (conditions specified after the pattern) allow additional filtering beyond the basic pattern match. This enables complex pattern matching where you can check both the structure and specific conditions of the input.

Pattern guards add conditions to match branches using the `when` keyword. After binding variables, you can specify additional constraints. For example, `VAR x, VAR y when x == y` matches any two numbers and only proceeds if they are equal. Similarly, `VAR x, VAR y when x == -y` matches numbers that are opposites. Guards allow complex conditional logic within match patterns without nested if statements.

Guards add conditions to pattern matches using 'when' clauses. For example, '| x when x % 2 = 0 -> true' matches even numbers. Guards allow conditional logic within pattern matching, combining pattern matching with boolean tests. The underscore ('_') wildcard is used when you don't care about the matched value.

The when statement in Kotlin is a powerful control flow alternative to if-else statements for evaluating variables against multiple patterns. It uses 'when' keyword followed by parentheses containing the expression to evaluate, with each pattern followed by a colon and code block. The statement supports string types with multiple patterns (like country names) and integer types with range syntax using 'in start..end' to define inclusive ranges. Multiple patterns can be combined using commas for shared code blocks. The else clause provides a default fallback when no pattern matches. This approach is cleaner and more maintainable than multiple if-else statements when handling categorical data or range-based conditions.

Algebraic data types (ADTs) are sum types representing choices between constructors. Examples include lists (nil or cons), trees (empty or node), and options (none or some). Custom ADTs ensure exhaustive pattern matching: defining data type order = Less | Equal | Greater creates exactly three possible values. The compiler verifies all cases are handled, catching typos at compile time. This eliminates impossible cases and prevents runtime errors from unhandled patterns, unlike returning integers or strings where invalid values can slip through.

Algebraic data types are defined using the Data keyword with a type name (starting with capital letter) and its constructors. A type can be thought of as a 'bag' containing values, where each constructor represents a distinct value. Constructors immediately create values of that type. However, simple type definitions with no arguments have limitations—a 'figura' type with only 'círculo' and 'rectángulo' constructors cannot distinguish between different sizes or properties. To make types more useful, you can add arguments to constructors (e.g., 'rectángulo' takes four floats for dimensions). Pattern matching allows functions to behave differently based on argument structure: a variable (like 'f') acts as a wildcard matching any value, while specific constructors match only that type. The order of patterns matters because the first matching pattern is executed.

Algebraic Data Types (ADTs) originated in ML (1973), introducing type inference, generics, and pattern matching that influenced modern languages. ADTs combine enums and records into a single construct, enabling types that represent multiple possibilities with associated data. In Scala, ADTs use the 'enum' keyword with case constructors, each defining how values are built. Pattern matching consumes ADTs by asking 'what kind of value is this?' and extracting components accordingly. This provides exhaustive case handling with compiler enforcement, solving common problems like optional data representation where traditional nulls fail to enforce invariants.

Enums in Rust are algebraic data types that can have multiple variants. Each variant can have associated data (fields) or be unit variants (no data). Enums are defined using the 'enum' keyword followed by the enum name and variant declarations. Rust supports pattern matching on enums using 'match' expressions, allowing handling each variant differently based on its associated data. This enables writing code that handles different cases based on the enum variant. Pattern matching is a powerful feature for working with algebraic data types.

ADTs can be constructed inline for simple cases or composed from existing records for complex systems. Pattern matching replaces manual discriminant checking with declarative syntax that handles different variants while preserving type safety. Type guards within matchers enable TypeScript to correctly narrow types at each branch, ensuring compile-time verification of case coverage. Generic codec dispatching at the ADT level automatically routes serialization/deserialization to the appropriate member implementation, eliminating manual codec selection when handling mixed ADT instances.

Generics implement polymorphic parametric polymorphism, where the type parameter is passed as a parameter to the class. When you create a LinkedList<Integer>, the list is bound to work only with Integer objects. This is different from runtime polymorphism (inheritance-based). The key benefit is that you can work with specific types while still maintaining the flexibility of polymorphism through inheritance. You can create lists of different types (LinkedList<Integer>, LinkedList<String>, LinkedList<Vaca>) and each will enforce its own type constraints.

Generic functions enable a single function definition to work with multiple types using type variables (lowercase names) instead of concrete types. This parametric polymorphism allows functions like 'twice' to work with integers, strings, or any compatible type. Type variables are replaced with specific types each time the function is called, enabling flexible and reusable code without sacrificing type safety. The compiler ensures type consistency across all uses of the generic function.

Generics (parametric polymorphism) enable code to work with any type while preserving type information at compile time. Unlike object-oriented subtype polymorphism where collections lose type information, generics remember the type of elements they contain. This enables strongly typed helper methods and eliminates runtime casts. Type inference further improves usability by automatically deducing generic type arguments from method arguments, reducing boilerplate code.

Parametric polymorphism is a programming paradigm that enables writing generic code that works uniformly across different data types without sacrificing type safety; it uses type variables (like α) to represent unspecified types, allowing functions and data types to be defined once and reused for any type, such as implementing a length function that works for int lists, string lists, or even nested lists by having the type system infer appropriate instantiations based on usage context.

Parametric polymorphism uses generic types (A, B) to create highly abstract functions. The more abstract a function signature is, the fewer ways there are to implement it, reducing developer choices and potential mistakes. When a function takes and returns a generic type A with no constraints, the only valid implementation is to return the input unchanged. Adding container types like List increases implementation possibilities slightly, while adding concrete types like Int dramatically expands options. This principle helps developers write correct code with less thinking.