Tag: functions

Clean Code Notes – Functions

January 5th, 2021
Notes from the book Clean Code.
- Functions should be small. They should max 20 lines long. An ideal function should be just 2-5 lines solving only one purpose.
- The if/while/loop blocks should be one line long, which means they should enclose another function call.
- A function should do only one thing. One level of abstraction per function. If a function does only those steps that decompose the name of the function, it is doing only one thing and it is at one level of abstraction.
- The Stepdown Rule – Every function should be followed by another function which is the next level of abstraction. One should be able to read the functions top-down like reading a narrative.
- The Switch Statement –
  - cannot be reduced in size.
  - violates the Single Responsibility Principle as there is more than one reason for it to change.
  - moreover, it can grow with the addition of new conditions.
  - A Solution is to bury the switch statement in the basement Abstract Factory and let no one see it. The factory will then use the switch statement to create appropriate instances of the derivatives of the object. [ Abstract Factory is a creational design pattern that lets you produce families of related objects without specifying their concrete classes. ]
- Use descriptive names. Don’t be shy of using long names.
- Be consistent in names, use similar phrases, nouns, and verbs.
- Try to limit arguments. Best is no argument, next best is one argument. Multiple arguments make reading functions difficult as well as testing them.
- Monadic functions ( functions with one argument) should always return something.
- Diads and Triads functions are difficult to read and grasp and should be avoided whenever possible.
- Multiple arguments can be clubbed into objects, which can reduce arguments.
- Have function names with verbs(intent) and keywords. eg assertEquals can be changed to assertExpectedEqualsActual, which can help remove the need to remember the ordering of arguments.
- Avoid output arguments, if the function changes the state of something then let it change the state of its owning object.
- Return exceptions instead of returning error codes.
  - With exceptions, one can separate the error path from the happy path
  - With error codes, there is usually a file maintaining that error codes, which can change any time, making the dependencies to change as well. With exceptions, we can avoid this.
- The code inside try-catch blocks should be moved to separate functions of their own.
- Dijkstra’s rule of structured programming – every function should have exactly one entry and one exit, ie no break/continue/goto, and a single return statement. With small functions, we can have multiple return statements and break/continue.
Learning Swift: Functions [Argument labels]

March 31st, 2017
From last three posts, we have been working on functions in swift. So far we learned
In this post, we will learn about function argument labels.

Recall this syntax we discussed in the first post on functions.
```
func functionName (paramName: paramType  ) -> returnType{
 
 //block of code
 return object
 
 }
```
Here we have not used argument labels. First, let’s add the argument labels to this syntax.
```
func functionName (argumentLabel paramName: paramType  ) -> returnType{
 
 //block of code
 return object
 
 }
```
What is this argument label? Why do we use it? How’s it different from the parameter names.

Let’s find out.

Remember this factorial function from last few posts?
```
func factorial (number: Int) -> Int{
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}
```
We will add an argument label “of” to the parameter name number.
```
func factorial (of number: Int) -> Int{
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}
```
Immediately we have an error here, where we are calling this function factorial.

The error says “Incorrect argument label in call(have number:”, expected “of:”

When we replace the number with of, the error vanishes.

This “of’ here is an argument label. The argument labels are like external parameter name. These are used when calling a function. The other parameter name “number” is the internal parameter name and is used inside the function.

Earlier when there was no “of” ie argument label, the parameter name became the default argument label and we used “number:” instead of “of:”.

So when we explicitly write an argument label we have to use that in the function call. Else we use the parameter name as argument label.

The use of argument label makes a function more expressive, sort of like a sentence. Like this factorial function call above, now, can be read as the factorial of 7.

With this we complete functions. If you have any questions leave them in the comment section below.
Learning Swift: Functions [Return Values]

March 21st, 2017
From last two posts, we have been working on functions in swift. In the first post we learned how to define and call the functions and in the second we focused on the parameters.

In this post, we will look into the values a function can return.

If you recall the last two posts, we have used an example of a factorial function. For this post also, we will be using the same factorial function as an example.
```
func factorial (number: Int) -> Int{
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}
```
Functions with One Return Value

When we take a closer look at the function, we see that this function returns factorial variable. What is this factorial variable?

This factorial variable stores the factorial of the number which we pass as the parameter. And this factorial is of the type integer.

Plus the main point to note here is that we have used Int as the return type in the function definition which you can see in the first line.

When we call this function for a factorial of 7, we get the output as 5040 which is an integer.

So this function has a return value. It returns just one value ie factorial.

But returning a value is not mandatory for a function. We will also have functions which are having no return values.

Functions with No Return Value

For the example of a function with no return value, we will be removing the return type of this factorial function.

Let’s delete this int from the first line. But as soon as we remove this int, we get an error which says, “Unexpected non-void return value in void function”

This actually means that we are returning a value in a function which has no return value. Void means that the function is not going to have a return value.

And when we delete this return statement the error vanishes.

Now factorial function is complete and we are calling this factorial function here in the print statement. The output is just the empty parenthesis and not 5040. why?

Well, coming back to the function, we see it does not return a value and also have no print statement to print the value of factorial.

What we can do is copy this print statement inside and replace the function call with the factorial variable. And call this function separately.

Now we can again see the output 5070.
```
//Example
//Factorial of a Number

func factorial (number : Int) {
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    print("Factorial is \(factorial)")

}

//functionName(paramName: paramValue)
factorial(number: 7)
```
Hmm, this was a function with no return value. And before this one, we saw the function with one return value.

Functions with Multiple Return Values

But what should we do if we want to return more than one value?

In swift, we can do that by using tuples as return values. And in these tuples, specify the multiple return types.

Not clear? I know. It will be through this example. We will first write a function to return the quotient and remainder of dividing number A by number B and then understand it.
```
//divide function with two return values quotient and remainder

func divide(numA: Int, numB: Int) -> (quotient: Int, remainder: Int){
    return (numA/numB, numA%numB)
}

let result = divide(numA: 9, numB: 2)

print("Quotient is \(result.quotient) and Remainder is \(result.remainder)")
```
We get the output as 4 and 1.

Any guess what’s going on here. We have a function divide with two input parameters: numA and numB. And the return values quotient and remainder which are enclosed in parenthesis to form a tuple.

Next, we return numA/numB to get the quotient and numA%numB to get the remainder.

We can directly print the result by calling the function in a print statement. But if want to access both the results separately, we store them in a constant and then call them by their names as we did in this print statement using the result.quotient and result.remainder.

Now we know how to make functions with no parameter, one parameter and also multiple parameters.

You can find the source code for this post here.

In the next post, we will move on to argument labels.
Learning Swift: Functions [Parameters]

March 14th, 2017
In the previous post on functions, we started with defining and calling functions.

Today we will go a bit deeper into function parameters or popularly called arguments.

Parameters are the inputs for the function.

If you recall from the previous video, this is the factorial function we studied. This factorial function has only one parameter i.e. number.
```
func factorial (number: Int) -> Int{
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}
```
Here the number is the input for the factorial function.

There are functions with one parameter and function with more than one parameters also.

To see an example of the function with zero parameters we will remove the parameter number from the function factorial. And add a constant number 7 inside the function.
```
func factorial () -> Int{
    let number = 7
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}

//functionName(paramName: paramValue)

print("Factorial is \(factorial(number: 7))")
```
But we see an error in the print function where we call our function. The error says, “Argument passed to call that takes no arguments”

This is happening because the function we defined has no parameters but the function we are calling has one parameter. To remove the error we remove number: 7 from the function call. And now there is no error and we get our output 5040.
```
func factorial () -> Int{
    let number = 7
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}

//functionName(paramName: paramValue)

print("Factorial is \(factorial())")
```
Now to study an example of a function with two parameters, we will define a function product, having two parameters x and y, both integers, and the function will return the product of x and y as an integer.
```
//product of two numbers

func product(x: Int, y: Int) -> Int {
    return x*y
}

print("Product of 6 and 14 is \(product(x: 6, y: 14))")
```
We can see that this function has two parameters in the definition x and y. And we call the function product with values of x as 6 and y as 14 and get the product 84.

Similarly, there can be functions with three or even four or five parameters.

With this, we complete the function parameters. In next post, we will focus on the return types.

You can find the source code for this post here.

If you have any questions or comments do leave them in the comment section below.
Learning Swift: Functions [Define and Call]

March 8th, 2017
Hello Friends,

From the past few posts, we have been learning swift one step at a time. In our previous post, we completed control flow. The code for this post is available here.

Starting today next few posts will be on functions. Function definition and function call will be covered in this post. Subsequent posts will focus on parameters, return types and argument labels respectively.

So, what are functions?

Functions are self-contained blocks of code that solve a specific purpose. For example, the factorial function that you see here is used to find the factorial of a given number.
```
func factorial (number: Int) -> Int{
    var factorial = 1
    var temp = number
    while(temp>1){
        factorial =  factorial * temp
        temp = temp - 1
    }
    return factorial
}
```
Or this print that we use so much. The print is also a function which is used to print the results on the console.

How do we define functions?

We do that using the following syntax
```
func functionName (paramName: paramType  ) -> returnType{
 
    //block of code
    return object
 
 }
```
It is clear that the function definition can be broken down into three main parts:
1. Function name through which we can call this function.
2. Parameters list which is actually list of inputs for this function
3. Return type which defines the type of result the function is going to return.
Let’s see this factorial function definition to better understand function definition

As we can see, the function name is defined as factorial. The parameter name is number. And the Parameter type is an integer. Return Type is also Integer. Then we have a code inside the curly brackets which calculates the factorial and stores it into a factorial variable and returns it. The data type of factorial variable is Integer, similar to the return type mentioned in the first line of the function.

How to call a function?

Now that we have defined factorial, how do we use it? How do we call it? How can we find the factorial of number 7 using this function?

The syntax for the function call is given below:
```
functionName(paramName: paramValue)
```
Like in this example we use print factorial of a number is factorial(number: 7). 7 is an integer and we have defined the parameter of the number as an integer.
```
print("Factorial is \(factorial(number: 7))")
```
In the next post, we will begin going deeper into functions.