Control flow on OOFP 2025-26

Pattern matching

Mon, 01 Jan 0001 00:00:00 +0000

Pattern matching #

Pattern matching is a traditional feature of functional languages. It pairs well with sum types (which we will see later).

Pattern matching is no longer exclusive to functional languages: several imperative languages now support it to some extent (natively or via libraries). This includes:

C# (since 2020),
Java (since 2021),
PHP (since 2021),
Python (since 2021)
Rust (since its first release in 2015).

in Haskell #

A pattern is a syntactic expression that can match certain values.

Boolean condition

Mon, 01 Jan 0001 00:00:00 +0000

Boolean condition #

Pattern matching has limitations.

Examples. No pattern can match:

integers greater than 2,

odd integers,

etc.

For more expressive conditions, programming language usually rely on Boolean expressions.

In Haskell #

Boolean expression #

We have seen how to define a Boolean operator (precisely, the Boolean operator “AND”) with patterns in Haskell.

This is not necessary: Haskell provides native implementations, similar to their counterparts in Java (and many programming languages). They include:

List comprehension

Mon, 01 Jan 0001 00:00:00 +0000

List comprehension #

Pure functional programming does not admit loops.

In particular, this is the case of Haskell. So iteration in Haskell is primarily achieved via recursive functions.

Besides, Haskell provides an alternative syntax for a limited form of iteration, called list comprehensions.

List comprehensions are also available in Python (with a slightly different syntax) since the release of Python 2 (in 2000).

Syntax #

We have already seen set comprehensions.

Call stack

Mon, 01 Jan 0001 00:00:00 +0000

Call stack #

During the execution of a program, the call stack keeps track of ongoing function/method calls:

when a function/method is called, a frame is pushed on top of the stack: the frame stores information about the execution of the function/method (current value of variables, …),

when the execution of the call terminates, the frame is popped from the stack, and control is passed back to the calling function/method (whose frame is now on top of the stack).