Spade language preview

1. Blinky

an expression-based counter that toggles an LED

horizon-dark

entity blinky(clk: clock, rst: bool) -> bool {
    let duration = 100_000_000;
    reg(clk) count: uint<28> reset(rst: 0) = if count == duration {
        0
    } else {
        trunc(count + 1)
    };
    count > duration / 2
}

atom-one-dark

entity blinky(clk: clock, rst: bool) -> bool {
    let duration = 100_000_000;
    reg(clk) count: uint<28> reset(rst: 0) = if count == duration {
        0
    } else {
        trunc(count + 1)
    };
    count > duration / 2
}

github-dark

entity blinky(clk: clock, rst: bool) -> bool {
    let duration = 100_000_000;
    reg(clk) count: uint<28> reset(rst: 0) = if count == duration {
        0
    } else {
        trunc(count + 1)
    };
    count > duration / 2
}

dracula

entity blinky(clk: clock, rst: bool) -> bool {
    let duration = 100_000_000;
    reg(clk) count: uint<28> reset(rst: 0) = if count == duration {
        0
    } else {
        trunc(count + 1)
    };
    count > duration / 2
}

nord

entity blinky(clk: clock, rst: bool) -> bool {
    let duration = 100_000_000;
    reg(clk) count: uint<28> reset(rst: 0) = if count == duration {
        0
    } else {
        trunc(count + 1)
    };
    count > duration / 2
}

github

entity blinky(clk: clock, rst: bool) -> bool {
    let duration = 100_000_000;
    reg(clk) count: uint<28> reset(rst: 0) = if count == duration {
        0
    } else {
        trunc(count + 1)
    };
    count > duration / 2
}

2. Pipelined multiplier

a one-stage pipeline with an explicit reg boundary

horizon-dark

pipeline(1) mul(clk: clock, x: int<18>, y: int<18>) -> int<36> {
    let result = x * y;
  reg;
    result
}

atom-one-dark

pipeline(1) mul(clk: clock, x: int<18>, y: int<18>) -> int<36> {
    let result = x * y;
  reg;
    result
}

github-dark

pipeline(1) mul(clk: clock, x: int<18>, y: int<18>) -> int<36> {
    let result = x * y;
  reg;
    result
}

dracula

pipeline(1) mul(clk: clock, x: int<18>, y: int<18>) -> int<36> {
    let result = x * y;
  reg;
    result
}

nord

pipeline(1) mul(clk: clock, x: int<18>, y: int<18>) -> int<36> {
    let result = x * y;
  reg;
    result
}

github

pipeline(1) mul(clk: clock, x: int<18>, y: int<18>) -> int<36> {
    let result = x * y;
  reg;
    result
}

3. Enum with pattern matching

variants carrying payloads, destructured with match

horizon-dark

enum Color {
    Red,
    Green,
    Blue,
    Gray{brightness: uint<8>},
    Custom{r: uint<8>, g: uint<8>, b: uint<8>}
}

fn to_rgb(color: Color) -> (uint<8>, uint<8>, uint<8>) {
    match color {
        Color::Red => (255, 0, 0),
        Color::Green => (0, 255, 0),
        Color::Blue => (0, 0, 255),
        Color::Gray(br) => (br, br, br),
        Color::Custom(r, g, b) => (r, g, b)
    }
}

atom-one-dark

enum Color {
    Red,
    Green,
    Blue,
    Gray{brightness: uint<8>},
    Custom{r: uint<8>, g: uint<8>, b: uint<8>}
}

fn to_rgb(color: Color) -> (uint<8>, uint<8>, uint<8>) {
    match color {
        Color::Red => (255, 0, 0),
        Color::Green => (0, 255, 0),
        Color::Blue => (0, 0, 255),
        Color::Gray(br) => (br, br, br),
        Color::Custom(r, g, b) => (r, g, b)
    }
}

github-dark

enum Color {
    Red,
    Green,
    Blue,
    Gray{brightness: uint<8>},
    Custom{r: uint<8>, g: uint<8>, b: uint<8>}
}

fn to_rgb(color: Color) -> (uint<8>, uint<8>, uint<8>) {
    match color {
        Color::Red => (255, 0, 0),
        Color::Green => (0, 255, 0),
        Color::Blue => (0, 0, 255),
        Color::Gray(br) => (br, br, br),
        Color::Custom(r, g, b) => (r, g, b)
    }
}

dracula

enum Color {
    Red,
    Green,
    Blue,
    Gray{brightness: uint<8>},
    Custom{r: uint<8>, g: uint<8>, b: uint<8>}
}

fn to_rgb(color: Color) -> (uint<8>, uint<8>, uint<8>) {
    match color {
        Color::Red => (255, 0, 0),
        Color::Green => (0, 255, 0),
        Color::Blue => (0, 0, 255),
        Color::Gray(br) => (br, br, br),
        Color::Custom(r, g, b) => (r, g, b)
    }
}

nord

enum Color {
    Red,
    Green,
    Blue,
    Gray{brightness: uint<8>},
    Custom{r: uint<8>, g: uint<8>, b: uint<8>}
}

fn to_rgb(color: Color) -> (uint<8>, uint<8>, uint<8>) {
    match color {
        Color::Red => (255, 0, 0),
        Color::Green => (0, 255, 0),
        Color::Blue => (0, 0, 255),
        Color::Gray(br) => (br, br, br),
        Color::Custom(r, g, b) => (r, g, b)
    }
}

github

enum Color {
    Red,
    Green,
    Blue,
    Gray{brightness: uint<8>},
    Custom{r: uint<8>, g: uint<8>, b: uint<8>}
}

fn to_rgb(color: Color) -> (uint<8>, uint<8>, uint<8>) {
    match color {
        Color::Red => (255, 0, 0),
        Color::Green => (0, 255, 0),
        Color::Blue => (0, 0, 255),
        Color::Gray(br) => (br, br, br),
        Color::Custom(r, g, b) => (r, g, b)
    }
}