Pocketlang is a small (~3000 semicollons) and fast functional language written in C. It's syntactically similar to Ruby and it can be learned within 15 minutes. Including the compiler, bytecode VM and runtime, it's a standalone executable with zero external dependecies just as it's self descriptive name. The pocketlang VM can be embedded in another hosting program very easily.

The language is written using Wren Language and their wonderful book Crafting Interpreters as a reference.

What pocketlang looks like

# Python like import statement.
from lang import clock as now

# A recursive fibonacci function.
def fib(n)
  if n < 2 then return n end
  return fib(n-1) + fib(n-2)
end

# Prints all fibonacci from 0 to 10 exclusive.
for i in 0..10
  print(fib(i))
end

Try It Now

You can try pocketlang on your browser. It's a WebAssembly build of the VM compiled using emscripten. Note that in the webassembly version of the language, some features (input, relative import, etc.) have disabled, has limited memory allocations, and the IO calls might be slower.

On Your System

NOTE: Make sure you've compiled the pocketlang source code and you have the pocket binary in build/debug/.

Copy/paste or type in the following factorial code in any editor of your choice:

# A recursive factorial function
def fac(n)
  if n == 0 then return 1 end
  return n * fac(n - 1)
end

# Prints all factorials from 0 to 10 exclusive.
print('Factorial of 0 - 9')
for i in 0..10
  print(fac(i))
end

Save the file as factorial.pk and execute it from the pocketlang binary directory with: ./pocket <path-to-factorial.pk>.

This should print out the output of the factorial program in your STDOUT (terminal).

Documentation

The pocketlang documentation is hosted at https://thakeenathees.github.io/pocketlang/ which is built from the docs branch generated by a little python script at docs/generate.py. Note that the documentations are WIP and might not be up to date.

Performance

All the tests are ran on, Windows10 (64bit), ASUS N552VX, Intel Core i7-6700HQ 2.6GHz with 12GB SODIMM Ram. And the language versions are: pocketlang (pre-alpha), wren v0.3.0, python v3.7.4, ruby v2.7.2.

The source files used to run benchmarks could be found at test/benchmarks/ directory. They were ran using a small python script in the test directory.

Building From Source

See build documentation for using an optional build script (Makefile, batch script for MSVC, SCons found in the build/ directory). It can be build from source easily without any depencency, or additional requirenments except for a c99 compatible compiler. It can be compiled with the following command.

GCC

gcc -o pocket cli/*.c src/*.c -Isrc/include -lm -Wno-int-to-pointer-cast

MSVC

cl /Fepocket cli/*.c src/*.c /Isrc/include && rm *.obj

For other compiler/IDE

1. Create an empty project file / makefile.
2. Add all C files in the src directory.
3. Add all C files in the cli directory (not recursively).
4. Add src/include to include path.
5. Compile.

If you weren't able to compile it, please report by opening an issue.

References

• Bob Nystrom.(2021) craftinginterpreters [online] Available at: www.craftinginterpreters.com/ (Accessed January 2021)

• Leonard sch<63>tz.(2020) Dynamic Typing and NaN Boxing [online] Available at: https://leonardschuetz.ch/blog/nan-boxing/ (Accessed December 2020)

• Bob Nystrom.(2011) Pratt Parsers: Expression Parsing Made Easy [online] Avaliable at: http://journal.stuffwithstuff.com/2011/03/19/pratt-parsers-expression-parsing-made-easy/ (Accessed December 2020)

• Carol E. (Wolf of Pace University), P. Oser. The Shunting Yard Algorithm [online] Available at: http://mathcenter.oxford.emory.edu/site/cs171/shuntingYardAlgorithm/ (Accessed September 2020)