ytakano/blisp

---

ytakano/blisp.json

{
  "createdAt": "2020-07-23T12:40:24Z",
  "defaultBranch": "master",
  "description": "A statically typed Lisp like scripting programming language for Rust.",
  "fullName": "ytakano/blisp",
  "homepage": "https://ytakano.github.io/blisp/",
  "language": "Rust",
  "name": "blisp",
  "pushedAt": "2025-02-17T09:34:10Z",
  "stargazersCount": 230,
  "topics": [
    "no-std",
    "programming-language",
    "rust"
  ],
  "updatedAt": "2025-10-19T01:36:04Z",
  "url": "https://github.com/ytakano/blisp"
}

BLisp

BLisp is a statically typed Lisp like programming language which adopts effect system for no_std environments. BLisp supports higher order RPC like higher order functions of functional programming languages.

This repository provides only a library crate. Please see blisp-repl to use BLisp, and baremetalisp which is a toy OS.

Homepage is here.

Features

• Algebraic data type
• Generics
• Hindley–Milner based type inference
• Effect system to separate side effects from pure functions
• Big integer
• Supporting no_std environments

How to Use

use blisp;

fn main() {
    let code = "(export factorial (n) (Pure (-> (Int) Int))
    (if (<= n 0)
        1
        (* n (factorial (- n 1)))))";
    let exprs = blisp::init(code, vec![]).unwrap();
    let ctx = blisp::typing(exprs).unwrap();

    let e = "(factorial 10)";
    blisp::eval(e, &ctx).unwrap();
}

If Rust compiler or linker says warning of fmod, please add fmod manually as follows.

#[no_mangle]
extern "C" fn fmod(x: f64, y: f64) -> f64 {
    libm::fmod(x, y)
}

Cargo.toml

[dependencies.blisp]
version = "0.4"

Examples

"Hello, World!" ; "Hello, World!"
(+ 0x10 0x20)   ; 48
(+ 0b111 0b101) ; 12
(+ 0o777 0o444) ; 803
(car '(1 2 3))  ; (Some 1)
(cdr '(1 2 3))  ; '(2 3)
(map (lambda (x) (* x 2)) '(8 9 10)) ; '(16 18 20)
(fold + 0 '(1 2 3 4 5 6 7 8 9))      ; 45
(reverse '(1 2 3 4 5 6 7 8 9))       ; '(9 8 7 6 5 4 3 2 1)
(filter (lambda (x) (= (% x 2) 0)) '(1 2 3 4 5 6 7 8 9)) ; '(2 4 6 8)