Right now, each procedure is responsible for doing its own arity checking. This works in practice, but at worst it's easy to miss that when implementing one natively, and at best it results in boilerplate code across the board.

In addition, Scheme should provide the ability to reflect on arity at runtime, which is not possible in the current model.

We can solve both these problems by storing arity as a metadatum on a procedure primitive - not only can we build the check into the procedure call mechanism, but we can expose this information at runtime.

we need filter, map, and fold at the very least.

• https://www.gnu.org/software/mit-scheme/documentation/mit-scheme-ref/Parameters.html#Parameters
• https://www.gnu.org/software/mit-scheme/documentation/mit-scheme-ref/Dynamic-Binding.html#Dynamic-Binding

it's required by the language definition.

provide some utilities for writing procedures - destructuring/typechecking arguments, handling primitives, etc.

right now, errors are a hot mess. they should do a better job of reflecting what has actually gone wrong, and we should provide a runtime mechanism for recovering for errors.

See this page for more info.

see here

we can implement From<_> on Primitive and then a generic From<T> on SExp for each relevant type.

typeof methods on both Primitive and SExp, casting (?), etc.

right now, lambdas and defines are not statically scoped - if you use a global var inside a function, then mutate it before actually calling the function, the new value is used instead of the old one. example:

> (define x 3)
> (define (y z) (+ z x))
> (y 4)
7
> (set! x 5)
> (y 4)
9

right now it puts the first element of the iterator at the end of the list, rather than at the root.