Statements and control flow

Forms that compile (24)

Syntax	Description	Note
if / else	Branch on a condition
switch (n) { case 1: ... }	Branch on a value (statement)
n switch { 1 => 10, _ => 0 }	Branch on a value (expression)	Even when the cases cover every value, it can’t be omitted for int or an enum. Only union allows that.
n switch { var v when v > 0 => 10, _ => 0 }	Case with a condition	It can’t be written in the case of a switch statement.
n > 0 ? 10 : 20	Conditional operator
while (n < 3)	Loop while a condition holds
do { ... } while (n < 3);	Loop with the check after the body
for (int i = 0; i < 3; i++)	Loop a fixed number of times
for (int i = 0, j = 3; i < j; i++, j--)	Loop with multiple variables
foreach (int v in a)	Iterate over an array	Because the runtime has no enumerators.
foreach (var (a, b) in ps)	Deconstruct while iterating
for { for { } }	Nested loops
break	Exit a loop
continue	Continue to the next iteration
while (true) { ... break; }	Exit an infinite loop	A break in the body is needed to leave it.
if (...) { return; }	Return partway through
{ … }	Block
;	Empty statement
const int a = 1;	Local constant
int Twice(int x) { return x * 2; }	Local function	Outer variables can be read but not written back (Forms that don’t compile (21)).
static int Twice(int x) { … }	static local function
for (;;)	Omitting parts of a for
return;	Return without a value
class MyError : System.Exception { }	Declaring an exception type

Forms that don’t compile (21)

Syntax	Description	Error	Reason	Alternative
goto top;	Jump to a label	TUKI0001, TUKI0099	by design	Rewrite with a loop
goto case c; / goto default;	Jump to another switch case	TUKI0001	by design	Move the shared logic into a method and call it from both case blocks
case 0: if (c) { break; } …	Exiting from the middle of a case	TUKI0001	undecided	Invert the exit condition and write the rest under it
L: stmt	Put a label on a statement	TUKI0099	by design	There’s no goto, so rewrite without a label
throw new Exception();	Throw an exception	TUKI0001, TUKI0101	runtime	Represent failure with a return value or state
try { } catch { }	Catch an exception	TUKI0001	runtime	Check the condition beforehand
throw;	Rethrows a caught exception	TUKI0001	runtime	Represent failure with a return value or state
catch (…) when (…)	Catch an exception conditionally	TUKI0001	runtime	Same as above
try { } finally { }	Run cleanup whether or not an exception occurred	TUKI0001	runtime	Write the cleanup at the end of the block
using (r) { … }	Clean up when leaving a block	TUKI0001	not yet	Call the cleanup method yourself (with no finally, it doesn’t run when you leave early)
using var r = …;	Let the declared variable’s cleanup happen automatically	TUKI0001, TUKI0099	not yet	Same as above
yield return / yield break	Return values one at a time	TUKI0001	runtime	Pack them into an array and return it
IEnumerator<int> Nums()	Returns an iterator	TUKI0001	runtime	Same as above
p switch { (1, 2) => … }	Deconstruct by position in a case	TUKI0001	not yet	Write { Item1: 1, Item2: 2 }, or read the elements and compare them
void Bump() { n = n + 1; } (writes back to an outer variable)	Modifying an outer variable from a function inside a method	TUKI0001	undecided	Return it as a value and let the caller assign it (a function that only reads the value can be written)
ref int r = ref a;	Give a variable an alias	TUKI0001	undecided	Assign the value and use it
lock (o) { … }	Do mutual exclusion	TUKI0001	runtime	Unnecessary, since there is only one flow of execution
async Task Go() { await ...; }	Await asynchronously	TUKI0001, TUKI0101	runtime	Use a mechanism that calls back after a delay
async void Go()	Writes an async method with no return value	TUKI0001, TUKI0101	runtime	Same as above
n switch { 1 => 10, 2 => 20 }	Branch without a default case	TUKI0001	by design	Always include _ =>. It can only be omitted for a union
foreach (var (a, b) in ps) (a type with a hand-written Deconstruct)	Use your own hand-written deconstruction	TUKI0001	by design	Read the fields by name

Declaring and using are separate	Being supported for declaration doesn’t mean it can be used. Exception types are supported as declarations, and the error appears only the moment you write the line that throws

Branching and loops

Branch on a condition

using UnityEngine;
using Tsukimi;

public class ExpressionsIfElse : TsukimiBehaviour
{
    void Start()
    {
        int n = 1;
        if (n > 0) { n = 2; } else { n = 3; }
        Debug.Log(n);   // => 2
    }
}

Branch on a value (statement)

using UnityEngine;
using Tsukimi;

public class ExpressionsSwitchStatement : TsukimiBehaviour
{
    void Start()
    {
        int n = 1;
        switch (n)
        {
            case 1: n = 10; break;
            default: n = 0; break;
        }
        Debug.Log(n);   // => 10
    }
}

Branch on a value (expression)

A _ => case is required.

using UnityEngine;
using Tsukimi;

public class ExpressionsSwitchExpression : TsukimiBehaviour
{
    void Start()
    {
        int n = 1;
        int r = n switch { 1 => 10, _ => 0 };
        Debug.Log(r);   // => 10
    }
}

Case with a condition

Adding when selects that case only when the pattern matches and the condition is also true.

using UnityEngine;
using Tsukimi;

public class ExpressionsSwitchArmWhen : TsukimiBehaviour
{
    void Start()
    {
        int n = 1;
        int r = n switch { var v when v > 0 => 10, _ => 0 };
        Debug.Log(r);   // => 10
    }
}

Conditional operator

using UnityEngine;
using Tsukimi;

public class ExpressionsTernary : TsukimiBehaviour
{
    void Start()
    {
        int n = 1;
        int r = n > 0 ? 10 : 20;
        Debug.Log(r);   // => 10
    }
}

Loop while a condition holds

using UnityEngine;
using Tsukimi;

public class ExpressionsWhile : TsukimiBehaviour
{
    void Start()
    {
        int n = 0;
        while (n < 3) { n++; }
        Debug.Log(n);   // => 3
    }
}

Loop with the check after the body

using UnityEngine;
using Tsukimi;

public class ExpressionsDoWhile : TsukimiBehaviour
{
    void Start()
    {
        int n = 0;
        do { n++; } while (n < 3);
        Debug.Log(n);   // => 3
    }
}

Loop a fixed number of times

using UnityEngine;
using Tsukimi;

public class ExpressionsFor : TsukimiBehaviour
{
    void Start()
    {
        int total = 0;
        for (int i = 0; i < 3; i++) { total += i; }
        Debug.Log(total);   // => 3
    }
}

Loop with multiple variables

using UnityEngine;
using Tsukimi;

public class ExpressionsForMultiInit : TsukimiBehaviour
{
    void Start()
    {
        int count = 0;
        for (int i = 0, j = 3; i < j; i++, j--) { count++; }
        Debug.Log(count);   // => 2
    }
}

Iterate over an array

foreach can only iterate over arrays.

using UnityEngine;
using Tsukimi;

public class ExpressionsForeachArray : TsukimiBehaviour
{
    void Start()
    {
        int[] a = new int[] { 1, 2 };
        int total = 0;
        foreach (int v in a) { total += v; }
        Debug.Log(total);   // => 3
    }
}

Deconstruct while iterating

using UnityEngine;
using Tsukimi;

public class ExpressionsForeachDeconstruct : TsukimiBehaviour
{
    void Start()
    {
        (int, int)[] ps = { (1, 2) };
        foreach (var (a, b) in ps) { Debug.Log(a + b); }   // => 3
    }
}

Nested loops

using UnityEngine;
using Tsukimi;

public class ExpressionsNestedLoop : TsukimiBehaviour
{
    void Start()
    {
        int count = 0;
        for (int i = 0; i < 2; i++)
        {
            for (int j = 0; j < 2; j++) { count++; }
        }
        Debug.Log(count);   // => 4
    }
}

Exit a loop

using UnityEngine;
using Tsukimi;

public class ExpressionsBreak : TsukimiBehaviour
{
    void Start()
    {
        int count = 0;
        for (int i = 0; i < 5; i++)
        {
            if (i == 2) { break; }
            count++;
        }
        Debug.Log(count);   // => 2
    }
}

Continue to the next iteration

using UnityEngine;
using Tsukimi;

public class ExpressionsContinue : TsukimiBehaviour
{
    void Start()
    {
        int count = 0;
        for (int i = 0; i < 5; i++)
        {
            if (i == 2) { continue; }
            count++;
        }
        Debug.Log(count);   // => 4
    }
}

Exit an infinite loop

while (true) keeps looping without evaluating a condition.

using UnityEngine;
using Tsukimi;

public class ExpressionsWhileTrueBreak : TsukimiBehaviour
{
    void Start()
    {
        int n = 0;
        while (true)
        {
            n++;
            if (n > 2) { break; }
        }
        Debug.Log(n);   // => 3
    }
}

Return partway through

using UnityEngine;
using Tsukimi;

public class ExpressionsReturnEarly : TsukimiBehaviour
{
    private int Level() { return 1; }

    void Start()
    {
        Debug.Log(1);   // => 1
        if (Level() > 0) { return; }
        Debug.Log(2);
    }
}

Statement building blocks

Block

using UnityEngine;
using Tsukimi;

public class StBlock : TsukimiBehaviour
{
    void Start()
    {
        {
            int a = 1;
            Debug.Log(a);   // => 1
        }
    }
}

Empty statement

using UnityEngine;
using Tsukimi;

public class StEmpty : TsukimiBehaviour
{
    void Start()
    {
        ;
        Debug.Log(1);   // => 1
    }
}

Local constant

using UnityEngine;
using Tsukimi;

public class StLocalConst : TsukimiBehaviour
{
    void Start()
    {
        const int a = 1;
        Debug.Log(a);   // => 1
    }
}

Local function

A function can be declared inside a method.

using UnityEngine;
using Tsukimi;

public class StLocalFunc : TsukimiBehaviour
{
    void Start()
    {
        int Twice(int x) { return x * 2; }
        Debug.Log(Twice(2));   // => 4
    }
}

static local function

using UnityEngine;
using Tsukimi;

public class StLocalFuncStatic : TsukimiBehaviour
{
    void Start()
    {
        static int Twice(int x) { return x * 2; }
        Debug.Log(Twice(2));   // => 4
    }
}

Omitting parts of a for

using UnityEngine;
using Tsukimi;

public class StForOmitted : TsukimiBehaviour
{
    void Start()
    {
        int i = 0;
        for (;;) { i++; if (i > 2) break; }
        Debug.Log(i);   // => 3
    }
}

Return without a value

using UnityEngine;
using Tsukimi;

public class StReturnVoid : TsukimiBehaviour
{
    void Start()
    {
        Debug.Log(1);   // => 1
        return;
    }
}

Declaration only

Declaring an exception type

You can declare an exception type, but you can neither throw nor catch it.

using UnityEngine;
using Tsukimi;

public class MyError : System.Exception { }
public class ExCustom : TsukimiBehaviour
{
    void Start()
    {
        Debug.Log(1);   // => 1
    }
}