Defining Functions

Functions

One way to organize code and to make it more readable and reusable is to factor-out useful pieces into reusable functions. In mathematics, function is a mapping from defined source set to a corresponding defined destination set. The implementation remains an abstraction to keep the code clean. Here we'll cover ways of creating functions.

In languages such as Julia, a function is an object that maps a tuple of argument values to a return value. Julia functions are not pure mathematical functions, because they can alter and be affected by the global state of the program.

Let's look into Fibonacci program implemented as a function:

dart

python

julia

package main

import "fmt"

func fibonacci(n int) []int {
    var a, b = 0, 1
    var fibonacci_numbers = []int{}

    for len(fibonacci_numbers) < n {
        a, b = b, a+b
        fibonacci_numbers = append(fibonacci_numbers, a)
    }

    return fibonacci_numbers
}

func main() {
    fib_numbers := fibonacci(8)
    fmt.Println(fib_numbers)
}

Note: In the above code, iterative approach has been used to write the Fibonacci program. Try to use the recursive approach in your stack of ML-in-production languages

If you're familiar with strongly-typed languages (Dart, Go, Julia), you'll immediately notice that there is no type information associated with the function inputs or outputs for languages like JS and Python. Python functions can return any Python object, simple or compound, which means constructs that may be difficult in other languages are straightforward in Python, (and JS). We therefore use TypeScript, (for JS) and MyPy (for Python) to enforce type hinting.

Default Argument Values

Often when defining a function, there are certain values that we want the function to use most of the time, but we'd also like to give the user some flexibility. In this case, we can use default values for arguments.

Note: Go does not support default arguments

dart

python

julia

function printValues(x = 1, y = 2) {
    console.log(x, y)
}

// This kind of default parameter overidding
// only overides from the first
printValues(4, 9)

// This is more flexible
function printValuesToo({x = 1, y = 2} = {}) {
    console.log(x, y)
}

// You can specify a particular value to overide
printValuesToo({ y: 6 })

Flexible Arguments

Sometimes you might wish to write a function in which you don't initially know how many arguments the user will pass. In this case, you can use the special form to catch all arguments that are passed.

Dart has no real support for this. Generally, a function accepting more arguments than they are formally declared to accept, are called variadic functions

Here is an example:

python

julia

package main
import "fmt"

func sum(nums ...int) {
    fmt.Print(nums, " ")
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}
func main() {

    sum(1, 2)
    sum(1, 2, 3)

    nums := []int{1, 2, 3, 4}
    sum(nums...)
}

Note: Print variations

python

package main

import "fmt"

func main() {
    var a, b = 10, 4.5
    // fmt.Print and fmt.Println print the raw string
    // Println inserts spaces between arguments
    // Print only inserts spaces between arguments
    // when either argument is not a string.
    fmt.Print("The numbers are", a, "and", b, "\n") // Does not have new line by default
    // Res ==> The numbers are10and4.5
    fmt.Println("The numbers are", a, "and", b) // Has new line by default
    // Res ==> The numbers are 10 and 4.5
    var res string = fmt.Sprintf("The numbers are %d and %.3f\n", a, b)
    fmt.Print(res)
    // Res ==> The numbers are 10 and 4.500
    fmt.Printf("The numbers are %d and %f", a, b)
    // Res ==> The numbers are 10 and 4.500000
    // Note: using %v prints 4.5 instead of 6-floating precision 
    // %v is generic for all data types during printing
    // %T prints data type instead of the data itself
}

Anonymous Functions

In computer programming, an anonymous function (function literal, lambda abstraction, lambda function, lambda expression or block) is a function definition that is not bound to an identifier. Anonymous functions are often arguments being passed to higher-order functions or used for constructing the result of a higher-order function that needs to return a function.1 If the function is only used once, or a limited number of times, an anonymous function may be syntactically lighter than using a named function

An anonymous function defined into another function F can use elements that are not defined in its scope but in the scope of F. Anonymous functions can keep references to its surrounding state. They are known as function closures.

dart

python

julia

package main

import "fmt"

func main() {
    func() {
        fmt.Println("Anonymous function called")
    }()

    // closure call
    pos, neg := adder(), adder()
    for i := 0; i < 10; i++ {
        fmt.Println(
            pos(i),
            neg(-2*i),
        )
    }
}

func adder() func(int) int {
    sum := 0
    // Function closure
    return func(x int) int {
        sum += x
        return sum
    }
}

Defer Functions in Go

A defer statement defers the execution of a function until the surrounding function returns. The deferred call's arguments are evaluated immediately, but the function call is not executed until the surrounding function returns.

package main

import "fmt"

func main() {
    defer fmt.Println("world")

    fmt.Println("hello")
}

            [Golang]$ go run test.go
hello
world
[Golang]$
          

Deferred function calls are pushed onto a stack. When a function returns, its deferred calls are executed in last-in-first-out order.

package main

import "fmt"

func another() {
    for i := 0; i < 10; i++ {
        defer fmt.Println("Defer:", i)
    }
}
func main() {
    defer another()
    fmt.Println("counting")

    for i := 0; i < 10; i++ {
        defer fmt.Println(i)
    }

    fmt.Println("done")
}

            [Golang]$ go run test.go
counting
done
9
8
7
6
5
4
3
2
1
0
Defer: 9
Defer: 8
Defer: 7
Defer: 6
Defer: 5
Defer: 4
Defer: 3
Defer: 2
Defer: 1
Defer: 0
[Golang]$
          

Defer only works within a certain thread as they are bound within a goroutine. Goroutines are defined here
Read more onDefer, Panic and Recover

Weird returns

Let's see how the two languages, Julia and Go have weird returns, if you may call it that way. In Go, you can initialize the variable name in the return part of a function and it will be returned. In Julia, the last executed operation/variable is the one returned to the caller, ensuring the type matches.

julia

package main

import "fmt"

func add(x, y int) int {
    z := x + y
    return z
}

func weirdAdd(x, y int) (z int) {
    z = x + y
    return
}

func main() {
    var a, b int = 5, 8
    fmt.Println(add(a, b))
    fmt.Println(weirdAdd(a, b))
}

Of course, these ways of returns are not recommended.