f92e171 | plum

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

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

f92e171 — Peter John 2026-07-24T11:45:33+05:30

feat(libs/std): migrate stdlib generics to bracket syntax

Files changed (4) hide show

libs/std/list.plum +22 -22
libs/std/map.plum +9 -9
libs/std/option.plum +1 -1
libs/std/result.plum +2 -2

libs/std/list.plum CHANGED Viewed

@@ -3,23 +3,23 @@ module std
 import std/option
 # A node stores the data in a list and contains pointers to the previous and next sibling nodes
-type Node(a) =
+type Node[T] =
-  value: a
+  value: T
   prev: Option[Node]
   next: Option[Node]
 # A list is a data structure describing a contiguous section of an array stored separately from the slice variable itself.
 # It contains the pointers to the start and end nodes (head, tail) and maintains the size as well
-type List(Stringable)(a: Stringable) =
+type List[T: Stringable](Stringable) =
   head: Option[Node]
   tail: Option[Node]
   size: Int
-init<List>(self, values: ...a) -> List =
+makeList(values: ...T) -> List =
-  List().add(values)
+  List(None, None, 0).add(values)
 # gets the element at i'th index of the list
-get<List>(self, i: Int) -> Option(a) =
+get<List>(self, i: Int) -> Option[T] =
   current = self.head
   index = 0
   while current != None
@@ -34,7 +34,7 @@ get<List>(self, i: Int) -> Option(a) =
   None
 # sets the element at i'th index of the list
-set<List>(self, i: Int, v: a) -> Option(a) =
+set<List>(self, i: Int, v: T) -> Option[T] =
   todo
 # returns the no of elements in the list
@@ -42,7 +42,7 @@ length<List>(self) -> Int =
   self.size
 # adds the specified elements to the start of the list
-add<List>(self, values: ...a) =
+add<List>(self, values: ...T) =
   todo
 # removes the element at i'th index of the list
@@ -50,7 +50,7 @@ removeAt<List>(self, i: Int) =
   todo
 # removes the element v from list
-remove<List>(self, v: a) =
+remove<List>(self, v: T) =
   todo
 # removes all objects from this list
@@ -58,23 +58,23 @@ clear<List>(self) =
   todo
 # returns a new list with the elements in reverse order.
-reverse<List>(self, v: fn(a) -> Bool) -> List =
+reverse<List>(self, v: fn(T) -> Bool) -> List =
   todo
 # returns a new list with the elements sorted by sorter
-sort<List>(self, sorter: fn(a) -> Bool) -> List =
+sort<List>(self, sorter: fn(T) -> Bool) -> List =
   todo
 # returns an item and index in the list if the item is is equal to search item
-find<List>(self, search: a) -> Option(a) =
+find<List>(self, search: T) -> Option[T] =
   todo
 # returns the index of an item in the list if present and comparable otherwise None
-contains<List>(self, v: a) -> Bool =
+contains<List>(self, v: T) -> Bool =
   todo
 # calls f for each elem in the list
-each<List>(self, cb: fn(a)) -> Unit =
+each<List>(self, cb: fn(T)) -> Unit =
   current = self.head
   while current != None
     match current
@@ -85,7 +85,7 @@ each<List>(self, cb: fn(a)) -> Unit =
         break
 # returns a list made up of b elements for each elem in the list
-map<List>(self, cb: fn(a) -> b) -> List(b) =
+map<List>(self, cb: fn(T) -> U) -> List[U] =
   nl = List()
   current = self.head
   while current != None
@@ -103,27 +103,27 @@ flatMap<List>(self) =
   todo
 # returns a new list with the elements that matched the predicate
-retain<List>(self, predicate: fn(a) -> a) -> List =
+retain<List>(self, predicate: fn(T) -> T) -> List =
   todo
 # returns a new list with the elements that matched the predicate removed
-reject<List>(self, predicate: fn(a) -> a) -> List =
+reject<List>(self, predicate: fn(T) -> T) -> List =
   todo
 # returns true if any element in the list satisfies the predicate
-any<List>(self, predicate: fn(a) -> Bool) -> Bool =
+any<List>(self, predicate: fn(T) -> Bool) -> Bool =
   todo
 # returns true if all of the elements in the list satisfies the predicate
-every<List>(self, predicate: fn(a) -> Bool) -> Bool =
+every<List>(self, predicate: fn(T) -> Bool) -> Bool =
   todo
 # returns the accumulated value of all the elements in the list
-reduce<List>(self, acc: b, cb: fn(a) -> a) -> Option(b) =
+reduce<List>(self, acc: U, cb: fn(T) -> T) -> Option[U] =
   todo
 # returns the first element in the list
-first<List>(self) -> Option(a) =
+first<List>(self) -> Option[T] =
   match self.head
     Some(node) =>
       Some(node.value)
@@ -131,7 +131,7 @@ first<List>(self) -> Option(a) =
       None
 # returns the last element in the list
-last<List>(self) -> Option(a) =
+last<List>(self) -> Option[T] =
   match self.tail
     Some(node) =>
       Some(node.value)

libs/std/map.plum CHANGED Viewed

@@ -1,14 +1,14 @@
 module std
 # A Pair is a grouping of a key with a value
-type Pair(a, b) =
+type Pair[K, V] =
-  key: a
+  key: K
-  val: b
+  val: V
 # 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.
-type Map(a, b) =
+type Map[K, V] =
-  items: List(Pair(a, b))
+  items: List[Pair[K, V]]
 init<Map>(self, kvs: ...Pair) -> Map =
   Map().add(kvs)
@@ -18,19 +18,19 @@ add<Map>(self, kvs: ...Pair) =
   self.items.add(kvs)
 # gets a value from the Map using key k
-get<Map>(self, k: a) -> Option(b) =
+get<Map>(self, k: K) -> Option[V] =
   for p in self.items
     if p.key == k
       return Some(p.val)
   None
 # puts a value into the Map
-set<Map>(self, k: a, v: b) =
+set<Map>(self, k: K, v: V) =
   self.items.add(Pair(key: k, val: v))
 # puts a value into the Map if its not already present
-putIfAbsent<Map>(self, k: a, v: b) =
+putIfAbsent<Map>(self, k: K, v: V) =
   todo
-map<Map>(self, cb: fn(Pair(a, b)) -> Pair(c, d)) -> Map(c, d) =
+map<Map>(self, cb: fn(Pair[K, V]) -> Pair[X, Y]) -> Map[X, Y] =
   self.items.map(cb)

libs/std/option.plum CHANGED Viewed

@@ -1,5 +1,5 @@
 module std
 enum Option =
-  | Some(a)
+  | Some[T]
   | None

libs/std/result.plum CHANGED Viewed

@@ -1,8 +1,8 @@
 module std
 enum Result =
-  | Ok(a)
+  | Ok[T]
-  | Err(b)
+  | Err[E]
 # checks whether the result is an Ok value
 isOk<Result>(self) -> Bool =