Go makes it easy to declare your own functions.

You do so using the func key word followed by the name you want the function to have.

So we'll name this function myFunction.

Then you include a pair of parenthesis

followed by a code block in curly braces that gets run when the function is called.

So on this function, myFunction, we'll just make a call to the print

line function and we'll pass up the string Running myFunction.

Once you've declared a function you can call it by typing the function name,

myFunction, followed by a pair of parentheses again.

So, save this and run it down here in the console.

The main function gets called when the program is run and then it makes a call

to myFunction, which then prints out the string Running myFunction.

You can see that down here on the output.

The rules for naming functions are the same as they are for variables.

A function name has to start with a letter.

A capital letter means the function is exported from the current package, whereas

lowercase means it's unexported, that is, not visible outside the current package.

And again, there's a convention that if a function name has multiple words,

then all words after the first should begin with a capital letter.

If we try to refer to function names from outside the package,

we're only allowed to refer to functions that have been exported, that is,

those whose names begin with a capital letter.

If we try to refer to a non-exported function name,

we'll get a compile error saying cannot refer to unexported name.

If you want your functions to accept parameters,

you can declare those within the parentheses when declaring the function.

A parameter is just like any other variable, you need to give it a name and

you need to declare a type for it.

If you need a function to accept multiple parameters,

you can separate those with commas.

If you have multiple parameters of the same type,

you can just list the type after the last parameter.

So up here we make calls to the functions we've declared and

pass arguments into each of those parameters.

Let's try running this real quick.

So here we call the square function which

multiplies the number by itself then prints the value out.

So 3 times 3 is 9.

Here we call the add function and we pass it arguments of 2 and 4,

which it adds together and prints the result out.

So 2 plus 4 is 6.

And here we call subtract.

We pass up the arguments 10 and 3, it subtracts 3 from 10,

gives us the result, 7.

And since we declare the types of all the parameters,

that allows Go to enforce the use of the correct arguments.

So for example, if we were to try to pass a string to the square function and

then try to run this, we'll get an error.

Cannot use type string as type int as an argument to the square function.

There's certain features for

method declarations that you may be used to in other languages, but

the Go omits in order to keep method call simple, clear, and fast.

Go doesn't allow default values for parameters,

it doesn't allow you to name parameters, and it doesn't allow method overloading.

That means declaring multiple methods with the same name but different parameters.

That means that when you call a method you're always going to

use the same number of arguments in the same place.

The goal is to make calling methods simple, clear, and fast.

And of course, as in most other programming languages,

functions can return values.

So let's suppose that we wanted to update all these functions to

return a value instead of simply printing a value out.

We'll set up our square function to return an int,

by specifying the int type here following the parentheses.

And then instead of taking the number times itself and

printing that, we're going to return that value using the return keyword.

You can set up a variable to hold the return value,

which is also known as naming the return value.

Sometimes that's useful as documentation.

So if we want to do that, we place parentheses here

after the parentheses that accept the parameters for the function.

And we provide a name for the return value.

So we'll call this one sum, and of course its type is going to be a float64,

since we're adding two float64 numbers together.

And then as before instead of printing the value out, we'll just return it.

If you've named a return value, then you can use what's called a bare return.

So let's name the return value for the subtract function to be difference,

and it's going to have a type of float64.

That sets up a variable that we can assign to and

then that value will be used as our return.

So we can say difference = a minus b.

And then, that allows us use to use a bare return here at the end of the function.

So we can just use the return key word all by itself.

And that will, since we've set difference up as a named return value

that's the value that will be returned.

So let's save this.

And up here in the main function now that we're returning values instead,

we'll need to print them out up here.

So we'll say format.printline.

We'll print the return value of square.

We'd better change that back to an acceptable argument type.

So we'll say square(3).

And then fmt.Println(add(2, 4)).

And fmt.Println(subtract(10, 3)).

Subtract 3 from 10.

Save that, run it, and there are our results.

The square of 3 and 3 is 9.

The result of the adding 2 and 4 is 6.

And the result of subtracting 3 from 10 is 7.

The values were returned from each of the function calls

up here in the main function and we printed each one of them.

If you were to add a statement after the return statement within a function,

that line of code would never be breached.

Go protects you from this sort of situation by giving you a compile error.

So let's suppose that we were to add a call to fmt.Println(

down here after the return statement within the square function.

Let's try running that, and you see we get a compile error.

Missing return at end of function.

So if a function is supposed to return a value,

you need to ensure that the last line of that function is a return statement.