Every type, in one list

Summary#

Types explains the types with a wrinkle. This page is the other half: the complete list, so that "does the language have a type for this?" is a question you can answer by looking rather than by guessing.

It is worth having because guessing goes wrong in a specific way — you invent a name for something that already exists. There is no Command type for a callable; it is Action. There is no Set<T>; it is HashSet<T>. Every name below is one the compiler matches, and the list is checked against the compiler itself, so it cannot quietly fall behind.

Anything not on this page is a type you declare — an entity, an enum, a class, or a component's own type parameter.

Description#

Scalars and value kinds#

The storable types. These are what an entity member, a function local, or a component parameter may be.

A bare member of one of these is required unless the type has an honest zero — see Optional and required members, which is the rule that decides whether ? is needed.

Which collection types may I write?#

An entity's child rows are not one of these — they are a collection property on the parent, described in relations. Reach for List<T> for an in-memory list, never to hold children.

A jagged array is not a separate kind. T[] is a collection of T, so T[][] is a collection of those. The outer rank is a List, so a grid can be appended to (board.Add(row)) and a List<T[]> goes straight into one — a bare T[] value does not, for the reason every T[] → List<T> is refused: an array cannot promise the .Add the slot offers. So build the grid as a List<T[]> and assign it as it stands, without a .ToArray().

int[][] Grid(int w) {
  var rows = new List<int[]>();
  for (var y = 0; y < w; y = y + 1) {
    var row = new List<int>();
    for (var x = 0; x < w; x = x + 1) { row.Add(0); }
    rows.Add(row.ToArray());
  }
  int[][] board = rows;                     // the List goes straight in — no `.ToArray()` on the outer rank
  board[0][0] = 1;                          // write a cell
  return board;
}

int[][] Laid() { int[][] board = [[1, 2], [3, 4]]; return board; }   // …or laid out literally

new T[n] — n copies of the default#

new T[n] is an array of n copies of default(T), as in C#. For a number that is 0, for a bool false, for a char '\0', for a DateTime DateTime.MinValue, for a TimeSpan TimeSpan.Zero, and for an enum its zero member. For a string or a class it is null, so new string[3] is a string?[]. A slot you have not written reads as null, so read it with ?? "" or check it for null first. The same rule holds in a function and in the browser.

string Labels() {
  var names = new string[3];
  names[0] = "first";
  names[2] = "third";
  return string.Join(",", names.Select(n => n ?? "-"));   // "first,-,third"
}

⚠ int[,] does not exist. A rectangular array is a distinct type in C# and not one Osy# has; the compiler refuses it by name and tells you to write int[][], which indexes identically.

How do I type a function value?#

Two spellings, both exactly C#'s, and there are no others:

component PrimaryButton(string label, Action onPress) { … }

class MenuEntry {
  public string Label;
  public Action Run;          // the verb to run — an Action, not a "Command"
}

Func with no type argument is an error: a function that returns something must say what. For a callback that returns nothing, use Action.

Calling one. A callable is invoked exactly as in C# — run() on a local or parameter, entry.Run() on a class member, and Run() unqualified inside the class that declares it:

class MenuEntry {
  public string Label;
  public Action Run;
}

component Menu(MenuEntry[] entries, Action onDismiss) {
  action Choose(MenuEntry entry) {
    entry.Run();      // run the verb the caller put on this entry
    onDismiss();      // and the callback this component was given
  }
  …
}

The argument count and types are checked against the callable's signature, so Action<int> invoked with a string is a compile error rather than a surprise on the client.

A verb call evaluates to nothing. It is fire-and-forget: the call does not wait for the verb to finish and yields no value, so a Func<…, T> cannot be invoked — the compiler says so by name rather than handing you a value that never arrives. Use Action for a callback and a plain function when you want a result.

Component-parameter wrappers#

Writable on a component parameter, where they mean something the plain type cannot say:

component TypeDropdown(Binding<OrganizationType> value) { … }

Reading a value out of text#

int.Parse, long.Parse, decimal.Parse, double.Parse and bool.Parse read a value of their type out of a string, as C# does. Numbers are read in the current culture, as C#'s are: the viewer's, else app.DefaultCulture, else the invariant culture (1234.5) — so under sv-SE decimal.Parse("1 234,5") is 1234.5 and "1234.5" is an error. Pass CultureInfo.InvariantCulture to read text a machine wrote (decimal.Parse(s, CultureInfo.InvariantCulture)). The same text gives the same number on the server and in the browser (Culture formatting — ToString(format, culture)). bool.Parse takes true or false in any letter case. Text that is not a value of the type is an error, never a quiet 0 or false: catch it where a person typed the text, and let it fail where your own code produced it.

A double also holds IEEE 754's non-numbers, spelled as in C#: double.NaN, double.PositiveInfinity, double.NegativeInfinity (and double.Epsilon, the smallest positive value). A NaN is equal to nothing, itself included, so x == double.NaN is always false — ask with double.IsNaN(x), double.IsInfinity(x), double.IsPositiveInfinity(x), double.IsNegativeInfinity(x) or double.IsFinite(x). They answer the same on the server, in the browser and in a stored query, and a query sorts NaN before every number, as C# does.

Types you declare#

Everything else is yours: an entity (persisted), an enum, a plain class (in-memory), and a component's own type parameters. Those are named by their declaration and scoped by namespace and type visibility (public / internal).

Examples#

Scalars and a collection, together in one function, so the spellings on this page are shown compiling rather than only described. (Callables belong to a component or a class, so their example lives in Callables above.)

string Summarise(string title, List<decimal> amounts) {
  decimal total = 0;
  foreach (var a in amounts) {
    if (a > 0) total = total + a;
  }
  return title + ": " + total;
}
// Summarise("Q1", [10, -5, 20])   ->  "Q1: 30"

Reading values out of text — the typed amount is caught, because a person typed it; the rest come from systems that promise the format, so a bad value fails loudly.

decimal? TypedAmount(string typed) {
  decimal? amount = null;
  try { amount = decimal.Parse(typed); } catch { }
  return amount;
}

long IssuedSequence(string issued) { return long.Parse(issued); }
double SensorReading(string text) { return double.Parse(text); }
bool FeatureFlag(string text) { return bool.Parse(text); }

See also#

• Types — the types with a wrinkle worth reading about first
• Optional and required members — which bare members are required, and when ? is needed
• entity members — declaring these as entity members
• component — where Binding<T>, Query<T>, Content and Slot are used
• Classes — plain in-memory value shapes