02-fundamentals.slide

# Fundamentals #1
Course Go
Tags: golang, go

## Outline

- Built-in types
- Variables
- Control flow
- Functions
- Custom types
- Pointers

## Keywords

[Mat Ryer: Things in Go I Never Use](https://youtu.be/5DVV36uqQ4E?si=hZDbgTxZiUAvAS3g)

```
break       case     chan      const         continue
default     defer    else      fallthrough   for
func        go       goto      if            import
interface   map      package   range         return
select      struct   switch    type          var
```

First lecture covered:

```

                                             import
                     package

```

This lecture covers most of them:

```
break       case               const         continue
default     defer    else      fallthrough   for
func                 goto      if
                                             return
struct               switch    type          var
```

## Built-in types

## Built-in types

- Similar to C
- No auto casts
- Type inference and default types
```
bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // alias for uint8

rune // alias for int32
     // represents a Unicode code point

float32 float64

complex64 complex128
```

## Default values

- Each type has it's default value
    - Booleans: **`false`**
    - Strings: **`""`**
    - Numeric types: **`0`**
    - Runes: **`''`** == **`0`** == **`U+0000`**
    - Complex: **`0+0i`**
    - Pointer types: **`nil`**
        - More on those later

## Variables

## Variables

- Declarations
    - Using **`var`**
    - Using **`:=`**
        - Infers the type of the variable
        - Cannot be used when declaring global variables (only function level)
- Assignments
    - Using **`=`**
    - The variable has to be previously declared

## Variables

.play assets/lecture-02/variables/variables.go

## Idiomatic declarations

- Use **`var`** when you want to leverage the default value
```
 // YES
var counter int

 // NO
counter := 0
```
- Use **`:=`** when initializating the variable with other than the default value
```
 // YES
counter := 100

 // NO
var counter = 100
```

## Constants

- Declared and initialized using **`const`**
- No changes are permitted beyond declaration
- Only supports runes, strings, bools, and numeric values 

.play assets/lecture-02/variables/constants.go

## Type conversions

- No auto casts

.play assets/lecture-02/variables/casting.go

## Shadowing

- Variables from outer blocks can be shadowed

.play assets/lecture-02/variables/shadowing.go

## Shadowing

- Does not work in the same block

.play assets/lecture-02/variables/shadowing-same-block.go

## Control Flow

## Conditions

- No parantheses around conditions
- Allows init statement
- Variables declared via init do not exist beyond the scope of the if block

.play assets/lecture-02/if/if.go

## Else statement

- Variables declared in the init statement are reachable in the (else-if)-else blocks

.play assets/lecture-02/if/if-else.go

## Switch statement

- Also allows init statement
- Like set of if-(else-if)-else statements
- Evaluated top-bottom, first successful case is executed
- No fallthrough by default

.play assets/lecture-02/switch/switch.go

## Switch statement fallthrough

- Fallthrough can be explicitly set
- Generally not recommended

.play assets/lecture-02/switch/fallthrough.go

## Switch statement expressions

- Allows non-constant and non-integer values

.play assets/lecture-02/switch/expressions.go

## Switch without condition

- Switch without condition is like `switch true`

.play assets/lecture-02/switch/empty.go

## Loops

- Only the `for` keyword exists (no `while`)

.play assets/lecture-02/for/for.go

## Loops

- `break` keyword
- `continue` keyword
- Same as in other languages

## Labels & goto statement

- It is here but just don't
- Pretty please...
- Your colleagues will hate you!

.play assets/lecture-02/goto/goto.go

[Edsger W. Dijkstra on goto](https://dl.acm.org/doi/10.1145/362929.362947)

## Labels with loops

- Can be used with `break` and `continue` in loops

.play assets/lecture-02/for/labels.go

## Functions

## Functions

- Defined using the `func` keyword
- Arguments are passed by value

.play assets/lecture-02/functions/functions.go

## Multiple return values

.play assets/lecture-02/functions/multiple-return-values.go

## Named return values

.play assets/lecture-02/functions/named-return-values.go

## Shortening type declarations

.play assets/lecture-02/functions/shortened-types.go

## Ignoring return values

- '`_`' idiom can be used to drop return values

.play assets/lecture-02/functions/ignore-values.go

## Lambda functions

- AKA function literals
- Can be invoked directly or assigned to a variable

.play assets/lecture-02/functions/literals.go

## Typical usages for lambda functions

- `go` blocks
- `defer` statement
- Callback functions
- Comparison functions for sorting

## Higher order functions

- Functions are like any other value
    - "first-class citizens"

.play assets/lecture-02/functions/higher-order.go

## Closures

- Lambda functions that refer to variables defined outside the scope of the function
- It "closes over" another function, hence the name
- Contains code pointer and environment pointer internally
- Useful for functions that need to store it's state "somewhere"

## Closures

.play assets/lecture-02/functions/closure.go

## The infamous init function

- Basically a function for side effects
    - Sets-up an initial state
- Gets called when a package is imported
- Allows multiple declarations even per file/package
    - They are processed as declared/alphabetically
- Avoid it whenever possible

.play assets/lecture-02/functions/init.go /START OMIT/,/END OMIT/

## defer statement

- `defer` is a keyword in the Go
- Used to "remember" commands that will be called before `return` or function exit
- Based on LIFO (stack) of remembered commands
    - The last defered call is called first
- Parameters are evaluated when `defer` is declared (i.e. in runtime)
    - Not when the specified code is called
- It is possible to change function return value(s) via `defer`
- Great for cleaning-up resources

## Basic usage of defer statement

- Function `on_finish()` is called before exit from `main()`

.play assets/lecture-02/defer/defer.go

## Function declaration in defer statement

- Usually, the function definition is part of `defer` statement
- This function is anonymous - lambda, and usually it is a closure as well

.play assets/lecture-02/defer/lambda.go

## defer in loop

- 5 `defer` statements
- LIFO behaviour

.play assets/lecture-02/defer/loop.go

## defer arguments evaluation

- Actual parameters are evaluated in runtime

.play assets/lecture-02/defer/arguments-evaluation.go /START OMIT/,/END OMIT/

## defer with multiple return statements

- `defer` is called even when more `return` statements are used

.play assets/lecture-02/defer/multiple-returns.go /START OMIT/,/END OMIT/

## Practical usage of defer

.play assets/lecture-02/defer/io-example.go /START OMIT/,/END OMIT/

## defer and return values

- It is possible to change function's return value(s) via `defer`
    - Works as function declared in defer is a closure
- Function return values needs to be named
- Sometimes used in applications to alter the `err` return value

## defer and return values

.play assets/lecture-02/defer/return-values.go /START OMIT/,/END OMIT/

## Custom types

## Custom types

- `type` keyword
- Go is very strict in typing (see examples)
- New types can be defined by the `type` keyword

```
type Email string
```

- This is, for example, how the `byte` and `rune` types are defined:

```
type byte = uint8
type rune = int32
```

[builtin.go](https://cs.opensource.google/go/go/+/master:src/builtin/builtin.go)

- All custom types can easily be printed
    - No need to define some kind of `toString()` function

## User-defined data types

.play assets/lecture-02/types/user-types.go

## User-defined data types (passing to function)

.play assets/lecture-02/types/user-types-as-params.go

## Structures

- AKA records
- Defined using `type` and `struct` keywords
- User-defined data type
    - Can also be anonymous
- Dot operator to access struct members
- Initialization using `{}`
    - Members are explicitly named or follow the structure order as declared
- Structs are comparable
    - Note that the structure must not contain uncomparable types (slices, maps, ...)

## Structs and dot operator

.play assets/lecture-02/structs/struct.go

## Initialization of struct members

- Similar to C language initialization
- Usage of {} parenthesis
- C-like initialization: order matters!

## Initialization of struct members

.play assets/lecture-02/structs/init.go

## Explicit struct members initialization

- Struct members are explicitly specified by name
- Greatly increases readability 
- Preferred approach

## Explicit struct members initialization

.play assets/lecture-02/structs/explicit-init.go

## Structures can be compared

- `==` and `!=` operators

.play assets/lecture-02/structs/comparison.go /^func main/,/^}/

## Calling functions with structs as arguments

.play assets/lecture-02/structs/argument.go /START OMIT/,/END OMIT/

## Struct composition

.play assets/lecture-02/structs/composition.go /START OMIT/,/END OMIT/

## Struct embedding

.play assets/lecture-02/structs/embedding.go /START OMIT/,/END OMIT/

## Anonymous structure

- Just declare new variable and specify its type to `struct` _something_

.play assets/lecture-02/structs/anonymous.go

## Enums

- No direct support
- Can be somewhat simulated with 
    - Custom types
    - And a set of predefined constants
- Go has a special **iota** for enumerating integer constants

[Go Spec: iota](https://go.dev/ref/spec#Iota)

## Enums

.play assets/lecture-02/enums/days.go /START OMIT/,/END OMIT/

## Enums

.play assets/lecture-02/enums/iota.go /START OMIT/,/END OMIT/

## Pointers

## Pointers

- Always points to an element of some type
    - I.e. `void` pointers are not supported
- Default pointer value is `nil`
- Address of an element can be retrieved using the `&` operator
- Access via pointer (dereference in some other languages) using the `*` operator
- Go does not support pointer arithmetic

## Basic usage of pointers

- Note the usage of `*p_i++`

.play assets/lecture-02/pointers/to-int.go

## Panic on nil dereference

.play assets/lecture-02/pointers/panic.go

## Pointer to structure

- Note the possibility of writing `p_u.id` instead of `(*p_u).id`

.play assets/lecture-02/pointers/to-struct.go /START OMIT/,/END OMIT/

## Pointer to structure member

.play assets/lecture-02/pointers/to-struct-member.go /START OMIT/,/END OMIT/

## Return pointer to local variable from C function

    #include <stdio.h>

    int* get_pointer(void) {
        int i = 42;
        return &i;
    }

    int main(void) {
        int *p = get_pointer();
        printf("%p\n", p);
        printf("%d\n", *p);
        return 0;
    }

## Return pointer to local variable from Go function

.play assets/lecture-02/pointers/return-reference.go

## Back to types

## Methods on types

- A _method_ is a function that has a defined receiver
    - In OOP: a method is a function on an instance of an object
- Concept of a _receiver_
- Method declaration:

```
func (receiver) methodName(parameters) returnTypes {
    // body
}
```

- Methods are called like this:

```
someType.methodName(parameters)
```

- Methods can modify the receiver
    - Call by value vs. call by reference

## User type with a single method

.play assets/lecture-02/methods/methods.go /START OMIT/,/END OMIT/

## Value receiver

.play assets/lecture-02/methods/value-receiver.go /START OMIT/,/END OMIT/

## Pointer receiver

.play assets/lecture-02/methods/pointer-receiver.go /START OMIT/,/END OMIT/

## Nil receiver

.play assets/lecture-02/methods/nil-receiver.go /START OMIT/,/END OMIT/

## More methods for the same type

.play assets/lecture-02/methods/multiple.go /START OMIT/,/END OMIT/

## The new keyword

- Initializes the zero value of a type and returns a pointer to it
- Generally somewhat avoided 

.play assets/lecture-02/new/new.go /START OMIT/,/END OMIT/