Examples · 27 of 339
27-order
The standard library's traits: Ord, Show and Eq.
tin 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