⁉️Try-Statements

Try-statement syntax

try <expr> with <expr if error != nil>

--OR--

let <successVar, failureVar> = try <expr> with <expr>

The try-statement will evaluate the expression in-between try and with. Said expression must have a type of (..., error).

• If error != nil: the expression to the right of with will be returned.

• If error == nil:

  • If you're using the first syntax: Control flow will continue as normal

  • If you're using the second syntax: expression between try and with will be destructured into successVar and failureVar

Working Example

Gauntlet

package main

import "fmt" as fmt
import "errors" as errors

fun divide(num1: Int, num2: Int): (Int, Error) {
  if num2 == 0 {
    return (0, errors.new("Cannot divide by 0"))
  }
  return (num1 / num2, null)
}

fun divideBy2(num: Int): (Int, Error) {
  return divide(num, 2)
}

fun divideBy0(num: Int): (Int, Error) {
  return divide(num, 0) 
}

fun getResults(num: Int): (Int, Error) {
  let dBy2Res, dBy2Err = try divideBy2(5) with (dBy2Res, dBy2Err)
  let dBy0Res, dBy0Err = try divideBy0(10) with (dBy0Res, dBy0Err)
  return (dBy2Res + dBy0Res, null)
}

fun main(): Unit {
  fmt.println("Let's see if there's an error:")
  let res, err = getResults(10)
  fmt.println(err != null)
}

Transpiled

package main

import fmt "fmt"
import errors "errors"

func divide(num1 int, num2 int) (int, error) {
	if num2 == 0 {

		return 0, errors.New("Cannot divide by 0")
	}

	return num1 / num2, nil

}

func divideBy2(num int) (int, error) {

	return divide(num, 2)

}

func divideBy0(num int) (int, error) {

	return divide(num, 0)

}

func getResults(num int) (int, error) {
	dBy2Res, dBy2Err := divideBy2(5)
	if dBy2Err != nil {
		return dBy2Res, dBy2Err
	}
	dBy0Res, dBy0Err := divideBy0(10)
	if dBy0Err != nil {
		return dBy0Res, dBy0Err
	}

	// Eliminates any 'unused variable' errors
	_, _, _, _ = dBy0Err, dBy0Res, dBy2Err, dBy2Res
	return dBy2Res + dBy0Res, nil

}

func main() {
	fmt.Println("Let's see if there's an error:")
	res, err := getResults(10)
	fmt.Println(err != nil)
	// Eliminates any 'unused variable' errors
	_, _ = err, res

}

Output

Let's see if there's an error:
true