Sn Tin

Learn Tin · Part 1: The language · Chapter 11

Values, var and inout

Every value is a copy. How you change things anyway, and why it helps.

This chapter is short, but it's the one most different from Python, JavaScript or Java. If you remember one rule from it: in Tin, everything is a value.

Assigning makes a copy

In many languages, b = a for a list makes b a second name for the same list, so changing one changes "both". In Tin, b gets its own copy:

copy.tintin run copy.tin
fn main() {
  var a = [1, 2]
  let b = a          // b gets its own copy
  a.push(3)
  print(a)
  print(b)           // still [1, 2]
}
[1, 2, 3]
[1, 2]

Structs work the same way:

copy-struct.tintin run copy-struct.tin
type Robot = { name: string, battery: int }

fn main() {
  var first = Robot { name: "Bud", battery: 90 }
  var second = first           // a copy, not a second name for the same robot
  second.name = "Petal"
  second.battery = 40
  print(first)
  print(second)
}
Robot { name: "Bud", battery: 90 }
Robot { name: "Petal", battery: 40 }

Functions get copies too

A function receives a copy of each argument, so it can't change the caller's data behind its back. To change something, it returns the new value:

param.tintin run param.tin
// A parameter is a copy too. The function can't reach the caller's data.
fn drained(r: Robot): Robot {
  var out = r
  out.battery = 0
  out
}

type Robot = { name: string, battery: int }

fn main() {
  let bud = Robot { name: "Bud", battery: 90 }
  let empty = drained(bud)
  print(bud)        // unchanged
  print(empty)
}
Robot { name: "Bud", battery: 90 }
Robot { name: "Bud", battery: 0 }

Parameters are read-only, and the error says what to do instead:

param-let.tintin check param-let.tin
type Robot = { name: string, battery: int }

fn drain(r: Robot) {
  r.battery = 0
}

fn main() {
  drain(Robot { name: "Bud", battery: 90 })
}
error: cannot change this: 'r' is immutable
 --> param-let.tin:4:3
  |
4 |   r.battery = 0
  |   ^
  = note: parameters are read-only; take it as `r: inout Robot` to change the caller's variable

inout: when a function should change your variable

Sometimes changing a variable in place is exactly what you want. Mark the parameter inout. The caller writes &, so whoever reads the call can see that the variable may change there:

inout.tintin run inout.tin
type Robot = { name: string, battery: int }

// inout: this function may change the caller's variable.
fn charge(r: inout Robot, amount: int) {
  r.battery = min(100, r.battery + amount)
}

fn main() {
  var bud = Robot { name: "Bud", battery: 70 }
  charge(&bud, 20)         // & at the call: you can see that bud may change here
  print(bud)
  charge(&bud, 20)
  print(bud)
}
Robot { name: "Bud", battery: 90 }
Robot { name: "Bud", battery: 100 }

Only a var can be passed this way:

inout-let.tintin check inout-let.tin
fn addZero(xs: inout int[]) {
  xs.push(0)
}

fn main() {
  let fixed = [1, 2]
  addZero(&fixed)
}
error: cannot call 'addZero', which changes its argument: 'fixed' is immutable
 --> inout-let.tin:7:12
  |
7 |   addZero(&fixed)
  |            ^^^^^
  = note: declare it with `var fixed = ...` to change it
  = fix: declare fixed with var

A method whose first parameter is inout changes the value it's called on, like push does for arrays. On a method call you don't write &:

inout-method.tintin run inout-method.tin
type Counter = { count: int }

// A method whose first parameter is inout changes the value it is called on.
fn Counter.bump(c: inout Counter) {
  c.count += 1
}

fn main() {
  var clicks = Counter { count: 0 }
  clicks.bump()             // a method call on a var needs no &
  clicks.bump()
  print(clicks.count)
}
2

Your own for loops

inout is also how you make a type that for can walk. Give it a next method that changes the value and returns Some(item), then None when it is done. The loop works on its own copy, so your variable is left as it was:

iterator.tintin run iterator.tin
type Countdown = { n: int }

// next changes the countdown in place (inout) and gives the next number, or None when done
fn Countdown.next(c: inout Countdown): Option<int> {
  if c.n == 0 { return None }
  c.n -= 1
  Some(c.n + 1)
}

fn main() {
  let launch = Countdown { n: 3 }
  for t in launch {
    print("{t}...")
  }
  print("liftoff, and launch.n is still {launch.n}")
}
3...
2...
1...
liftoff, and launch.n is still 3

A collection type can instead have iter, returning something for already walks, such as an array or a Map: fn Tree.iter(t: Tree): int[].

Why it works this way

Today's cost: copies are made right away, so copying a big array in a hot loop costs time. Tin plans to copy only when something actually changes (copy-on-write). Programs will print the same things, only faster.

Tasks

●○○ Task 1: Predict the output

Before running it, write down what this prints: var original = ["a", "b"], var backup = original, original.push("c"), backup[0] = "z", then print both.

Solution
task-1.solution.tintin run task-1.solution.tin
fn main() {
  var original = ["a", "b"]
  var backup = original
  original.push("c")
  backup[0] = "z"
  print(original)   // ["a", "b", "c"]
  print(backup)     // ["z", "b"]
}
["a", "b", "c"]
["z", "b"]

●●○ Task 2: Swap the ends

Write swapEnds(xs: inout int[]) that swaps the first and the last item in place. It should do nothing for arrays shorter than two.

Solution
task-2.solution.tintin run task-2.solution.tin
fn swapEnds(xs: inout int[]) {
  if xs.len < 2 { return }
  let first = xs[0]
  xs[0] = xs[xs.len - 1]
  xs[xs.len - 1] = first
}

fn main() {
  var xs = [1, 2, 3, 4]
  swapEnds(&xs)
  print(xs)
}
[4, 2, 3, 1]

●●○ Task 3: A bank account

Give Account { owner: string, balance: int } two inout methods: deposit, and withdraw that returns false and changes nothing if the balance is too low.

Solution
task-3.solution.tintin run task-3.solution.tin
type Account = { owner: string, balance: int }

fn Account.deposit(a: inout Account, amount: int) {
  a.balance += amount
}

fn Account.withdraw(a: inout Account, amount: int): bool {
  if amount > a.balance { return false }
  a.balance -= amount
  true
}

fn main() {
  var acct = Account { owner: "ada", balance: 0 }
  acct.deposit(50)
  print(acct.withdraw(80))
  print(acct.withdraw(30))
  print(acct)
}
false
true
Account { owner: "ada", balance: 20 }

What's next

Next: Durations and frequencies. Units are types: 250ms + 3 does not compile.

In the reference: Arrays and structs are values · Variables