# Functions in Julia

As promised in the last article of last week, we’ll be taking a proper look at functions in Julia. And what is that exclamation mark anyway? What metaphors are appropriate for Julian functions? We’ll answer all these questions shortly

### Definition

Functions are defined using the `function` keyword, as usual terminated with the keyword `end` as usual, making indentation superfluous

``````julia> function hi(name)
print(name)
end
hi (generic function with 1 method)
``````

You can also define short functions one line

``````julia> hey(name)= print(name)
hey (generic function with 1 method)
``````

And this is precisely where having LaTeX symbols in our lexicon completely distinguishes Julia. As we can name our functions so as to facilitate understanding while also keeping brevity. Done correctly, we can get our (Pluto) notebooks to read quite like math notes!

``````julia> Π(x::Array{Int64}) = prod(x)
Π (generic function with 1 method)

julia> factorial(n::Int) = Π(collect(1:n))
factorial (generic function with 1 methods)

julia> factorial(2)
2

julia> factorial(3)
6
``````

As is common, you can explicitly return a value, in which case the function stops there, or you can let the last expression be returned implicitly, as done in above functions:

``````julia> explicitReturn(x)=(factorial(x); return "Ha!"; print("I never show"))
explicitReturn (generic function with 1 method)

julia> explicitReturn(123)
"Ha!"
``````

Oh, and what about those functions with an exclamation mark ? Well, that’s just a naming convention that I humbly ask you to follow when defining your own functions. Its simple, whenever your function mutates i.e. changes it’s input arguments, you should end that function’s name with `!`.

### Typing

We can force a particular return type on a function just like we assert a DataType on a variable. If you want to read more about all that, you should read our full article on DataTypes here. But for now, just note that we use the `::`operator to assert the type of a variable, and that functions are first-class objects in Julia:

``````julia> typedReturn(x)::Int=(factorial(x); return "Ha!"; print("I never show"))
typedReturn (generic function with 1 method)
``````

Be careful, the above function, though defined, will never successfully execute, as it returns a string while expecting an integer!

Now, if you want a function to actually return nothing whatsoever, you’ll have to explicitly return `nothing`

``````julia> Nothing() = return nothing
Nothing

julia> Nothing() #Note the lack of output below
``````

But what if you like gifting, and would like to return a lot of stuff? Well, you’d bundle it up in a tuple:

``````julia> gifter(x,y,z)=return (x,y,z)
gifter (generic function with 1 method)

("machine", "learning", "geek")
``````

And then you unpack the gifts at once, and give it a fancy name ‘destructuring’

``````
julia> M,L,G=gifter("machine","learning","geek"); print("M:\$M |L:\$L |G:\$G ")
M:machine |L:learning |G:geek
``````

What if you instead want to pass on a variable number of arguments? You simply add an ellipsis to the last argument, and iterate over it to get each argument( in order):

``````julia> function reciever(gifts...)
return nothing
end
reciever (generic function with 1 method)

julia> reciever("Hi",1,"hello",(1,2,3))
Hi and 1 and hello and (1, 2, 3) and ``````

return nothing end reciever (generic function with 1 method) julia> reciever(“Hi”,1,”hello”,(1,2,3)) Hi and 1 and hello and (1, 2, 3) and

### Anonymous/Lambda functions

We can define functions without a name via two syntaxes. Either we can simply skip the name part in a normal definition:

``````julia> function(x)
x^2
end
#1 (generic function with 1 method)

julia> ans(10)
100
``````

Or you can use the `->` token:

``````julia> x->x^2
#2 (generic function with 1 method)

julia> ans(100)
10000
``````

Canonically, we’d use them in functions like `map`

``````julia> map(x->x^2,collect(1:10))
10-element Array{Int64,1}:
1
4
9
16
25
36
49
64
81
100
``````

And that’s a wrap folks. We’re almost done with this mini-series on Julia. Next up we’ll be looking at exception handling and databases.