Join The Clean Code Studio Newsletter
First-class functions can either accept another function as an argument or return a function. Being able to create functions and return them or pass them
to other functions becomes extremely useful in code
reusability and code abstractions.
First-class functions are functions treated as objects themselves, meaning we can pass a function as a parameter to another function, return a function from a function, or store a function in a variable.
Pure functions are one of the most useful features in functional programming, as well as one of the more difficult concepts to learn and use effectively.
In its most generalized form, a function is merely a way to encapsulate a piece of work so that we can easily reference
it again.
Name - used to identify the function
Parameter List - containing objects to operate on
Body - where we transform the parameters and execute some logic
Return - to specify the result
Function: {
name: 'add',
args: numeric,
body: sum = numeric + 1
return: sum
}
A pre-condition confirms that the args passed in are of a specific type.
For example, we could enforce our numeric arg to be an integer like so before we execute the call.
function addOne(numeric) {
if (typeof numeric !== 'integer') {
throw new Error(`Type ${typeof numeric} is invalid. Parameter must Must be an Integer`)
}
let sum = numeric + 1
return numeric
}
We have created a pre-condition on our function. The condition that needs to be met previous to our function running is that the numeric arg must be of the Integer type.
A concise way to add a pre-condition is to use type checking on the function input.
(given your language allows it typescript, Java, C++, etc...).
function addOne(integer numeric) {
let sum = numeric + 1
return numeric
}
This removes the need to add your own condition and executes before the function runs.
A post-condition is used directly after your function body runs and is used to conditionally check the given return from your function is of the right type.
function addOne(numeric) {
let sum = numeric + 1
/** Post Condition **/
if (typeof sum !== 'integer') {
throw new Error(`addOne must return an integer type`)
}
return sum
}
A concise way to add a post-condition is to use type checking on the return value of your function. (for languages that allow it - typescript, PHP, Java, etc...)
function addOne (numeric) : integer {
return numeric + 1
}
Adding preconditions and post-conditions together, we can confirm the input and the output are of the given types we what we expect.
function addOne (integer numeric) : integer {
return numeric + 1
}