Redblue

try
    say 1 / 0
catch
    say "recovered"
end

test "division by zero is caught, not fatal"
    set caught to no
    try
        say 1 / 0
    catch
        set caught to yes
    end
    expect caught to be yes
end

set total to 0
for each n in [1, 2, 3]
    if n is 2 then
        skip
    end
    set total to total + n
end
say total

set empty to []
try
    set x to empty[0]
catch err
    say err
end

test "empty list index is an error"
    set empty to []
    try
        set x to empty[0]
    catch error
        set caught to yes
    end
    expect caught to be yes
end

Error: AnalyzerError: Unknown variable 'y'
  --> err.rb:2:1
2 | say y
  | ^

// variables.rb
set name to "Alice"
set age to 30
set fruits to ["apple", "banana", "orange"]

say name
say age
say fruits

// loops.rb
for each number from 1 to 5
    say number
end

set items to ["a", "b", "c"]
for each item in items
    say item
end

// files.rb
import files

files.write("output.txt", "Hello from Redblue!")
set content to files.read("output.txt")
say content

files.read(path)      // Read file as text
files.write(path, content)
files.append(path, content)
files.exists(path)   // Check if file exists
files.lines(path)    // Read as list of lines
files.delete(path)
files.copy(from, to)     // Copy a file
files.rename(from, to)   // Rename it, or move it

path.join("data", "records.rb")   // join with the platform's separator
path.parent("data/records.rb")    // "data", or nothing for a root
path.filename("data/records.rb")  // "records.rb"; a trailing separator is ignored
path.stem("data/records.rb")      // "records"
path.extension("data/records.rb") // "rb"
path.is_absolute("data")          // no
path.resolve("data")              // an absolute path with . and .. removed
path.normalize("data/./records.rb") // clean it, but keep it relative
path.list("data")                 // sorted entry names; [] for an empty directory

bytes.from_text(text)   // Text to a list of byte values (0 to 255)
bytes.text(bytes)       // A byte list back to text
bytes.write(path, bytes) // Write a byte list to a file

base64.encode(bytes)     // Standard base64 with canonical = padding
base64.decode(text)      // A byte list; padded or unpadded input
hex.encode(bytes)        // Lowercase hexadecimal text
hex.decode(text)         // A byte list
hash.sha256(text or bytes) // Lowercase SHA-256 digest
hash.sha512(text or bytes) // Lowercase SHA-512 digest
uuid.generate()          // A new random version-4 UUID, canonical lowercase
uuid.parse(text)         // Canonical lowercase; accepts hyphenated, simple, braced and urn:uuid: forms

collections.counter(items)                // {counts: [[key, count], ...], missing: 0}
collections.count(counter, key)           // the count, or the counter's missing value
collections.most_common(counter)          // [[key, count], ...], most common first
collections.defaultdict(factory)          // {entries: [], factory}
collections.get(dict, key)                // {value, dict}; a missing key is added
collections.put(dict, key, value)         // the dict with the key set
collections.deque()                       // an empty deque
collections.deque(items)                  // a deque of the items
collections.push_left(deque, value)       // add at the front
collections.push_right(deque, value)      // add at the back
collections.pop_left(deque)               // {value, deque}, or nothing at the front
collections.pop_right(deque)              // {value, deque}, or nothing at the back
length(deque)                             // the number of items the deque holds
collections.namedtuple(names, values)     // a record with those named fields
collections.field(record, name)           // the field; a missing field is an error

time.now()             // Get current timestamp
time.sleep(seconds) // Sleep for N seconds
time.format(timestamp_or_date, "format")
time.parse("YYYY-MM-DDTHH:MM:SS+HH:MM")         // ISO-8601 text to a date
time.parse("29/02/2024", "%d/%m/%Y")            // text in a chosen layout
time.unix("YYYY-MM-DD HH:MM:SS")
time.from_unix(seconds)                        // Seconds to a date, read as UTC
time.date(year, month, day)                    // A date at midnight
time.datetime(year, month, day, hour, minute, second)
time.duration(seconds)                         // A signed span of time
time.add_years(date, years)                    // Calendar arithmetic
time.add_months(date, months)                  // Clamps at month end
time.add_days(date, days)                      // Fixed 24-hour days
time.add_hours(date, hours)
time.add_minutes(date, minutes)
time.add_seconds(date, seconds)
// dates compare with < <= > >=, subtract to a duration, and add a duration

sys.argv()             // Arguments after the program path (empty outside `rb run`)
sys.parse(declaration) // Parse those arguments into a record of typed flags
sys.parse(declaration, arguments)

network.get(url)     // HTTP GET
network.post(url, body)

json.parse(text)     // Parse JSON to record
json.stringify(value)
json.parse_lines(text)      // one JSON value per line -> list
json.stringify_lines(list)  // a list -> one JSON value per line
csv.parse(text)     // Parse CSV to list of lists
csv.stringify(rows) // Write rows, quoting commas, quotes, newlines and space
toml.parse(text)    // the documented TOML subset -> record

zip.write(path, files)  // files is a record of names to text or byte lists
zip.read(path)          // the same record, text when the bytes are UTF-8
tar.write(path, files)
tar.read(path)

PI, E                          // Constants, not module members: no math.PI
math.abs(x), math.floor(x), math.ceil(x)
math.round(x), math.sqrt(x), math.pow(x, y)
math.sin(x), math.cos(x), math.tan(x)
math.log(x), math.exp(x)
// every one of them is also spelled flat: abs(x), sqrt(x), ...
// math.random is not implemented, and there is no math.random

text.uppercase("text"), text.lowercase("text"), text.trim("text")
text.split("text", by), text.join(list, by)
text.contains("text", sub)
text.starts_with("text", prefix), text.ends_with("text", suffix)
text.replace("text", from, to)
text.length("text")      // characters, not bytes: text.length("héllo") is 5
text.wrap("text", width) // a list of lines no longer than width; whitespace runs become one space
text.diff(old, new)      // a standard unified diff; empty when the texts are equal
text.dedent("text")      // remove the common leading whitespace
text.template("Hi <<name>>!", {name: "Ada"})  // "Hi Ada!"; <<<< writes a literal <<
text.pad("x", 3, "-")    // "x--"
text.align("x", 5, "right")  // "    x"; left, right or center
// uppercase, lowercase, trim, split, join, contains, starts_with, ends_with,
// replace and length are also spelled flat.

say "Hello"                      // print with a newline
print "Hello"                    // print without one
console.log("Hello")             // `say` under its module spelling
console.error("Could not read")  // diagnostics go to stderr
console.clear()                  // clear the screen
set name to input("Your name? ")  // read one line from the terminal

logging.set_level("info")          // debug, info, warn, error or off; default off
logging.level()                    // the current threshold
logging.set_timestamps(no)         // deterministic records without a timestamp
logging.set_destination("app.log") // a file path, or "stderr" / "stdout"
logging.debug("looking up a row")
logging.info("read 12 rows")
logging.warn("the cache is cold")
logging.error("the file does not exist")
logging.reset()                    // threshold off, stderr, timestamps on

list.map(xs, to (x) give back x * 2)  // every member, through a function
list.length([1, 2, 3])                 // 3
length(xs), push(xs, x)                // flat list builtins

regex.match(text, pattern)             // a match record, or nothing
regex.is_match(text, pattern)          // yes/no, searching anywhere
regex.capture(text, pattern, group)    // a captured text, or nothing
regex.replace(text, pattern, "user-$1")// every match, with capture references
regex.split(text, pattern)             // the text between matches
// text.split keeps its literal separator; regex.split is the pattern form.

matrix.from_lists([[1, 2], [3, 4]])  // a 2x2 matrix; rows must be rectangular
matrix.zeros(2, 3)                    // every element is 0
matrix.ones(2, 3)                     // every element is 1
matrix.identity(2)                    // a 2x2 identity
matrix.shape(a)                       // [rows, columns]
matrix.to_lists(a)                    // the rows as nested lists
matrix.add(a, b)                      // elementwise; equal shapes required
matrix.subtract(a, b)                 // elementwise; equal shapes required
matrix.multiply(a, b)                 // elementwise; equal shapes required
matrix.divide(a, b)                   // elementwise; a zero divisor is refused
matrix.scale(a, 0.5)                  // every element times 0.5
matrix.matmul(a, b)                   // matrix product; inner dimensions must match
matrix.transpose(a)                   // rows and columns exchanged
matrix.sum(a)                         // the sum; an empty matrix sums to 0
matrix.mean(a)                        // the mean; an empty matrix is refused
matrix.min(a)                         // the smallest element
matrix.max(a)                         // the largest element
matrix.at(a, 1, 0)                    // one element
matrix.row(a, 0)                      // one row as a list
matrix.column(a, 0)                   // one column as a list

redblue/
├── src/
│   ├── lib.rs           # Main library
│   ├── main.rs          # CLI entry
│   ├── lexer.rs         # Tokenizer
│   ├── parser.rs        # AST builder
│   ├── analyzer.rs      # Semantic analysis
│   ├── vm.rs            # Tree-walking interpreter
│   ├── bytecode/        # Bytecode format, compiler, disassembler, VM
│   ├── stdlib.rs        # Standard library
│   ├── formatter.rs     # Code formatter
│   ├── linter.rs        # Code linter
│   ├── lsp.rs           # Language server
│   ├── repl/            # REPL
│   └── testing/         # Test harness
├── tests/               # Rust + Redblue test suites
├── corpus/              # Differential-test programs
├── examples/            # Example programs
├── modules/             # Importable modules
└── tooling/vscode/      # Editor extension (highlighting)