Fonctions de première classe et fonctions d'ordre supérieur

In Clojure, functions are "first-class citizens." This means they are treated just like any other value, such as numbers or strings.

You can:

• Assign them to variables.
• Pass them as arguments to other functions.
• Return them as results from other functions.

This powerful concept is fundamental to functional programming!

Let's see how we can treat functions as values by assigning them to a name using def or let. Think of it as giving a nickname to a function.

Try running this example:

A key aspect of first-class functions is the ability to pass them as arguments to other functions. This allows for highly flexible and reusable code.

Imagine a function that performs an operation, but what operation it performs is decided by another function you pass to it!

Try running this example:

Functions can also create and return new functions. This is useful for building "function factories" that produce specialized functions based on some input.

Here, make-adder takes a number and returns a new function that adds that number to its input.

Try running this example:

When a function either takes one or more functions as arguments, or returns a function as its result, it's called a Higher-Order Function (HOF).

HOFs are incredibly powerful because they allow you to:

• Abstract common patterns.
• Write more concise and expressive code.
• Create flexible and reusable program components.

Let's look at some common HOFs in Clojure!

map is a fundamental higher-order function. It applies a given function to each item in a collection (like a list or vector) and returns a new collection containing the results.

It's perfect for transforming data without changing the original collection.

Try running this example:

The filter HOF takes a "predicate" function (a function that returns true or false) and a collection. It returns a new collection containing only the elements for which the predicate function returns true.

This is great for selecting specific items from a list.

Try running this example:

reduce is another powerful HOF that combines all elements of a collection into a single result. It takes a combining function, an optional initial value, and a collection.

The function is applied cumulatively to each item, often used for summing, finding max/min, or concatenating.

Try running this example:

Often, the functions we pass to HOFs are small and used only once. For these, Clojure provides anonymous functions, also known as lambdas.

They use the shorthand #(...) syntax, where % refers to the first argument, %1 for the first, %2 for the second, and so on.

Try running this example:

You've learned about first-class and higher-order functions. Now, let's test your understanding of how they can be combined to achieve specific data transformations.

Consider the sequence of numbers (range 1 6), which evaluates to (1 2 3 4 5).

Which Clojure expression correctly uses higher-order functions to get a list of squared even numbers from this sequence?

Congratulations! You've unlocked the power of first-class and higher-order functions in Clojure!

Here's what we covered:

• First-Class Functions: Functions can be treated like any other data type – assigned to variables, passed as arguments, and returned from other functions.
• Higher-Order Functions: Functions that operate on other functions (taking them as arguments or returning them).
• Key HOFs: We explored map for transformation, filter for selection, and reduce for aggregation.
• Anonymous Functions: The #(...) syntax for concise, inline function definitions.

These concepts are central to writing expressive and flexible Clojure code. Keep practicing!