Language tour

This chapter expands the first program into the source shapes you will read most often: explicit bindings, functions, branchy control flow, optionals, and a small result-style return type.

Make values readable

Use explicit types at useful boundaries and mark mutation where it happens.

package tour;

fn accumulate (limit: int) -> int {
  let mut total: int = 0;
  let mut i: int = 0;

  while i < limit {
    total = total + i;
    i = i + 1;
  }

  return total;
}

Use small functions for decisions

Return types make the boundary visible even when the body is simple.

fn classify (score: int) -> string {
  if score >= 90 { return "excellent"; }
  if score >= 70 { return "steady"; }
  if score >= 50 { return "watch"; }
  return "blocked";
}

Model absence with an optional

T? is the right shape when missing is normal and no extra error detail is needed.

fn env_label (name: string) -> string? {
  if name == "prod" { return Some("production"); }
  if name == "dev" { return Some("development"); }
  return None;
}

fn label_or_default (name: string) -> string {
  return env_label(name) ?? "unknown";
}

Check the module

Keep using the same quick feedback loop as the first chapter.

silk check src/tour.slk
silk test src/tour.slk

What changed

• let mut made mutation visible.
• Function signatures carried the important type information.
• string? represented absence without inventing an error path.
• ?? handled the optional fallback at the call site.