e7e3d5166b | ||
---|---|---|
lib | ||
.gitignore | ||
LICENSE | ||
Makefile | ||
README.md | ||
docstring.go | ||
env.go | ||
felise.1 | ||
filesystem.go | ||
globals.go | ||
go.mod | ||
go.sum | ||
helpers.go | ||
interpret.go | ||
keywords.go | ||
lexer.go | ||
main.go | ||
parser.go | ||
stack.go | ||
test.fe | ||
types.go | ||
walkthrough.html |
README.md
felise
felise is a programming language occupying a space between concatenative and procedural programming (with, like many modern languages, some influence from functional programming). It is a hobby language designed as a successor to nimf (an earlier programming language by the same author). The language is implemented as a basic AST walking interpreter (though a compiler, JIT, or bytecode/vm would also be possible) in golang. It is not dynamically typed and all variables need to be declared as a given type (even control structures like if
and while
are technically types as well). Type checks are generally handled at runtime, with a few such checks handled in the lex/parse phases of runtime (rather than as encountered in running code).
Deliberate effort has gone into bridging some gaps between the stack based concatenative style and a procedural/imperative style. The later is represented by a heavy focus on variable use, lexical scoping, nested procedures forming closures, etc.
This README has gotten a little messy with lots of random information. TODO: clean it up.
Example
A fibonocci procedure seems like a decent example. Below you will see variables, error handling, a procedure, a docstring, comments, conditionals, loops, program arguments, etc. Covers a lot of good bases.
A file, test.fe
(included in the repo):
proc fib
| Stack: INT
Read :
Push : INT
Notes: Calculates the nth fibonacci number where n is an INT on TOS at call time |
# svar! creates and sets a var in one call
svar! fib#
# var! creates a var with a zero value initialized
INT var! a
1 svar! b
INT var! s
proc continue-loop? fib# 0 > end
continue-loop? while
a b + set! s
b set! a
s set! b
fib# 1 - set! fib#
continue-loop?
end
a
end
# run it!
sys-args length 0 > if
try
# attempt to convert to INT
sys-args 1 <- INT cast
catch
"Requires an integer" throw
end
fib println
else
"No input" stderr file-write
end
Running time felise ./fibtest.fe 40
on my Linux system outputs:
102334155
real 0m0.015s
user 0m0.005s
sys 0m0.013s
Pretty snappy for this initial test as I am building things. Granted, it is iterative and not recursive (which would certainly slow down).
Building
Assuming you have the mainline go compiler and git installed (and are using a posix-ish shell on a non-windows system):
git clone https://tildegit.org/sloum/felise && cd felise && make
sudo make install # at your option
You should then be able to run felise
(or ./felise
if only make
was called) to load the repl.
Libraries
Libraries, written in felise, are baked into the executable at present. This makes it easier to work things out than depending on a file-system based approach. The available libraries are as follows:
std
(loaded by the repl automatically)math
paths
stack
strings
To load a library follow this pattern:
"strings" import
You could also do something like the following to load arbitrary code from another file:
"~/my-code/felise-code.fe" import
Features
- Types
BOOL
,FLOAT
,INT
,LIST
,STRING
,TYPE
- Blocks
- Blocks create their own scope as a child to the scope they were created in
- All block types end with
end
, which always closes out the current scope (including the main scope) - Block types:
- Loops
while
,dowhile
- Procedures
proc
,proc!
- User defined forward reading procedures (
proc!
) enable things like writing procedures that act on variables directly, like howvar!
andset!
do
- User defined forward reading procedures (
- Conditionals
if
,else
- Error handling
try
,catch
(often used withthrow
)
- Loops
- Lexical scoping with explicit scope jumping for variable creation/setting (
scoped-var!
&scoped-set!
) and closures - A solid base library of built-in procedures developed in golang directly, providing the language primitives and base features to build on without sacrificing speed
- A
list
type that can contain any other type, including lists themselves- felise lists are
1
indexed - Most list operations allow negative index references. -1 would be the last item in the list, -2 the 2nd to last, and so on...
- Setting indexes, getting indexes,
slice
, joining two lists (+
), joining a list into a string (*
),pop
,shift
, andappend
are all available (generally with variants that can update a variable in addition to stack versions)
- felise lists are
- Variables are typed at creation:
INT var! myvar
creates an int variable namedmyvar
and is set to the type's zero value (0
in this case) at creation - Helpful error messages with stack straces
- Repl with tab completions for built-ins, library procs, and imports
- Any arguments passed at the shell will be passed in as a list named
sys-args
- Variables can be created in parent scopes with
scoped-var!
or updated in parent scopes withscoped-set!
- There is a lot of "operator overloading" going on with
+
,-
,*
,/
to have them work on strings and lists in interesting ways. - Procedures have the ability to add a docstring
proc myproc | I am a docstring | "hello" println end
defines a procedure, anddocstring! myproc
would add the docstring for that proc to TOS (whence it could be printed). Built-ins also have docstrings available (learning the stack order for everything can be a pain without them). To see the available words/procedures the system knows usewords
, which will add a string containing them to TOS. You can then try todocstring!
them and find out what they do - The functional programming operations
each!
andfilter!
are available.each!
, by nature of operating on the stack, can also be used as reduce as well (0 [1 2 3] each! +
sums all of the numbers in the list starting at0
, resulting in6
on TOS) - Type comparisons are as easy as casting to TYPE and comparing. Assuming two items are on the stack:
TYPE cast swap TYPE cast =
- Procedures/built-ins that end their identifier with a
!
indicate that they will "forward read" a word. So the codeINT var! my-int
will placeINT
(aTYPE
) on the stack, thenvar!
will pop the type and create a variable in the current scope with that type,var!
will then "forward read" the token stream to getmy-int
and assign that SYMBOL to the newly createdINT
variable. Users can create their own forward reading procedures by usingproc!
instead ofproc
. This works sort of like a macro in some other languages: in the procedure body you can use the symbolprocarg
and when the procedure is run it will forward read to get a symbol or value and replace all instances ofprocarg
with that value before executing the procedure. This allows for some form of argument passing beyond using the stack and is also the only way to reference a variable symbol without referencing its value
Gotchas / Weird Things
- Unlike a traditional forth style system, felise encourages use of local variables. Its lexical scoping and garbage collection mean that the global scope does not get littered with random variables, and so it is very comfortable and easy to use local variables when defining procedures and not have to do the stack manipulation dance except where it makes sense to do so
- LIST type items have a starting index of 1
- When using
cast
to go fromFLOAT
toINT
, the number will be floored rather than truncated (as is common). Positive numbers will function like a trunc, but negative numbers will not (the FLOAT-1.57
would cast to the INT-2
) - Using divide on two strings will do a split and produce a list of
s1
split bys2
(TOS); this can be reversed by multiplying the list by a string. Similarly, subtracting anything from a LIST or STRING will attempt to remove the thing from the LIST or remove a stringified version of the thing from the STRING. This is just a sample of the "fun" overloading that is happening. Enjoy! - File I/O is done without file handles (from a user perspective) and consists only of append (
file-write
) and read all (file-read
). When combined withfile-remove
andfile-exists?
, most common file actions can be accomplished with this set of features (when was the last time you needed to seek in a file). It makes both writing and reading a bit more expensive, but simplicity if the tradeoff - You can close out the global scope with a terminal
end
(at your option) and anything after it in the file will be ignored by the interpreter, allowing for long comments/notes at the end of the file - While I write above that a non-windows system is required... it may build and work on windows. I'm not sure, as I do not use that OS and do not have a system to test it on. YMMV
License
Notice: This is not free/libre software as defined by the FSF or OSC. I do not ascribe to their vision of free software. I believe that capitalism is an inherent threat to freedom and is an injustice to everyone. As such I use the Floodgap Free Software License (Version 1). The license is included in the repo (see LICENSE
file), and is mentioned and linked in each source code file. The basic idea is that you as an individual can do anything you like with this software that does not involve, directly or indirectly, money changing hands. There are a few exceptions to this noted in the license, but in general, that is the idea. Free to use in any way you like, so long as you don't charge for it. You are, of course, welcome to license code produced for the felise interpreter/language in any way you choose. The license I have chosen only applies to my interpreter code.