A Concatenative Programming Language
Dochi is strongly influenced by Factor, Lua and Clojure.
Its design goal is to be lightweight and embeddable, similar to Lua.
Its default data structures are immutable, like Clojure.
It has been designed to be a largely static language.
Syntax
- Code is a list of words, like Forth/Factor
- They operate on a stack
- Bindings can be introduced at any point:
- Results in 4:
1 (a) a 2 + a +
- Results in 11:
2 3 4 (a b c) a a + b + c +
- Top level definitions use the ‘def’ keyword:
def square (a) a a *
- All word definitions are inside a
module name
- Use
use module-name to import another module, or use module-name.word
- Code quotations:
number? ["yes" write] ["no" write] if
- Lists:
{1 2 3 4} is syntax sugar for f 4 ; 3 ; 2 ; 1 ; where ; is cons
- Literal values:
- Keywords:
:hello
- Strings:
"hello"
- Character:
Ch{h}
- List:
L{1 2 3 4}
- Table:
T{:a 1 :b 2 :key value}
- Cons:
C{1 2}
Standard Library
core library
| word |
stack effect |
description |
| pp |
(value → ) |
pretty prints a value |
| write |
(string → ) |
writes a string to output |
| →string |
(value → string) |
converts a value to a string |
| if |
(condition true-quot false-quot → ) |
branch based on condition |
| + – * / |
(num num → num) |
operate on two numbers |
| < <= > >= = |
(value value → bool) |
compare two values |
table library
| << |
(table value keyword → ) |
associate keyword with value in table |
| >> |
(table keyword → value) |
return association of keyword in table |
| keys |
(table → list) |
table keys |
| values |
(table → list) |
table values |
| union |
(table table → union) |
union of two tables |
list library
| ; |
(value value → cons) |
cons two values |
| head |
(cons → value) |
head of cons |
| tail |
(cons → value) |
tail of cons |
| length |
(list → number) |
length of list |
| nth |
(list n → value) |
nth value of list |
Embedding in Haskell Code
Parse.dochiParseFile Turns a string of code into a [ChiModuleAST].Interpreter.emptyState an empty interpreter state.Interpreter.injectAST compiles and injects a list of ChiModuleAST into the interpreter state.Interpreter.injectLib injects a Haskell ChiModule into the interpreter state.Interpreter.runWord runs a word in the given interpreter state.Interpreter.runDochi runs a string of code in the given interpreter state.Util.runFiles takes a list of filenames, parses and compiles them, and runs ‘main.main’Util.runFilesWithState does the same with an initial state.