plum

git clone https://pyrossh.dev/repos/plum.git

A statically typed, imperative programming language inspired by rust, python

1f7d137f — pyrossh

lang changes

Files changed (4) hide show

readme.md +108 -61
std/http.mi +7 -7
std/list.mi +47 -135
std/map.mi +17 -7

readme.md CHANGED Viewed

@@ -1,14 +1,15 @@
 # 👾 Pacos Programming Language
-A simple statically typed imperative programming language. Its main aim to be simple and easy to code correct programs. It takes inspiration for golang, ponylang, and dart. It comes packed with linting, formatting, test runner, language server, and package management in-built.
+A simple, statically typed, imperative, minimalistic programming language. Its main aim to be simple and easy to code correct programs. It takes inspiration for golang, ponylang, and dart. It comes packed with linting, formatting, test runner, language server, and package management in-built.
 The compiler users the tree-sitter parser so has out of the box syntax highlighting support for helix and zed editor.
 Here is some sample code, please enjoy.
 ```rb
 module lambda
-import ca/list
+import pacos/list
 import pacos/math
 import pacos/http
@@ -22,12 +23,12 @@ fn sum(a: int, b: int): int = a + b
 fn sum_all(series: list[int]): int =
   series.reduce(0, |v| v + 1)
-fn fib(n: int): int =
+fn fib(n: int) -> int
   match n
     0 | 1 -> n
     _ -> fib(n - 1) + fib(n - 2)
-fn fib(n: int): int =
+fn fib(n: int) -> int
   if n == 0 || n == 1
     n
   else
@@ -86,7 +87,7 @@ enum Temperature =
   | celsius(float)
   | fahrenheit(float)
-fn (s Temperature) to_str(): str =
+fn (s: Temperature) to_str(): str =
   match s
     celsius(t) && t > 30 -> "${t}C is above 30 celsius"
     celsius(t) -> "${t}C is below 30 celsius"
@@ -94,29 +95,23 @@ fn (s Temperature) to_str(): str =
     fahrenheit(t) -> "${t}F is below 86 fahrenheit"
-group("Cat Record") |g|
-  test("talks") |t|
+test("talks") |t|
-    c := Cat(name = "123", age = 1)
+  c := Cat(name: "123", age: 1)
-    c.talk()
+  c.talk()
-  test("fullname") |t|
-    Cat("rabby", 21).fullname() == "rabby21"
-    c2 := Cat(...c, age: c.age + 1)
-  test("to_str") |t|
+test("fullname") |t|
-    items := [Cat("Molly", 9), Cat("Fenton", 6)]
+  Cat("rabby", 21).fullname() == "rabby21"
-        .retain(|p| p.name.size > 5)
+  c2 := Cat(...c, age: c.age + 1)
-        .map(|p| describe(p))
-        .each(|d| println(d))
-    assert items[0].to_str() == "Cat<Fenton, 6>"
-test("enum ordinal value") |t|
+test("to_str") |t|
-  expect(Value.zero).to_equal(0)
+  items := [Cat("Molly", 9), Cat("Fenton", 6)]
-  expect(Value.one).to_equal(1)
+      .retain(|p| p.name.size > 5)
+      .map(|p| describe(p))
-  expect(Value.two).to_equal(2)
+      .each(|d| println(d))
+  assert items[0].to_str() == "Cat<Fenton, 6>"
-bench("1231") |t, n|
+bench("1231") |n|
-  for 0..n |i|
+  for i := range n
     println(i)
 ```
@@ -129,6 +124,7 @@ for,while,if,else,record,enum,fn,assert,when,match,type
 ```
 ### Types
 ```
 nil, any, bool, byte, int, float, dec, str, time, duration, regex, uuid
 [1, 2, 3] for lists      list[int], list[list[int]]
@@ -159,6 +155,7 @@ if true || false
 **byte**
 A byte represents an unsigned 8 bit number. It is mainly used to represent strings and binary data.
 ```rb
 let data: []byte?
 data = [104, 101, 197, 130, 197, 130, 111, 0]
@@ -169,7 +166,7 @@ data = [104, 101, 197, 130, 197, 130, 111, 0]
 An int is a signed 64 bit number. It can be represented in various ways,
 0b - Binary (Base 2)
 0x - Hexadecimal (Base 16)
-13 - Standard (Base 10)
+27 - Standard (Base 10)
 ```rb
 0b00101010
@@ -187,7 +184,7 @@ A float represents a 64-bit floating point (52-bit mantissa) IEEE-754-2008 binar
 **str**
-A str represents a slice of runes or unicode code points. It is encoded to UTF-8 by default.
+A str represents an array of runes or unicode code points. It is encoded to UTF-8 by default.
 It supports interpolation of variables/values that implement the ToStr interface.
 ```go
@@ -197,7 +194,6 @@ age := 1
 println("Name ${name} age ${age}")
 ```
 **list**
 ```py
@@ -206,12 +202,17 @@ import pacos/list
 a := [1, 2, 3]                // list[int]
 b := [[1, 2], [3, 4], [5, 6]] // list[list[int]]
-actors := List.new("Krabs", "Squidward")
+actors := ["Krabs", "Squidward"]
 actors.add("Spongebob")
 actors.length() // ==> 3
 actors.contains("Krabs") // ==> true
 actors.get(0) // => "Krabs"
 actors.get(5) // => nil
+items
+  .map(|v| v + 1)
+  .each(|v| println("v", v))
+  .reduce(0, |v| v + 1)
 ```
 **map**
@@ -238,13 +239,19 @@ friends_tree := [
     ],
   ],
 ]
+friends_tree
+  .map(|k, v| v)
+  .each(|k, v| println("v", v))
+  .reduce(0, |k, v| v + 1)
 ```
 **Constants**
 Constants can be declared at the top level of a program. They cannot be reassigned.
-* Primitive values like`int, float, str` are directly replaced in code.
+- Primitive values like`int, float, str` are directly replaced in code.
-* Reference values like `list, map, records` are initialized at program start and passed by reference when used. Their data can be modified.
+- Reference values like `list, map, records` are initialized at program start and passed by reference when used. Their data can be modified.
 ```rb
 PI = 3.14159f
@@ -260,7 +267,6 @@ COUNTRY_CODES = [
 fn count(n: int): int = n * 1
 ```
 **Assignment statement**
 ```rb
@@ -277,43 +283,55 @@ assoc_list["b"]
 **While statement**
 ```rb
+low, mid, high := 0, 0, n.size
 while low < high
   mid = (low + high) / 2
-  low = cmp > 0 > mid + 1 : low
+  low = cmp > 0 ? mid + 1 : low
   high = cmp < 0 ? mid : high
   if cmp == 0
     return mid, true
+while a > b
+  a += 1
 ```
 **For statement**
+type Seq0 = fn(yield: fn(): bool): bool
+type Seq1[V] = fn(yield: fn(V): bool): bool
+type Seq2[K, V] = fn(yield: fn(K, V): bool): bool
 ```rb
-for players_list |value|
-  if value == 0
+for i := range 10
-    continue
-  sum += value
+  sum += i
+n := 5
-for items[0..1] |v|
+for i := range n
-  sum += v
+  sum += i + 5
-for 0..5 |v|
+for k, v := range json_map
-  sum3 += v
+  sum += k + v
-let list = for filter(players_list) |v|
+for v := range list
+  sum += k + v
-items
-  .map(|v| v + 1)
-  .each(|v| println("v", v))
-  .reduce(0, |v| v + 1)
+record Tree[E](
+  value E,
+  left: Tree[E]?,
+  right: Tree[E]?,
+)
-fn range(start: int, end: int, cb: fn(v: T): IterateResult) =
+fn (t Tree[E]) op_range(yld: fn(E): bool): bool =
+  t ? true : t.left.in_order(yld) && yld(t.val) && t.right.in_order(yld)
-range(0, 5, |v| =>
+tt := Tree(
-  sum3 += v
+  value: 10,
+  left: Tree(20, Tree(30), Tree(39)),
+  right: Tree(40),
 )
-for items, items2 |i, j|
-  count += i + j
+for t := range tt
+  println(v)
 ```
 **When expression/statement**
@@ -342,7 +360,7 @@ match xs
   _ -> "This list has more than 2 elements"
 ```
-Arithmetic (+, -, /, *, @divFloor, @sqrt, @ceil, @log, etc.)
+Arithmetic (+, -, /, \*, @divFloor, @sqrt, @ceil, @log, etc.)
 Bitwise operators (>>, <<, &, |, ~, etc.)
 Comparison operators (<, >, ==, etc.)
@@ -350,9 +368,9 @@ Comparison operators (<, >, ==, etc.)
 ```rb
 if post.valid()
-  RenderNewView()
+  render_create_view()
 else
-  RenderPostView(post: post)
+  render_post(post: post)
 ```
 ### Conditional operators
@@ -376,9 +394,10 @@ x ? x : y
 a?.b?.c?.d
 ```
-**Safe index operator**
+**double-bang operator/not-null assertion operator**
 ```rb
-array?[1]
+a!!.b
 ```
 **elvis operator**
@@ -393,13 +412,41 @@ x ?: y
 atomic_number ?= 2
 ```
-**Range operator**
+**spread operator**
-```rb
-for 5..10 |i|
-  println(i)
 ```
+list := [1, 2, 3]
+list2 := [0, ...list]
+assert list2.length == 4
+list = nil
+list3 := [0, ...list?];
+assert list2.length == 1
+```
+**cascade operator**
+```dart
+paint := Paint()
+  ..color = Colors.black
+  ..strokeCap = StrokeCap.round
+  ..strokeWidth = 5.0
+```
+**variadic function**
-```rb
+```go
+fn add(items ...str) =
+  list.add(items)
+```
+**generics**
+```
+fn add[T: int | float](a: List[T], b: List[T]): List[T] =
+  pass
+```
+```
 fn create_post_action(req: Request): Response =
   post := Post(title = req.params.title, body = req.params.body)
   if post.valid()

std/http.mi CHANGED Viewed

@@ -9,17 +9,17 @@ fn file_response(file: str) =
   Response(
     status = 200,
     headers = [
-      :Content-Type => content,
+      "Content-Type" => content,
-      :Content-Length => "2"
+      "Content-Length" => "2"
     ],
     body = data
   )
-  Response::build()
+  Response()
-    .set_header("Content-Type", content)
+    .header("Content-Type", content)
-    .set_header("Content-Length", "2")
+    .header("Content-Length", "2")
-    .set_body(data)
+    .body(data)
-    .set_status(200)
+    .status(200)
 #[get("/")]
 fn index(): Response! =

std/list.mi CHANGED Viewed

@@ -15,7 +15,10 @@ record node[V](
   next: node[V]?
 )
+fn List.of[A](values: ...A): list[A] =
+  list[A]().add(values)
-fn (l: list) get(i: int): A =
+fn (l: list) get(i: int) -> A =
   `gets the element at i'th index of the list
   current := l.head
   index := 0
@@ -26,27 +29,43 @@ fn (l: list) get(i: int): A =
       current = current.next
       index += 1
-fn (l: list) set(i: int, v: V): A =
+fn (l: list) set(i: int, v: V) -> A =
   `sets the element at i'th index of the list
   pass
-fn (l: list) length(): int =
+fn (l: list) length() -> A =
   `returns the no of elements in the list
   _size
-fn (l: list) add(c: V) =
+fn (l: list) add(values: ...V) =
   `adds the specified elements to the start of the list
+  for v := range values
-  l.head = node(value: v, prev: nil, next: l.head)
+    l.head = node(value: v, prev: nil, next: l.head)
-  l.head.next.prev = l.head
+    l.head.next.prev = l.head
-  l._size += 1
+    l._size += 1
-fn (l: list) remove(i int) =
+fn (l: list) remove_at(i int) =
   `removes the element at i'th index of the list
   l.tail?.prev?.next = nil
   `old tail node gets deallocated due to zero reference count
   l.tail = list.tail?.prev
   l._size -= 1
+fn (l: list) remove(v V) =
+  `removes the element v from list
+  l.tail?.prev?.next = nil
+  `old tail node gets deallocated due to zero reference count
+  l.tail = list.tail?.prev
+  l._size -= 1
+fn (l: list) clear() =
+  `removes all objects from this list
+  l.tail?.prev?.next = nil
+  `old tail node gets deallocated due to zero reference count
+  l.tail = list.tail?.prev
+  l._size -= 1
 fn (l: list) reverse(v: fn(v: V): true): list[A] =
   `returns a new list with the elements in reverse order.
   pass
@@ -55,24 +74,16 @@ fn (l: list) sort(sorter: fn(v: V): true): list[A] =
   `returns a new list with the elements sorted by sorter
   pass
-fn (l: list) find(search: V): V? =
+fn (l: list) find(search: V): V?, int =
-  `returns an item in the list if the item is is equal to search item
+  `returns an item and index in the list if the item is is equal to search item
-  pass
-fn (l: list) find_index(search: V): int? =
-  `returns the index of an item in the list if present and comparable otherwise nil
   pass
-fn (l: list) contains(v: V): int? =
+fn (l: list) contains(v: V): bool =
   `returns the index of an item in the list if present and comparable otherwise nil
   pass
-fn (l: list) concat(ol: list): list[A] =
+fn (l: list) op_spread(other: list): list[A] =
-  `returns the index of an item in the list if present and comparable otherwise nil
+  `combines this list with other list and returns a new list
-  pass
-fn (l: list) sub_list(start: int, end: int?): list[A] =
-  `returns the index of an item in the list if present and comparable otherwise nil
   pass
 fn (l: list) each(cb: fn(v: V)): void =
@@ -103,11 +114,11 @@ fn (l: list) reject(predicate: fn(v: V): A): list[A] =
   `returns a new list with the elements that matched the predicate removed
   pass
-fn (l: list) any(predicate: fn(v: V): bool) =
+fn (l: list) any(predicate: fn(v: V): bool): bool =
   `returns true if any element in the list satisfies the predicate
   pass
-fn (l: list) all(predicate: fn(v: V): bool) =
+fn (l: list) every(predicate: fn(v: V): bool): bool =
   `returns true if all of the elements in the list satisfies the predicate
   pass
@@ -123,15 +134,23 @@ fn (l: list) last(): A? =
   `returns the last element in the list
   l.tail?.value
+fn (l: list) sublist(start: int, end: int): list[A] =
+  `returns a list containing the first n elements of the given list
+  pass
 fn (l: list) take(n: int): list[A] =
   `returns a list containing the first n elements of the given list
   pass
+fn (l: list) skip(n: int): list[A] =
+  `returns a list containing the first n elements of the given list
+  pass
 fn (l: list) drop(n: int): list[A] =
   `Returns a list containing the first n elements of the given list
 fn (l: list) sample() =
-  `returns a new list with all elements shuffled`
+  `returns a new list with some of the elements taken randomly`
   pass
 fn (l: list) shuffle() =
@@ -147,121 +166,14 @@ fn (l: list) chunk() =
   pass
 fn (l: list) group_by() =
-  `returns a new list with all elements shuffled`
+  `returns a new list with all elements grouped`
   pass
-fn (l: list) to_str(): str =
+fn (l: list) join(sep: str = ","): str =
   res := Buffer()
   l.each() |v|
     if @HasTrait(V, ToStr)
-      res.write(v.to_str())
+      res.write(v.to_str(), sep)
     else
-      res.write(@TypeToString(v))
+      res.write(@TypeToString(v), sep)
   res.to_str()
-class List[V]:
-  head: node[V]?
-  tail: node[V]?
-  size: int
-  fn get(i: int): A =
-    `gets the element at i'th index of the list
-    current := l.head
-    index := 0
-    while current != nil
-      if index == i
-        current.value
-      else
-        current = current.next
-        index += 1
-  fn set(i: int, v: V): A =
-    `sets the element at i'th index of the list
-    pass
-  fn add(c: V) =
-    `adds the specified elements to the start of the list
-    l.head = node(value: v, prev: nil, next: l.head)
-    l.head.next.prev = l.head
-    l._size += 1
-  fn remove(i int) =
-    `removes the element at i'th index of the list
-    l.tail?.prev?.next = nil
-    `old tail node gets deallocated due to zero reference count
-    l.tail = list.tail?.prev
-    l._size -= 1
-  fn reverse(v: fn(v: V): true): list[A] =
-    `returns a new list with the elements in reverse order.
-    pass
-  fn sort(sorter: fn(v: V): true): list[A] =
-    `returns a new list with the elements sorted by sorter
-    pass
-  fn find(search: V): V? =
-    `returns an item in the list if the item is is equal to search item
-    pass
-  fn find_index(search: V): int? =
-    `returns the index of an item in the list if present and comparable otherwise nil
-    pass
-  fn contains(s: V): bool =
-    `returns whether s is present in the list or not
-    pass
-  fn concat(ol: list): list[A] =
-    `returns the index of an item in the list if present and comparable otherwise nil
-    pass
-  fn sub_list(start: int, end: int?): list[A] =
-    `returns the index of an item in the list if present and comparable otherwise nil
-    pass
-  fn each(cb: fn(v: V)): void =
-    `calls f for each elem in the list
-    current := l.head
-    while current != nil
-      cb(current.value)
-      current = current.next
-  fn map[B](cb: fn(v: V): B): list[A] =
-    `returns a list made up of B elements for each elem in the list
-    nl := []
-    current := l.head
-    while current != nil
-      item := cb(current.value)
-      nl.push(item)
-    nl
-  fn flat_map() =
-    `returns a new list with all elements shuffled`
-    pass
-  fn retain(predicate: fn(v: V): A): list[A] =
-    `returns a new list with the elements that matched the predicate
-    pass
-  fn reject(predicate: fn(v: V): A): list[A] =
-    `returns a new list with the elements that matched the predicate removed
-    pass
-  fn any(predicate: fn(v: V): bool) =
-    `returns true if any element in the list satisfies the predicate
-    pass
-  fn all(predicate: fn(v: V): bool) =
-    `returns true if all of the elements in the list satisfies the predicate
-    pass
-  fn reduce[B](acc: B, cb: fn(v: V): A): B =
-    `returns the accumulated value of all the elements in the list
-    pass
-  fn first(): A? =
-    `returns the first element in the list
-    l.head?.value

std/map.mi CHANGED Viewed

@@ -1,9 +1,19 @@
 module std
-record map<V>(data: Pointer, length: int)
+record Pair[K: Comparable, V](k: K, v: V)
-  """
-  A slice is a data structure describing a contiguous section of an array stored separately from the slice variable itself.
+`A slice is a data structure describing a contiguous section of an array stored separately from the slice variable itself.
-  A slice is not an array. A slice describes a piece of an array.
+`A slice is not an array. A slice describes a piece of an array.
-  """
+record map[K, V](
+  items: list[Pair[K, V]]
+)
+fn map.of[K, V](kvs: ...Pair[K, V]): map[K, V] =
+  map[K, V]().add(kvs)
+fn (m: map) add(kvs: ...Pair[K, V]) =
+  `adds the specified elements to the start of the list
-  new init(): Slice
+  items.add(pair)
+fn (m: Map) op_range() =
-    pass
+  yield k, v

~repos /plum

git clone https://pyrossh.dev/repos/plum.git

A statically typed, imperative programming language inspired by rust, python