A programming language with a little more Baa.

// `let` can change. `const` cannot: and the compiler checks.
let sheep = 12
const MAX_SHEEP = 100

sheep += 1

// Strings interpolate with braces, and take whole expressions.
baa "The flock holds {sheep} of a maximum {MAX_SHEEP}."

// Defaults, rest parameters, closures, first-class functions.
fn tally(label, ..counts) {
    return "{label}: {counts.sum()}"
}

fn make_counter(start) {
    let count = start
    return fn() {
        count += 1
        return count
    }
}

const next = make_counter(10)
baa tally("this week", 3, 4, 5), next(), next()

import flock
import ram

const HERD = [
    { name: "Dolly", farm: "Hill", weight: 46.5 },
    { name: "Shaun", farm: "Hill", weight: 52.0 },
    { name: "Timmy", farm: "Dale", weight: 21.0 },
]

// Methods where a method reads well.
baa HERD.map(fn(s) { return s.name }).sort().join(", ")

// Modules where it doesn't.
const by_farm = flock.group_by(HERD, fn(s) { return s.farm })

for farm, members in by_farm {
    const weights = members.map(fn(s) { return s.weight })
    baa "{farm}: {members.length()} sheep, mean {ram.round(ram.mean(weights), 1)}kg"
}

// Arrays and maps compare by value, not by identity.
baa [1, [2]] == [1, [2]], { a: 1 } == { a: 1 }

// `match` is an expression, and patterns compare structurally:
// so a pair of booleans is a perfectly good pattern.
fn fizzbuzz(n) {
    return match [n % 3 == 0, n % 5 == 0] {
        [true, true] => "FizzBuzz",
        [true, false] => "Fizz",
        [false, true] => "Buzz",
        _ => to_string(n),
    }
}

fn describe(flock) {
    return match flock.length() {
        0 => "empty",
        1 => "one lonely sheep",
        2 || 3 => "a small flock",
        n if n > 50 => "a very large flock ({n})",
        _ => "a flock",
    }
}

for n in 1..=15 {
    baa fizzbuzz(n)
}

// Throw any value you like: errors keep their type.
fn shear(sheep) {
    if sheep.shorn {
        throw { code: "ALREADY_SHORN", sheep: sheep.name }
    }
    return "snip"
}

try {
    shear({ name: "Dolly", shorn: true })
} catch problem {
    baa "{problem.code}: {problem.sheep}"
}

// Runtime failures are catchable too, and carry a stable code.
try {
    baa ["Dolly"][99]
} catch problem {
    baa problem.code, problem.line   // BAA304 18
} finally {
    baa "gate closed"
}

// A standard module, a rename, and individual names.
import wool
import meadow as clock
import { round, mean } from ram

// A local file. Paths are relative to the importing file.
import "./pen.baa"
import "./helpers/text.baa" as text

baa wool.title_case("the flock is thriving")
baa clock.format(0, "YYYY-MM-DD")
baa round(mean([1, 2, 3, 4]), 2)

let my_pen = []
pen.admit(my_pen, "Dolly")
baa pen.describe(my_pen)

// Modules are values, so you can pass one around.
fn report(module, subject) {
    return module.describe(subject)
}

baa report(pen, my_pen)