plum

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

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

fc566dda — pyrossh

updates

Files changed (9) hide show

readme.md +0 -17
scratch.pc +12 -36
std/list.mi +32 -32
std/str.mi +21 -21
website/src/content/docs/declarations/enum.md +14 -2
website/src/content/docs/declarations/functions.md +6 -6
website/src/content/docs/declarations/records.md +11 -90
website/src/content/docs/declarations/traits.md +6 -1
website/src/content/docs/naming-convention.md +19 -0

readme.md CHANGED Viewed

@@ -5,20 +5,3 @@
 - Plans to be compiled to WASM
 View the docs here [pacos.sh](https://pacos.sh)
-## Rules
-- Function parameters are passed by value only. You cannot modify a parameter. The compiler will throw an error if you try to.
-- Strict naming convention
-- Only one way of doing things ex: loops, condition
-### General naming convention
-| Item                     | Convention              |
-| ------------------------ | ----------------------- |
-| Modules                  | snake_case              |
-| Types/Traits/Enum        | UpperCamelCase          |
-| Fields/Functions/Methods | lowerCamelCase          |
-| Local variables          | snake_case              |
-| Constants                | SCREAMING_SNAKE_CASE    |
-| Generics                 | single uppercase letter |

scratch.pc CHANGED Viewed

@@ -1,56 +1,31 @@
 data.price?.take_if(|a| a != "")
-trait HasEq[A](
-  fn eq(that: a): bool
-)
-trait Equatable[A]
-  `A trait that defines equal and not equal operations
-  fn eq(b: Equatable[A]): bool
-  fn ne(b: Equatable[A]): bool
-end
-enum Compare
-  | Less
-  | Equal
-  | Greater
-end
-trait Comparable[A] is Equatable[A]
-  fn lt(that: A): bool
-  fn le(that: A): bool
-  fn ge(that: A): bool
-  fn gt(that: A): bool
-  fn compare(that: a): Compare
-end
-enum list<T> =
+enum List<T> =
   | empty
   | link(v: T, rest: list<T>)
-fn list.of[A](values: ...A): list[A] =
+fn List.of[A](values: ...A): list[A] =
   list[A]().add(values)
-fn (o list<T>) each(cb: fn(v: T)) =
+fn (List) each(cb: fn(v: T)) =
-  match o
+  match self
     empty -> return
     link(a, rest) ->
       cb(a)
       rest.each(cb)
-fn (l: list) append(values: ...V) =
+fn (List) append(values: ...V) =
   `adds the specified elements to the start of the list
   range(values) |v|
-    l.add(v)
+    self.add(v)
-fn (l: list) append(v: V) =
+fn (List) append(v: V) =
   `adds the specified elements to the start of the list
-  l.last().rest = link(v, empty)
+  self.last().rest = link(v, empty)
-fn (l: list) prepend(v: V) =
+fn (List) prepend(v: V) =
   `adds the specified elements to the start of the list
-  l.first() = link(v, l.first())
+  self.first() = link(v, self.first())
 (1 + 2).mod(3).pow(2).sqrt()
@@ -82,7 +57,8 @@ fn UserData.fromJsonStr(data: str): UserData | JsonParseError =
 type FetchDataError =  FetchError | IOError |  JsonParseError
+#effects(IO)
-fn fetch_data(route: str): map[str, any] | UserData | FetchError | IOError |  JsonParseError =
+fn fetch_data(route: str): Result[UserData] =
   res := fetch(route)?
   data := res.body.read_all()?
   parse_json(data)?

std/list.mi CHANGED Viewed

@@ -18,7 +18,7 @@ record node[V](
 fn listOf[A](values: ...A): list[A] =
   list[A]().add(values)
-fn (l: list) get(i: int) -> A =
+fn (List) get(i: int) -> A =
   `gets the element at i'th index of the list
   current := l.head
   index := 0
@@ -29,36 +29,36 @@ fn (l: list) get(i: int) -> A =
       current = current.next
       index += 1
-fn (l: list) set(i: int, v: V) -> A =
+fn (List) set(i: int, v: V) -> A =
   `sets the element at i'th index of the list
   pass
-fn (l: list) length() -> A =
+fn (List) length() -> A =
   `returns the no of elements in the list
   _size
-fn (l: list) add(values: ...V) =
+fn (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.next.prev = l.head
     l._size += 1
-fn (l: list) removeAt(i int) =
+fn (List) removeAt(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) =
+fn (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() =
+fn (List) clear() =
   `removes all objects from this list
   l.tail?.prev?.next = nil
   `old tail node gets deallocated due to zero reference count
@@ -66,19 +66,19 @@ fn (l: list) clear() =
   l._size -= 1
-fn (l: list) reverse(v: fn(v: V): true): list[A] =
+fn (List) reverse(v: fn(v: V): true): list[A] =
   `returns a new list with the elements in reverse order.
   pass
-fn (l: list) sort(sorter: fn(v: V): true): list[A] =
+fn (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?, int =
+fn (List) find(search: V): V?, int =
   `returns an item and index in the list if the item is is equal to search item
   pass
-fn (l: list) contains(v: V): bool =
+fn (List) contains(v: V): bool =
   `returns the index of an item in the list if present and comparable otherwise nil
   pass
@@ -91,18 +91,18 @@ fn (l: list[T]) op_range(yld: fn(v: T): bool): bool =
     current = current.next
   true
-fn (l: list) op_spread(other: list): list[A] =
+fn (List) op_spread(other: list): list[A] =
   `combines this list with other list and returns a new list
   pass
-fn (l: list) each(cb: fn(v: V)): void =
+fn (List) 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 (l: list) map[B](cb: fn(v: V): B): list[A] =
+fn (List) 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
@@ -111,74 +111,74 @@ fn (l: list) map[B](cb: fn(v: V): B): list[A] =
     nl.push(item)
   nl
-fn (l: list) flatMap() =
+fn (List) flatMap() =
   `returns a new list with all elements shuffled`
   pass
-fn (l: list) retain(predicate: fn(v: V): A): list[A] =
+fn (List) retain(predicate: fn(v: V): A): list[A] =
   `returns a new list with the elements that matched the predicate
   pass
-fn (l: list) reject(predicate: fn(v: V): A): list[A] =
+fn (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): bool =
+fn (List) any(predicate: fn(v: V): bool): bool =
   `returns true if any element in the list satisfies the predicate
   pass
-fn (l: list) every(predicate: fn(v: V): bool): bool =
+fn (List) every(predicate: fn(v: V): bool): bool =
   `returns true if all of the elements in the list satisfies the predicate
   pass
-fn (l: list) reduce[B](acc: B, cb: fn(v: V): A): B =
+fn (List) reduce[B](acc: B, cb: fn(v: V): A): B =
   `returns the accumulated value of all the elements in the list
   pass
-fn (l: list) first(): A? =
+fn (List) first(): A? =
   `returns the first element in the list
   l.head?.value
-fn (l: list) last(): A? =
+fn (List) last(): A? =
   `returns the last element in the list
   l.tail?.value
-fn (l: list) sublist(start: int, end: int): list[A] =
+fn (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] =
+fn (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] =
+fn (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] =
+fn (List) drop(n: int): list[A] =
   `Returns a list containing the first n elements of the given list
-fn (l: list) sample() =
+fn (List) sample() =
   `returns a new list with some of the elements taken randomly`
   pass
-fn (l: list) shuffle() =
+fn (List) shuffle() =
   `returns a new list with all elements shuffled`
   pass
-fn (l: list) partition() =
+fn (List) partition() =
   `returns a new list with all elements shuffled`
   pass
-fn (l: list) chunk() =
+fn (List) chunk() =
   `returns a new list with all elements shuffled`
   pass
-fn (l: list) groupBy() =
+fn (List) groupBy() =
   `returns a new list with all elements grouped`
   pass
-fn (l: list) join(sep: str = ","): str =
+fn (List) join(sep: str = ","): str =
   res := Buffer()
   l.each() |v|
     if @HasTrait(V, ToStr)

std/str.mi CHANGED Viewed

@@ -15,19 +15,19 @@ record str(
 fn str.of(bs ...byte): str =
   data.add(bs)
-fn (s str) get(i: int) =
+fn<str> get(i: int) =
   data[i]
-fn (s str) contains(search: str): bool =
+fn (str) contains(search: str): bool =
   pass
-fn (s str) index_of(sub: str): int =
+fn (str) index_of(sub: str): int =
   pass
-fn (s str) test(pattern: Regex): []str =
+fn (str) test(pattern: Regex): []str =
   pass
-fn (s str) search(key str): int, bool =
+fn (str) search(key str): int, bool =
 	low, mid, high := 0, 0, n.numItems
 	while low < high
 		mid = (low + high) / 2
@@ -51,51 +51,51 @@ fn (t BTree) delete(key str): bool =
 		return true
 	return false
-fn (s str) starts_with(search: str): bool =
+fn (str) starts_with(search: str): bool =
   pass
-fn (s str) concat(other: str): str =
+fn (str) concat(other: str): str =
   s + other
-fn (s str) to_str(): str = s
+fn (str) to_str(): str = s
-fn (s str) concat(other: str): str =
+fn (str) concat(other: str): str =
   s + s
-fn (s str) starts_with(search: str): bool =
+fn (str) starts_with(search: str): bool =
   pass
-fn (s str) ends_with(search: str): bool =
+fn (str) ends_with(search: str): bool =
   pass
-fn (s str) contains(search: str): bool =
+fn (str) contains(search: str): bool =
   pass
-fn (s str) index_of(sub: str): int =
+fn (str) index_of(sub: str): int =
   pass
-fn (s str) match(pattern: Regex): []str =
+fn (str) match(pattern: Regex): []str =
   pass
-fn (s str) match_all(pattern: Regex): []str =
+fn (str) match_all(pattern: Regex): []str =
   pass
-fn (s str) pad_start(sub: str, count: int): str =
+fn (str) pad_start(sub: str, count: int): str =
   pass
-fn (s str) pad_end(sub: str, count: int): str =
+fn (str) pad_end(sub: str, count: int): str =
   pass
-fn (s str) repeat(count: int): str =
+fn (str) repeat(count: int): str =
   pass
-fn (s str) replace(pattern: Regex, sub: str): str =
+fn (str) replace(pattern: Regex, sub: str): str =
   pass
-fn (s str) replace_all(pattern: Regex, sub: str): str =
+fn (str) replace_all(pattern: Regex, sub: str): str =
   pass
-fn (s str) search(pattern: Regex): str =
+fn (str) search(pattern: Regex): str =
   pass
 fn slice(start: int, end: int): str =

website/src/content/docs/declarations/enum.md CHANGED Viewed

@@ -11,7 +11,7 @@ enum Ordering =
   | EQ
   | GT
-fn (Ordering->ToStr) toStr(): str =
+fn (Ordering->ToStr) toStr() str =
   match self
     LT -> "LT"
     EQ -> "EQ"
@@ -22,9 +22,21 @@ enum Shape =
   | Square(int)
   | Rectangle(int, int)
-fn (Shape) toStr() =
+fn (Shape) toStr() str =
   match self
     Circle(r) -> printLn("Circle(${r})")
     Square(s) -> printLn("Square(${s})")
     Rectangle(w, h) -> printLn("Rectangle(${w}, ${h})")
+fn (Shape) area() float =
+  match self
+    Circle(r) -> PI * r * r
+    Square(s) -> s * s
+    Rectangle(w, h) -> w * h
+fn (Shape) draw() float =
+  match self
+    Circle(r) -> PI * r * r
+    Square(s) -> s * s
+    Rectangle(w, h) -> w * h
 ```

website/src/content/docs/declarations/functions.md CHANGED Viewed

@@ -4,7 +4,7 @@ description: These are basic types
 ---
 ```rs
-fn fib(n: int): int =
+fn fib(n: int) -> int =
   match n
     0 | 1 -> n
     _ -> fib(n - 1) + fib(n - 2)
@@ -12,13 +12,13 @@ fn fib(n: int): int =
 fn log(level: str, msg: str) =
   printLn("${level}: ${msg}")
-fn info(msg: str) =
+pub fn info(msg: str) =
-  printLn("INFO", msg)
+  log("INFO", msg)
-fn warning(msg: str) =
+pub fn warning(msg: str) =
-  printLn("WARN", msg)
+  log("WARN", msg)
-fn addLists[T](a: List[T], b: List[T]): List[T] =
+fn addLists(a: List[T], b: List[T]): List[T] =
   a.concat(b)
 // Variadic function

website/src/content/docs/declarations/records.md CHANGED Viewed

@@ -6,109 +6,30 @@ description: These are basic types
 A record is a collect of data indexed by fields. It is a reference type and reference counted.
 ```rs
-struct Cat is Stringable where
+record Cat(name: str, age: int) where
-  name: str
-  age:  int
-  static fn withName(name: str): Cat =
+  static fn withName(name: str) Cat =
     Cat(name: name, age: 0)
-  fn fullname(): str =
+  fn fullname() str =
     name + age.toStr()
   fn talk() =
     printLn("cat ${name} says meow")
-  override fn plus(other: Cat): Cat =
+  override fn plus(other: Cat) Cat =
     Cat(...self, age: self.age + other.age)
-  override fn toStr(): str =
+  override fn toStr() str =
     "Cat<${fullname()}, ${age}>"
-struct Rand(seed: int) =
-  self.seed = seed
-fn Rand.int(): int =
-  1 * 2 * seed
-struct Cat(name: str, age: int) =
-  self.name = name
-  self.age = age
-fn Cat::withName(name: str): Cat =
-  Cat(name: name, age: 0)
-fn Cat.fullname(): str =
-  name + age.toStr()
-fn Cat.talk() =
-  printLn("cat ${name} says meow")
-fn Cat.plus(other: Cat): Cat =
-  Cat(...self, age: self.age + other.age)
-fn Cat.toStr(): str =
-  "Cat<${fullname()}, ${age}>"
-record Response
-  field _body: Buffer
-  field _headers: Map[str, str]
-  field _status: int
-  fn _init() =
-    _body = Buffer()
-    _headers = Map[str, str]()
-    _status = 0
-  fn header(kv Pair): Self =
-    _headers.add(kv)
-  fn body(b Buffer): Self =
-    _body = b
-  fn status(v int): Self =
-    _status = v
-struct Map[K, V](kvs: ...Pair[K, V]) =
+record Map[K, V](items: List[Pair[K, V]]) where
-  `A Map is a data structure describing a contiguous section of an array stored separately from the slice variable itself.
-  `A Map is not an array. A slice describes a piece of an array.
-  self._items = List[Pair[K, V]](kvs)
-  self.index = int(0)
-  self.length = int(kvs.length)
-fn Map.range(yld: fn(k: K, v: V): bool): bool =
-  `provide a range operation for map
-  for pair := range self._items
-    if !yld(pair.k, pair.v)
-      false
-  true
-fn Map.get(k: K): Option[V] =
-  for pair := range self._items
-    if pair.k == k
-      return v
-  None
-fn Map.set(k: K, v: V) =
-  for pair := range self._items
-    if pair.k == k
-      pair.v = v
-      return
-  self._items.add(k, v)
-fn Map.putIf(k: K, v: V) =
-  `put a value into the Map if its not already present
-  return
-struct Map[K, V] where
-  _items: List[Pair[K, V]]
-  static fn of[K, V](kvs: ...Pair[K, V]): Map[K, V] =
+  static fn of[K, V](kvs: ...Pair[K, V]) Map[K, V]
     Map[K, V]().add(kvs)
-  fn range(yld: fn(k: K, v: V): bool): bool =
+  fn range(yld: fn(k: K, v: V): bool) bool
     `allows the range operator to iterate over the Map
-    for item := range self._items
+    for item := range self.items
       if !yld(item.k, item.v)
         false
     true
@@ -125,11 +46,11 @@ struct Map[K, V] where
   fn set(k: K, v: V) =
     `put a value into the Map
-    for pair := range self._items
+    for pair := range self.items
       if pair.k == k
         pair.v = v
         return
-    self._items.add(k, v)
+    self.items.add(k, v)
   fn putIf(k: K, v: V) =
     `put a value into the Map if its not already present

website/src/content/docs/declarations/traits.md CHANGED Viewed

@@ -10,8 +10,13 @@ trait Equatable[A] where
   fn eq(other: A): bool
   fn ne(other: A): bool
+enum Compare =
+  | Less
+  | Equal
+  | Greater
 trait Comparable[A: Ord] where
-  fn compareTo(other: A): int
+  fn compareTo(other: A): Compare
 trait ArithmeticOperator[A] where
   fn add(other: A): A

website/src/content/docs/naming-convention.md ADDED Viewed

@@ -0,0 +1,19 @@
+---
+title: Naming Convention
+description: Naming Convention
+---
+| Item                     | Convention              |
+| ------------------------ | ----------------------- |
+| Modules                  | kebab-case              |
+| Types/Traits/Enum        | UpperCamelCase          |
+| Fields/Functions/Methods | lowerCamelCase          |
+| Local variables          | snake_case              |
+| Constants                | SCREAMING_SNAKE_CASE    |
+| Generics                 | single uppercase letter |
+## Rules
+- Function parameters are passed by value only. You cannot modify a parameter. The compiler will throw an error if you try to.
+- Strict naming convention
+- Only one way of doing things ex: loops, condition

~repos /plum

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

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