plum

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

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

68c4568f — pyrossh

docs

Files changed (2) hide show

readme.md +84 -2
std/list.mi +83 -37

readme.md CHANGED Viewed

@@ -8,6 +8,15 @@ Here is some sample code, please enjoy.
 ```rs
 module lambda
+import pacos/list
+import pacos/math
+import pacos/http
+const start_year = 2101
+const end_year = 2111
+const name: String = "Gleam"
+const size: Int = 100
 fn sum(a: int, b: int): int = a + b
 fn sum_all(series: list[int]): int =
@@ -46,14 +55,42 @@ fn first_item(l: list[int]): int? =
 fn to-celsius(f: float): float =
   (f - 32) * (5 / 9)
+class Cat[A: Comparable & Stringable] is Stringable:
+  name: str
+  age: int
+  fn Cat():
+    pass
+  fn ~Cat():
+    pass
+ fn Cat.with_name(name: str):
+    Cat(name: name, age: 0)
+  fn fullname() -> str:
+    name + age.to_str()
+  fn talk():
+    println("cat ${name} says meow")
+  fn to_str() -> str:
+    "Cat<{fullname()}, ${age}>"
-record Cat(
+record Cat[A](
   name: str
   age:  int
-)
+) where A is Comparable & Stringable
 fn Cat.with_name(name: str) =
   Cat(name: name, age: 0)
+fn (c: Cat) init(): str =
+  c.name + c.age.to_str()
+fn (c: Cat) deinit(): str =
+  c.name + c.age.to_str()
 fn (c: Cat) fullname(): str =
   c.name + c.age.to_str()
@@ -300,6 +337,51 @@ when
   cmp > 0 -> low = mid + 1
   cmp < 0 -> high = mid
   cmp == 0 -> return mid, true
+when x, y
+  1, 1 -> "both are 1"
+  1, _ -> "x is 1"
+  _, 1 -> "y is 1"
+  _, _ -> "neither is 1"
+when number
+  2 | 4 | 6 | 8 -> "This is an even number"
+  1 | 3 | 5 | 7 -> "This is an odd number"
+  _ -> "I'm not sure"
+match xs
+  [] -> "This list is empty"
+  [a] -> "This list has 1 element"
+  [a, b] -> "This list has 2 elements"
+  _ -> "This list has more than 2 elements"
+import palm/list
+list.new("Krabs")
+|> list.add("Spongebob")
+|> list.length() // ==> 3
+|> list.contains("Krabs") // ==> true
+|> list.get(0) // => Some("Krabs")
+|> list.get(5) // => None
+let x = list.new(2, 3)
+let y = list.new(1, ..x)
+import palm/map
+let nums = map.new(:one => 1, :two => 2) // => Map(k, v)
+nums |> map.get(:one) // => Some(1)
+nums |> map.get(:unknown) // => None
+import palm/io.{println}
+import palm/result.{Ok, Error}
+let connect_res = Error("Connection failed")
+case connect_res {
+  Ok(a) -> println("Connection succeeded")
+  Err(a) -> println("Error occurred: {a}")
+}
 ```
 Arithmetic (+, -, /, *, @divFloor, @sqrt, @ceil, @log, etc.)

std/list.mi CHANGED Viewed

@@ -1,39 +1,85 @@
 module std
-// A list is a data structure describing a contiguous section of an array stored separately from the slice variable itself.
-// A list is not an array. A list describes a piece of an array.  A list is immutable.
-record list<V>(_ptr: *V): ToStr
-  new create<V>(ptr: *V)
-    _ptr = ptr
-  fn concat(): slice<V> =
-    pass
-  fn length(): int =
-    len := 0
-    while *_ptr != 0x00
-      len += 1
-      _ptr += 1
-    len
-  fn each(cb: fn(v: V): void): void =
-    while *_ptr != 0x00
-      cb(@CastTo(_ptr, V))
-      _ptr += @SizeOf(V)
-  fn map<A>(cb: fn(v: V): A): []A =
-    res := []V
-    while *_ptr != 0x00
-      res.append(cb(@CastTo(_ptr, V)))
-      _ptr += @SizeOf(V)
-    res
-  fn to_str() =
-    res := ""
-    each<str>(|v| =
-      if @HasTrait(V, ToStr)
-        res.write(v.to_str())
-      else
-        res.write(@TypeToString(v))
-    )
+`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
+record list<V>(
+  head: node?
+  tail: node?
+  size: int
+)
+`A node captures the data value in a list and contains pointers to the previous and next sibling nodes
+record node[V](
+  value: V
+  prev: node[V]?
+  next: node[V]?
+)
+fn (l: list) get(i: int): A =
+  `gets the element at i'th index of the list
+  pass
+fn (l: list) set(i: int, v: V): A =
+  `sets the element at i'th index of the list
+  pass
+fn (l: list) 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 (l: list) 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 (l: list) some(predicate: fn(v: V): bool) =
+  `returns true if any element in the list satisfies the predicate
+  pass
+fn (l: list) reversed(v: fn(v: V): true) =
+  `returns a new list with the elements in reverse order.
+  pass
+fn (l: list) sort(v: fn(v: V): true) =
+  `returns a new list with the elements sorted in ascending order.
+  pass
+fn (l: list) indexOf(v: V): int? =
+  `returns the index of an item in the list if present and comparable otherwise nil
+  pass
+fn (l: list) each(cb: fn(v: V)) =
+  current := l.head
+  while current != nil
+    cb(current.value)
+    current = current.next
+fn (l: list) map(cb: fn(v: V): A): list[A] =
+  nl := []
+  current := l.head
+  while current != nil
+    item := cb(current.value)
+    nl.push(item)
+  nl
+fn (l: list) retain(predicate: fn(v: V): A): list[A] =
+  `returns a new list with the elements that matched the predicate
+  pass
+fn (l: 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) to_str() =
+  res := Buffer()
+  l.each() |v|
+    if @HasTrait(V, ToStr)
+      res.write(v.to_str())
+    else
+      res.write(@TypeToString(v))
+  res.to_str()

~repos /plum

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

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