Appendix D: Quick Reference Card

A concise reference for BioLang syntax, builtins, REPL commands, and CLI usage.

Language Syntax

Variables

let x = 42
let name = "BRCA1"
let seq = dna"ATGCGATCG"
let rna_seq = rna"AUGCGAUCG"
let protein = protein"MARS"

Reassignment (updates an existing binding):

x = 100

Types

Operators

Pipe Syntax

The pipe operator passes the left-hand value as the first argument to the right-hand function:

# These are equivalent:
x |> f(y)
f(x, y)

# Chaining multiple operations:
data
  |> filter(|r| r.quality > 30)
  |> map(|r| gc_content(r.sequence))
  |> mean()

Functions

Named functions:

let square = fn(x) {
  x * x
}

Closures (anonymous functions / lambdas):

|x| x * 2
|a, b| a + b
|r| r.quality >= 30

Records

let gene = {name: "TP53", chrom: "chr17", start: 7571720}
gene.name        # Access field: "TP53"
keys(gene)       # ["name", "chrom", "start"]
values(gene)     # ["TP53", "chr17", 7571720]

Lists

let nums = [1, 2, 3, 4, 5]
nums[0]          # First element: 1
len(nums)        # Length: 5
nums |> map(|x| x * 2)    # [2, 4, 6, 8, 10]
nums |> filter(|x| x > 3) # [4, 5]

Tables

let t = to_table(rows, ["name", "value", "score"])
t |> select("name", "score")
t |> where(|row| row.score > 0.5)
t |> mutate("log_score", |row| log2(row.score))
t |> summarize(|key, rows| {category: key, mean_score: mean(rows |> col("score"))})
t |> group_by("category")
t |> sort_by("score", "desc")

Control Flow

# If/else
if x > 0 then
  println("positive")
else
  println("non-positive")
end

# For loop
for item in items do
  println(item)
end

# While loop
while x > 0 do
  x = x - 1
end

Error Handling

try
  let data = read_fasta("missing.fa")
catch e
  println(f"Error: {e}")
end

Requires CLI: This example uses file I/O not available in the browser. Run with bl run.

Imports

import "utils.bl"
import "helpers.bl" as h
h.my_function()

Builtins by Category

Sequence Operations

File I/O

Streaming

Table Operations

Statistics

Math

Visualization

String Operations

Higher-Order Functions

API Access

Utility Functions

File System

LLM Integration

REPL Commands

Type these at the bl> prompt (they start with :):

CLI Commands

The bl command-line tool:

Common Usage Patterns

Run a script:

bl run analysis.bl

Run a one-liner:

bl -e 'gc_content(dna"ATGCGATCG") |> println()'

Start the REPL and load a file:

bl repl
bl> :load helpers.bl
bl> my_function("input.fasta")

Run with environment variables:

NCBI_API_KEY=your-key bl run fetch_genes.bl

Common Patterns

Read, Filter, Analyze

read_fastq("data/reads.fastq")
  |> filter(|r| r.quality >= 30)
  |> map(|r| gc_content(r.sequence))
  |> mean()

Requires CLI: This example uses file I/O not available in the browser. Run with bl run.

Stream Large Files

stream_fastq("huge.fastq")
  |> filter(|r| len(r.sequence) >= 100)
  |> each(|r| println(r.name))

Requires CLI: This example uses file I/O not available in the browser. Run with bl run.

Build a Summary Table

let reads = read_fastq("data/reads.fastq")
let rows = reads |> map(|r| {
  name: r.name,
  length: len(r.sequence),
  gc: gc_content(r.sequence),
  quality: r.quality
})
let t = to_table(rows, ["name", "length", "gc", "quality"])
t |> sort_by("gc", "desc") |> write_csv("summary.csv")

Requires CLI: This example uses file I/O not available in the browser. Run with bl run.

Fetch and Analyze from Database

let gene = ncbi_gene("TP53", "human")
let seq = ncbi_sequence(gene.id)
let motifs = find_motif(seq, "TATA")
println(f"Found {len(motifs)} TATA boxes in TP53")

Requires CLI: This example uses network APIs not available in the browser. Run with bl run.

Multi-Step Pipeline with Error Handling

try
  let variants = read_vcf("data/variants.vcf")
  let filtered = variants
    |> filter(|v| v.quality >= 30)
    |> filter(|v| v.alt != ".")
  println(f"Kept {len(filtered)} of {len(variants)} variants")
  write_csv(to_table(filtered, keys(filtered[0])), "filtered.csv")
catch e
  println(f"Pipeline failed: {e}")
end

Requires CLI: This example uses file I/O not available in the browser. Run with bl run.

Parallel Processing

let files = list_dir("fastq/") |> filter(|f| ends_with(f, ".fastq"))
let results = files |> par_map(|f| {
  let reads = read_fastq(f)
  {
    file: f,
    count: len(reads),
    mean_gc: reads |> map(|r| gc_content(r.sequence)) |> mean()
  }
})
to_table(results, ["file", "count", "mean_gc"]) |> write_csv("batch_results.csv")

Requires CLI: This example uses file I/O not available in the browser. Run with bl run.