RustでLisp

enum Value {
    Bool(bool),
    Int(i32),
    Sym(Rc<str>),
    Nil,
    Ref(Rc<RefValue>)
}
enum RefValue {
    // ...
    Cons(RefCell<Value>, RefCell<Value>)
}

gosh> (time (fib 30))
;(time (fib 30))
; real   0.086
; user   0.090
; sys    0.000
832040

Chez Scheme Version 9.5.4
Copyright 1984-2020 Cisco Systems, Inc.

> (define (fib n) (if (= n 0) 0 (if (= n 1) 1 (+ (fib (- n 1)) (fib (- n 2))))))
> (time (fib 30))
(time (fib 30))
    no collections
    0.011206316s elapsed cpu time
    0.011336000s elapsed real time
    0 bytes allocated
832040

(import-from some-module x)
x ; some-module:x が参照される

(module m1
  ; importはここでも有効
  x ; some-module:x
  ; defineはパス指定をサポートしない。現在のモジュールを操作対象とする
  (define x 123)
  ; 名前の探索順は、現在のモジュール > import
  x ; :m1:x
)

(module m1
  (define foo ...))

; どこか別の場所
(import-from another-module foo)
(module m1
  ; 名前の探索順から、m1:fooが呼ばれる
  (foo))

(import-from another-module bar)
(module m1
  (define bar ...)
  ; しかし、ここではimportよりモジュール定義を優先してm1:barが呼ばれてほしい感じがする
  (bar)
)

(import-from another-module buz)
(module m1
  (define buz ...))
; ...しばらく後
(module m1
  ; これはどうなってほしいか
  (buz))

(module m1
  (define name 'm1))

m1 ;=> #<module:m1>
(module-members m1) ;=> (name)
(module-get-member m1 'name) ;=> m1
(module-set-member m1 'name 'm1???)

(module m1)
(define m1 123)

x ; :global:x
(module m1 ) ; module :m1
(m1:x) ; :m1:x

(module global ; module :global
  (module m1) ; module :global:m1
)

; foo.lisp

; トップレベルで定義された名前は、そのファイルに対応するモジュール(以下、トップレベルモジュール)のメンバになる
; :<123>:x
(define x 1)

; トップレベルで参照される単純名は、
; 1. トップレベルモジュール
; 2. import
; の順に探索される
x ; :<123>:x

; 絶対名はそのままの意味で解決すればよし
:foo:bar

; トップレベルで参照される相対名は、
; 先頭のモジュール名を以下の順で探索し、解決結果を起点に残りのパスを解決する。
; 1. ルート
; 1. import
std:list ; :std:list

; トップレベルで定義されたモジュールは、ルート直下のモジュールになる
(module m1 ; module :m1
  ; モジュール内で定義された名前は、そのモジュールのメンバになる
  (define x 2) ; :m1:x
  ; モジュール内で定義されたモジュールは、親モジュールのメンバになる
  (module m2
    ; モジュール内で参照される単純名は、
    ; 1. そのモジュール
    ; 2. import
    ; 3. 親モジュール
    ; 4. 親の親モジュール...
    ; 5. トップレベルモジュール
    ; の順に探索される
    x ; :m1:x

    ; モジュール内で参照される相対名は、先頭のモジュール名を以下の順で探索し、
    ; 解決結果を起点に残りのパスを解決する
    ; 1. そのモジュール
    ; 2. import
  )

  ; モジュールが絶対名で指定されていたらそれに従う
  (module :foo:bar)
)

; bar.lisp

; foo.lispのトップレベルとは別のモジュールが使われる
x ; not found

(define-pub N 100)

(define-pub M 99)

(import foo)
foo:N ; => 100
(import-from foo N)
N ; => 100

(import foo:bar)
foo:bar:M ; => 99

(begin
  (define (f x) ...)
  (defmacro (g x) (f x))
  (g 123))

enum TopAst {
  // ...
  Begin(Box<TopAst>, rest: Vec<Value>)
}

fn eval(...) {
  TopAst::Begin(e, rest) => {
    eval(e)?;
    let mut ret = Value::Nil;
    for next in rest {
      ret = eval(compile(next)?)?;
    }
    ret
}

enum Value {
  Cons(ValueRef, ValueRef),
}

struct ValueRef(&Arena, usize);
impl Drop for ValueRef {
  fn drop(self) {
    self.0.dec_ref(usize);
  }
}
impl Clone for ValueRef {
  fn clone(&self) -> ValueRef {
    self.0.inc_ref(self.1);
    ValueRef(self.0, self.1)
  }
}

struct Arena { values: Vec<(usize, Value)>, free: Vec<usize> };

(define f (eval '(lambda (x) (+ x 1))))

(define x 0)
(define g (eval-with-names (x) '(lambda () (set-global! x 42))))

(define h
  (let ((a 0))
     (eval-with-names (a) '(lambda () (set-local! a 42)))))

(define x 0)
(let ((a 1))
  (eval-with-names (x a) <expr>))
; =>
(let ((a 1))
  (internal:eval-impl
    ((x global:0) (a local:0:0))
    (get-local-env)
    <expr>))

(define x 0)
(let ((a 1) (b 2) .. (z 26))
  (eval <expr>))
; =>
(let ((a 1))
  (internal:eval-impl
    (internal:compile
     ((a local:0:0) (b local:0:1) .. (z local:0:25))
      <expr>)
    (get-local-env)))