A small and fast programming language.

I wanted to exit pocket with a ^D in the terminal. Instead pocket printed out >>> in an endless loop:

$ pocket
PocketLang 0.1.0 (https://github.com/ThakeeNathees/pocketlang/)
Copyright(c) 2020 - 2021 ThakeeNathees.
Free and open source software under the terms of the MIT license.

>>> ^D
>>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>>^C
$ 

This is commit 2b4d3af0a24a3952334c54fcf409e9fd9d27eaf2

$ uname -omp
x86_64 unknown GNU/Linux

This is not really an issue but a notice that the repo is trending and stars are climbing up. Good job @ThakeeNathees and thanks for giving us an opportunity to be part of this journey.

Let's celebrate 😇 as it's now at 816 stars ⭐️

This patch introduces CLI argument parsing to pocketlang where basic options such as: "--help", "--version", etc are used to get some info about how to use the application on the command line.

An attempt to fix issue #99

The current copyright statement in the file headers doesn't address the pocketlang aurhtos. It should be updated like this.

Before

/*
 *  Copyright (c) 2020-2021 Thakee Nathees
 *  Distributed Under The MIT License
 */

After

/*
 *  Copyright (c) 2020-2021 Thakee Nathees
 *  Copyright (c) 2021 The pocketlang Authors
 *  Distributed Under The MIT License
 */

And thanks for being part of this :tada:

TODO: list addition

Currently adding 2 lists ([1, 2] + [3, 4]) cause a crash with a TODO message. which need to be implemented. (here)

How to implement

List* l1, *l2 are defined above the TODO statement in the source.

• Create a new list using newList(vm, size) function, where (initial reserved) size is the total length of l1 and l2. length of l1 = l1->elements.count
• iterate each lists and append to the new list.

for (uint32_t i = 0; i < l1->elements.count; i++) {
  listAppend(vm, list, l1->elements.data[i]);
}

• return the list as a var using VAR_OBJ(list) macro function.

Finally

Once you successfully implemented it, write some tests at tests/lang/

With a small factorial program written in pocketlang and executed on the terminal, this demonstrates how to execute a script on a loalhost using pocketlang binary.

Hey! It looks like you started implementing some JS for the benchmarks and stopped. There's a note in loop.js about V8's performance optimizations/benefits – I'm not sure if this deterred you from including/finishing JS or not, but I think it's still important to include them for context.

Pocketlang doesn't have to be the fastest in a graph in order for it to be considered :) It's a cool little language and I think it has more merit than speed.

I added the JS variants for all benchmarks and will include a sample of their results on my machine. Happy to PR the benchmark items if interested

Node v14.15.3
Python v3.9.5
Pocket (master : 6d434db) -> make release

benchmarks/fib
  node   0.090436s
  python 2.506929s
  pocket 1.380002s

benchmarks/list
  node   0.143674s
  python 2.351552s
  pocket 0.884381s

benchmarks/loop
  node   0.325279s
  python 1.946506s
  pocket 0.54898s

benchmarks/primes
  node   0.143707s
  python 2.6421330000000003s
  pocket 1.400831s

Again, I don't think this should be discouraging at all. It's amazing so far!

Similar to Ruby having an exit keyboard would be nice. I don't think we should bring over the lack of cleanup bang variant exit! though.

I'd be happy to implement this if some pointers (pun?) were given.

my lua version is 5.3.4

# python3 benchmarks.py                       
----------------------------------
 CHECKING FOR INTERPRETERS 
----------------------------------
Searching for pocketlang -- found
Searching for wren       -- not found (skipped)
Searching for python     -- found
Searching for ruby       -- not found (skipped)
Searching for lua        -- found
Searching for javascript -- not found (skipped)
----------------------------------
 factors 
----------------------------------
pocketlang : 4.000000s
python     : 5.265634s
lua        : 0.600000s
----------------------------------
 fib 
----------------------------------
pocketlang : 3.040000s
python     : 3.029289s
lua        : 0.950000s
----------------------------------
 list 
----------------------------------
pocketlang : 2.880000s
python     : 2.594415s
lua        : 0.790000s
----------------------------------
 loop 
----------------------------------
pocketlang : 1.230000s
python     : 2.204718s
lua        : 0.390000s
----------------------------------
 primes 
----------------------------------
pocketlang : 3.740000s
python     : 2.913168s
lua        : 0.550000s

Currently, our makefile depends on the find unix command which makes it harder for others to compile on windows

Here is what they have to do

To run make file on windows with mingw, you require make and find unix tools in your path. Which you can get from msys2 or cygwin. Run set PATH=<path-to-env/usr/bin/>;%PATH% && make, this will override the system find command with unix find for the current session, and run the make script.

But we want the makefile to be portable and independent of the system, Remove the find from the makefile.

Begin using it to mark functions that have a better version such as read_line() which has a better version: readLine() that uses a byte buffer.

Through out the code base, if we see functions that have a better version of itself, we should definitely mark it as deprecated with a meaningful deprecation message.

In effect, the GCC compiler will through a warning level message on the console at compile time reporting these deprecated functions.

Could you make a CudaText lexer for Pocketlang? It already has lexer for various languages whose Pocketlang syntax is based on (Python, Lua, Ruby,...). It has a well documented tool to create lexer. The problem is CudaText lexer is full of regular expression and I feared regular expression so much so I have to bother you here.

This is CudaText: https://github.com/Alexey-T/CudaText

Document for lexer creator tool: https://github.com/Alexey-T/CudaText/issues/4515#issuecomment-1298695532

compile can compile the source code into a closure at runtime time. Example:

message = "Metaprogramming"
value = 12345

code = "
  def test
    return $value
  end
  print('$message')
  return test()
"
func = compile(code)
print(func())

Output:

Metaprogramming
12345

eval can evaluate an expression and returns the result. Example:

message = eval("'Meta' + 'programming'")
value = eval("123450 / 10")
func = eval("
  fn
    print(message)
    return eval('value')
  end
")
eval("print")(eval("func()"))

Output:

Metaprogramming
12345

In many other language, ternary operator (:?) is the syntax for basic conditional expression. However, in some language (e.g. coffeescript), they use if expression as conditional expression.

This patch adds if expression as the conditional expressionf for pocketlang. I think it is more clear than ternary operator especially there is more then one condition (if ... elif ... else ...).

In the if expression, than can be omit, and end is not necessary (aslo not allowed). Example:

print(if true then 123 else 456)
print(if true 123 else 456)
print(if false 123 elif false 546 else 789)

a = if false
      123
    elif false
      456
    else
      789

print(a)

Output:

123
123
789
789

The Language Manual says:

Note that a call of form f(fn ... end) is a syntax sugar for f fn ... end where f is a function or a method that takes a single literal function as argument, like Lua.

This patch extends it: parentheses for closure/method calling can be omitted if first argument is fn, name, string, number, primitive, map, list, etc.

Example:

a = 123
sum = fn (a, b) return a + b end

print 1, 2, 3
print "a", "b", "c"
print sum 10, 20
print "x:", sum(10, 20), "y:", sum(30, 40)
print [1, 2, 3]
print {1: 1, 2: 2, 3: 3}
print fn return 123 end (),
  fn return 456 end ()

Output:

1 2 3
a b c
30
x: 30 y: 70
[1, 2, 3]
{2:2, 1:1, 3:3}
123 456

Object can be used as iterator if _next and _value is defined. Similar to wren's iterator protocal. Example 1:

class Countup
  def _init(first, last, step)
    self.first = first
    self.last = last
    self.step = step
  end

  def _next(iter)
    if iter == null then return self.first end
    iter += self.step
    if iter > self.last then iter = null end
    return iter
  end

  def _value(iter)
    return iter
  end
end

for i in Countup(0, 10, 2)
  print(i)
end

Output:

0
2
4
6
8
10

Example 2:

class Node
  def _init(val)
    self.val = val
    self.next = null
  end

  def _str()
    return "(${self.val})"
  end
end

class LinkedList
  def _init()
    self.head = null
  end

  def append(node)
    if self.head == null
      self.head = node
    else
      last = self.head
      while last.next do last = last.next end
      last.next = node
    end
  end

  def _next(iter)
    if iter == null then return self.head end
    return iter.next
  end

  def _value(iter)
    return iter
  end
end

ll = LinkedList()
ll.append(Node(4))
ll.append(Node(6))
ll.append(Node(3))
ll.append(Node(9))

for n in ll
  print(n)
end

Output:

(4)
(6)
(3)
(9)

Example 3:

class StringIter
  def _init(text)
    self.text = text
  end

  def _next(iter)
    if iter == null then return 0 end
    iter += 1
    if iter >= self.text.length then iter = null end
    return iter
  end

  def _value(iter)
    return self.text[iter]
  end
end

for c in StringIter("hello")
  print(c)
end

Output:

h
e
l
l
o