Tin

Examples · 27 of 339

27-order

The standard library's traits: Ord, Show and Eq.

examples/27-order.tintin run examples/27-order.tin
// The standard library's traits: Ord, Show and Eq.
//
// - Ord: write `compare` and a type gets < > <= >=, sort, min and max.
// - Show: every type prints; write `show` to choose how.
// - Eq: every comparable type has ==; write `equals` to choose what equal means.

type Version = { major: int, minor: int, patch: int }

fn Version.compare(a: Version, b: Version): int {
  if a.major != b.major { return a.major - b.major }
  if a.minor != b.minor { return a.minor - b.minor }
  a.patch - b.patch
}

fn Version.show(v: Version): string => "v{v.major}.{v.minor}.{v.patch}"

fn parse(s: string): Option<Version> {
  let parts = s.split(".")
  if parts.len != 3 { return None }
  Some(Version { major: parseInt(parts[0])?, minor: parseInt(parts[1])?, patch: parseInt(parts[2])? })
}

/// A sensor id is equal to another whatever its case.
type SensorId = { raw: string }

fn SensorId.equals(a: SensorId, b: SensorId): bool => a.raw.lower() == b.raw.lower()

/// Any ordered type: the bound says so, and the call checks it.
fn newest<T: Ord>(xs: T[]): Option<T> {
  if xs.len == 0 { return None }
  var best = xs[0]
  for x in xs { best = max(best, x) }
  Some(best)
}

fn main() {
  var releases: Version[] = []
  for s in ["1.4.2", "0.9.12", "1.10.0", "1.4.10", "bad"] {
    match parse(s) {
      Some(v) => releases.push(v),
      None => print("skipped {s}"),
    }
  }
  print(sort(releases))
  print("newest: {newest(releases).unwrap()}")
  print(newest(["pear", "apple", "zucchini"]))
  print(releases[0] < releases[3])

  let seen = [SensorId { raw: "IMU-1" }, SensorId { raw: "cam-2" }]
  print(seen.contains(SensorId { raw: "imu-1" }))
  print(SensorId { raw: "CAM-2" } == seen[1])
}
skipped bad
[v0.9.12, v1.4.2, v1.4.10, v1.10.0]
newest: v1.10.0
Some("zucchini")
true
true
true