Tree @master (Download .tar.gz)
Version 0.7. Work-in-progress, subject to change.
Robin is an excessively principled and thoroughly specified functional programming language with eager evaluation, latent typing, and a homoiconic syntax, based on a radically simple core semantics in which the macro, rather than the function, is the fundamental abstraction.
For more information, see the extended description below.
The Robin reference interpreter is written in about 1300 lines of Haskell.
To use it, you'll need an implementation of Haskell installed (typically either
ghc or Hugs).
If you have shelf installed, you can just run
If not, you can clone this repository,
cd into the repo directory, and run
to build the reference interpreter. (If you don't have
ghc, no executable will
be built, but the
bin/robin script will use
You can then run it on one of the example Robin sources in
eg like so:
You should see
To continue learning to program in Robin you can follow The Robin Tutorial.
If you have a few minutes to spare, and you have Falderal installed, you can run the test suite (consisting of more than 400 unit tests) by running
The tests that use only Robin's core semantics (
--no-builtins flag) are quite
slow, so you may want to skip them. You can skip them by running
The test suite will also run some property tests (using QuickCheck). Notably, for every macro that is defined multiple times (which includes much of stdlib, where the core definitions are written in Robin but also implemented in Haskell as "builtins" in the reference interpreter), QuickCheck will attempt to falsify the assertion that the definitions define the same macro. These attempts are currently rather crude; there is lots of room for improvement for them in some future release.
For experienced programmers, Robin might be best described by listing the languages that have had the strongest influences on it:
Like Scheme, Robin is eagerly evaluated, latently typed, and homoiconic, as well as properly tail-recursive and lexically scoped (at least by default), and tries hard to be well-defined and system-agnostic, but (as you can read below) diverges significantly from Scheme in other ways.
Like Forth, Robin has a radically simple core semantics. There are 15 intrinsic operations; every symbol in the standard library is defined in terms of these intrinsics, while an implementation is free to provide its own (perhaps more efficient) implementation of any such symbol. (See also Pixley).
PicoLisp allows defining functions with unevaluated arguments.
Robin adopts this kind of function for the basis of what it calls a
and builds everything else on top of
macros. (There is a
in Robin, but it's defined as a
macro!) This is much like how the Kernel
programming language builds everything from fexprs; however, Robin was
developed oblivious of Kernel — it adapted the idea directly from PicoLisp.
Like Haskell, Robin is referentially transparent (often described as "purely functional") — mutation of values is forbidden. (Robin intentionally does not, however, adopt lazy evaluation or a static type system.)
Reactive programs in Robin are built by composing transducers which are driven by events and produce effects (which are modelled as further events), in a manner very similar to The Elm Architecture.
Arbitrary text can by embedded in a Robin program using a syntax very much like a "heredoc", except it is an S-expression.
Deserves at least a passing mention here, as one thing that Robin
discards from Scheme is its jargony terminology: no
For a full description of the Robin language, see the Robin specification document.
- appliances/ — test appliances for the literate test suite.
- bin/ — driver script, destination for executable when built.
- demo/ — contains HTML5 document demonstrating build to JS by Haste.
- doc/ — Tutorial, specification, rationale, etc.
- eg/ — example programs written in Robin
- src/ — Haskell source for reference interpreter.
- stdlib/ — normative definitions of standard library symbols.
- HISTORY.md — history of this distribution.
- TODO.md — plans.
git clone https://git.catseye.tc/Robin/
- Merge pull request #6 from cpressey/develop-0.7 Chris Pressey (commit: GitHub) 4 months ago
- Short note of explanation about the state of the QuickCheck tests. Chris Pressey 4 months ago
- Explain about picking the first semantically equivalent definition. Chris Pressey 4 months ago
- Update statements made in README. Chris Pressey 4 months ago
- Note that abort values now have a defined representation. Chris Pressey 4 months ago
- No need for Either in World results. Chris Pressey 4 months ago
- Unwind more in TopLevel. Chris Pressey 4 months ago
- Begin unwinding error messages in TopLevel. Chris Pressey 4 months ago
- Canonical representation of abort values. Chris Pressey 4 months ago
- Remove `error` from Language.Robin.CmdLine as well. Chris Pressey 4 months ago