These are functions that always produce the same result if you give them the same input. They are predictable because they do not rely on any outside information.

Pure Functions

Instead of updating existing information, you create new versions of it. This prevents accidental mistakes that happen when multiple parts of a program try to change the same thing.

Data That Never Changes

This means you can treat a piece of code like a regular variable. You can pass a task to another part of the program just like you would pass a number or a name.

Functions as Values

Some functions are designed to accept other functions as inputs or give them back as results. This allows you to build very flexible and reusable tools.

Functions That Help Functions

A good functional program ensures that a specific task only returns a value. It does not accidentally change things elsewhere, like updating a hidden file or changing a global setting.

Avoiding Side Effects

This is the act of linking small, simple tasks into a sequence. By connecting these 'pipes,' you can build a complex system out of very easy-to-understand parts.

Chaining Functions Together

This approach focuses on telling the computer what you want the final result to look like. It avoids giving a long, step-by-step list of every tiny manual instruction.

Describing the Goal

Instead of using standard loops, a function can solve a problem by calling a smaller version of itself. This continues until the task is simple enough to finish instantly.

Self-Repeating Logic

The computer waits to perform a calculation until the very last second when the result is actually needed. This saves energy and memory by ignoring work that might never be used.

Doing Work Later

This technique takes a group of items and applies a specific rule to every single one. The result is a brand-new group where every item has been updated according to that rule.

Transforming a List

You can look through a large collection and keep only the items that match a certain condition. It is like using a sieve to separate the pieces you want from the ones you do not.

Picking Specific Items

This takes a whole list of information and combines it into one single value. A common example is adding up a list of prices to get one total at the bottom.

Shrinking Data Down

Instead of giving a function all its information at once, you give it one piece at a time. Each step creates a simpler function that waits for the next piece of info.

Breaking Down Inputs

Because functions are predictable, you can replace a call to a function with its final result without breaking the program. This makes the code much easier to test and fix.

Safe Code Replacement

Sometimes a function can 'remember' the information that was around when it was first created. This allows it to carry its own private context wherever it goes in the program.

Welcome to Function Chaining