plum

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

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

af78b68b — pyrossh

update

Files changed (12) hide show

readme.md +77 -4
scratch.pc +3 -199
std/bool.mi +4 -1
std/float.mi +0 -0
std/int.mi +0 -0
std/list.mi +3 -3
std/map.mi +8 -8
std/math.mi +1 -0
std/option.mi +15 -4
std/os.mi +45 -2
std/result.mi +16 -20
std/str.mi +7 -5

readme.md CHANGED Viewed

@@ -162,9 +162,9 @@ The nil type is used to represent types that are nilable
 The any type is an empty trait and is used to represent all types
-**err**
+**error**
-The err type is an enum of all errors
+The error type is an trait that represents all Error types
 **bool**
@@ -234,7 +234,9 @@ A str represents an array of runes or unicode code points. It is encoded to UTF-
 It supports interpolation of variables/values that implement the ToStr interface.
 ```go
+import std/os.{printLn}
-"Hello World"
+sed := "Hello World"
 name := "Pacos"
 age := 1
 printLn("Name ${name} age ${age}")
@@ -296,6 +298,74 @@ friends_tree
   .reduce(0, |k, v| v + 1)
 ```
+**option**
+An option is a type that represents either value present Some or nothing present
+```go
+import std/option
+record Car(wheels: int)
+c := some(Car(wheels: 2))
+match c
+  none -> print("no car")
+  some(car) -> car.wheels
+```
+**result**
+A result is a type that represents either success ok or failure err.
+```rs
+import std/str
+import std/result
+#[error]
+record FetchError()
+#[error]
+record IOError()
+#[error]
+record JsonParseError()
+#[json]
+record UserData(
+  id: int,
+  name: str,
+  roles: List[str]
+)
+fn parse_version(header: List[int]): result[Version, error] =
+  header.get(0) != nil ? v : error.InvalidHeaderLength(header.get(0))
+fn double_number(s: str): result[int] =
+  number_str.parse_int().map(|n| 2 * n)
+fn fetch_data(route: str): result[UserData] =
+  response := fetch(route)?
+  data := response.body.readAll()?
+  parse_json(data)?
+fn main(): result[int] =
+  double_number("10")?
+  version := parse_version(list.of(1, 2))
+  conn := pg.connect()?
+  match pg.connect()
+    ok(c) -> return 0
+    err(e) -> return e
+  res := fetch_data()
+  match res
+    ok(u) -> u.id
+    err(IOError(e)) -> printLn("IO failed")
+    err(e) -> printLn("generic error ${e.msg()}")
+  ok(0)
+```
 **constants**
 Constants can be declared at the top level of a program. They cannot be reassigned.
@@ -487,6 +557,10 @@ paint := Paint()
   ..color = Colors.black
   ..strokeCap = StrokeCap.round
   ..strokeWidth = 5.0
+v := list.of(1, 2, 3)
+  ..add(4, 5)
+  ..get(0)
 ```
 **variadic operator**
@@ -526,7 +600,6 @@ fn add[T: int | float](a: List[T], b: List[T]): List[T] =
 | Modules                  | snake_case              |
 | Types/Traits/Enum        | UpperCamelCase          |
 | Fields/Functions/Methods | lowerCamelCase          |
-| Conversion constructors  | from_some_other_type    |
 | Local variables          | snake_case              |
 | Constants                | SCREAMING_SNAKE_CASE    |
 | Generics                 | single uppercase letter |

scratch.pc CHANGED Viewed

@@ -1,8 +1,4 @@
 data.price?.take_if(|a| a != "")
-trait Iterator(
-  fun has_next(): Bool
-  fun next(): T?
-)
 trait HasEq[A](
   fn eq(that: a): bool
@@ -57,175 +53,11 @@ fn (l: list) prepend(v: V) =
   l.first() = link(v, l.first())
-fn range(start: int, e: int, cb: fn(int)) =
-  match start < end ->
-    cb(start)
-    range(start + 1, end, cb)
-fn repeat(n: int, cb: fn(int): void) =
-  match n != 0
-    cb()
-    repeat(n - 1, cb)
-fn repeat(cb: fn(int): void) =
-  cb()
-  repeat(cb)
-fn iterate[T](l: list[T], cb: fn(t: T)) =
-  pass
-fn main() =
-  repeat(10) |i|
-    println(i)
-  range(10, 20) |i|
-    println(i)
-```
-fn create_post_action(req: Request): Result[Response] =
-  post := Post(title = req.params.title, body = req.params.body)
-  if post.valid()
-    RenderNewView()
-  else
-    post := createRecord(post)
-    setSuccessMessage("Post created")
-    redirectTo("/posts")
-fn divide(dividend: u32, divisor: u32) !u32 =
-  if divisor == 0
-    error.DivideByZero
-  else
-    dividend / divisor
-error FileOpenError
-  | AccessDenied(str)
-  | OutOfMemory(str)
-  | FileNotFound(str)
-fn parse_version(header: List[int]): result[Version, error] =
-  header.get(0) != nil ? v : error.InvalidHeaderLength(header.get(0))
-fn main(): result[unit, unit] =
-  version := parse_version(list.of(1, 2))
-  match pg.connect()
-    ok(c) -> return 0
-    err(e) -> return e
-  greeting_file := file.open("hello.txt").unwrap_or_else() |error|
-    match error
-      ErrorKind::NotFound ->
-        File::create("hello.txt").unwrap_or_else() |error|
-          panic!("Problem creating the file: {:?}", error)
-      _ ->
-        panic!("Problem opening the file: {:?}", error)
-  conn := match pg.connect()?
-  create_post_action(req)
-    .map(|v| 0)
-    .map_err(|err| 1)
-  create_post_action(req)?
-  ok()
-  greeting_file := file.open("hello.txt")?
-  ok()
-import std/str
-import std/result
-fn double_number(s: str): result[i32, unit] =
-  number_str.parse_int().map(|n| 2 * n)
-fn main(): result<i32, unit> =
-  double_number("10")
-use std::num::ParseIntError;
-fn double_number(number_str: &str) -> Result<i32, ParseIntError> {
-    number_str.parse::<i32>().map(|n| 2 * n)
-}
-fn main() {
-    match double_number("10") {
-        Ok(n) => assert_eq!(n, 20),
-        Err(err) => printLn!("Error: {:?}", err),
-    }
-}
-trait error: debug + display (
-  fn description(): str
-  fn cause(): option<error>
-)
-trait From<T>(
-  fn from(v: T) -> Self;
-)
-trait Debug(
-  fn fmt(f: Formateer): result[unit, unit]
-)
-trait Display(
-  fn fmt(f: Formateer): result[unit, unit]
-)
-record Car(wheels: int)
-fn getWheels() =
-  returns 4
-fn main() =
-  let c1 = some(Car(wheels: 2))
-  let c2: option<Car> = none
-  let c1 = Some(Car(wheels: 2))
-  let c2: Option<Car> = None
-  match c
-    none -> print("no car")
-    some(car) -> car.getWheels()
-  Car c2 = null
-  c2.getWheels() // Null pointer
-```
 (1 + 2).mod(3).pow(2).sqrt()
-math.sqrt(math.pow(math.mod(1 + 2, 3)))
+math.sqrt(math.pow(math.mod(1 + 2, 3), 2))
-repeat(10) |i|
-  pass
-repeat(n) |i|
-  pass
-data.each() |k, v|
-  pass
-list.of(1, 2, 3).each() |v, i|
-  pass
-map.of("a" => 1, "b" => 2).each() |k, v|
-  pass
-repeat() |_|
-  pass
-repeat(|_| i < 9) |i|
-  pass
-repeat(|_| a > b && c < d) |i|
-  pass
-let v = list.of(1, 2, 3)
-  |> list.add(1, 2)
-  |> list.get(0)
-let v = list.of(1, 2, 3)
-  ..add(1, 2)
-  ..get(0)
-if v == nil
+if v == none
   error.Error
 else
   c * 20
@@ -241,20 +73,6 @@ match v
   Some(c) ->
     return c * 20
-#[json]
-record UserData(
-  id: int,
-  name: str,
-  roles: List[str]
-)
-`This is to follow the http standards
-trait Error(
-  fn code(): int
-  fn msg(): str
-)
 `derive implements this func
 `Derive is a compiler plugin/generator similar to dart
 `which runs automatically. Its not a macro more like a decorator.
@@ -267,18 +85,4 @@ type FetchDataError =  FetchError | IOError |  JsonParseError
 fn fetch_data(route: str): map[str, any] | UserData | FetchError | IOError |  JsonParseError =
   res := fetch(route)?
   data := res.body.read_all()?
-  parse_json(data)?
+  parse_json(data)?
-fn main() =
-  res := fetch_data()
-  if res is UserData
-    printLn("Success ${res.id}")
-  else if res is IOError
-    printLn("IO failed")
-  else if res is Error
-    printLn("generic error ${res.msg()}")
-  when res
-    UserData -> printLn("Success ${res.id}")
-    IOError -> printLn("IO failed")
-    _ -> printLn("generic error ${res.msg()}")

std/bool.mi CHANGED Viewed

@@ -1,6 +1,9 @@
 module std
+#[derive(Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
-type bool = true | false
+enum bool =
+  | true
+  | false
 fn (x: bool) op_eq(y: bool) = x == y
 fn (x: bool) op_ne(y: bool) = x != y

std/float.mi ADDED Viewed

File without changes

std/int.mi ADDED Viewed

File without changes

std/list.mi CHANGED Viewed

@@ -1,15 +1,15 @@
 module std
-`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](
+  `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
   head: node[V]?
   tail: node[V]?
   _size: int
 )
-`A node stores the data in a list and contains pointers to the previous and next sibling nodes
 record node[V](
+  `A node stores the data in a list and contains pointers to the previous and next sibling nodes
   value: V
   prev: node[V]?
   next: node[V]?

std/map.mi CHANGED Viewed

@@ -1,17 +1,17 @@
 module std
-record Pair[K: Comparable, V](k: K, v: V)
+record pair[K: Comparable, V](k: K, v: V)
+record map[K, 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]]
+  items: list[pair[K, V]]
 )
-fn Map.of[K, V](kvs: ...Pair[K, V]): map[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]) =
+fn (m: Map) add(kvs: ...pair[K, V]) =
   `adds the specified elements to the start of the list
   items.add(kvs)
@@ -28,7 +28,7 @@ fn (m: Map[K, V]) get(k K): V? =
   nil
 fn (m: Map) put(k K, v V) =
-  list.add(Pair(k, v))
+  list.add(pair(k, v))
 fn (m: Map) put_if(k K, v V) =
   if

std/math.mi CHANGED Viewed

@@ -72,6 +72,7 @@ fn acos(v: float) =
 `2**28
 const LARGE = 1 << 28
 fn acosh(v: float): float =
 	when
     x < 1 | IsNaN(x) -> // first case is special case

std/option.mi CHANGED Viewed

@@ -1,19 +1,30 @@
 module std
 enum option[T] =
+  `option is a type that represents either value present Some or nothing present
   | none
   | some(T)
+fn (o option[t]) isNone(): option[T] =
+  match o
+    none -> true
-enum Option<T> =
+    some(t) -> false
-  | None
+fn (o option[t]) isSome(): option[T] =
-  | Some(T)
+  !o.isNone()
 fn (o option[T]) get(): T =
   match o
     some(val) -> val
     none -> fail("called 'option.get()' on a 'none' value")
+fn (o option[T]) getOrElse(default: T): T =
+  `get if present otherwise return default value
+  match o
+    some(val) -> val
+    none -> d
-fn (o option[T: ToStr]) to_str(): str =
+fn (o option[T: ToStr]) toStr(): str =
   match o
     some(v) -> v.to_str()
     none -> "none"

std/os.mi CHANGED Viewed

@@ -1,5 +1,48 @@
 module std
-fn printLn(): result[unit, unit] =
+fn printLn(): IOError =
   `Writes the specified data, followed by the current line terminator, to the standard output stream.
-  pass
+  pass
+fn readFile(path: str): IO =
+  `Returns a stream to a file from the fs
+  pass
+fn writeFile(path: str, data: IO)
+  pass
+fn access(path[, mode])
+fn appendFile(path, data[, options])
+fn chmod(path, mode)
+fn chown(path, uid, gid)
+fn copyFile(src, dest[, mode])
+fn cp(src, dest[, options])
+fn lchmod(path, mode)
+fn lchown(path, uid, gid)
+fn lutimes(path, atime, mtime)
+fn link(existingPath, newPath)
+fn lstat(path[, options])
+fn mkdir(path[, options])
+fn mkdtemp(prefix[, options])
+fn open(path, flags[, mode])
+fn opendir(path[, options])
+fn readdir(path[, options])
+fn readFile(path[, options])
+fn readlink(path[, options])
+fn realpath(path[, options])
+fn rename(oldPath, newPath)
+fn rmdir(path[, options])
+fn rm(path[, options])
+fn stat(path[, options])
+fn statfs(path[, options])
+fn symlink(target, path[, type])
+fn truncate(path[, len])
+fn unlink(path)
+fn utimes(path, atime, mtime)
+fn watch(filename[, options])
+O_RDWR,
+O_CREAT,
+O_EXCL,

std/result.mi CHANGED Viewed

@@ -1,35 +1,31 @@
 module std
+trait Error(
-`result is a type that represents either success ok or failure err.
+  `This is used to represent an error value across the language
+  fn code(): int
+  fn msg(): str
-#[derive(Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
+  fn cause(): option<Error>
+)
 enum result[T]
+  `result is a type that represents either success ok or failure err.
   | ok(T)
-  | err(error)
+  | err(Error)
-fn (r result) is_ok(): bool =
+fn (r result) isOk(): bool =
   match o
     ok(v) -> return true
     err(e) -> return false
-fn (r result) is_err(): bool =
+fn (r result) isErr(): bool =
   !o.is_ok()
-fn (r result[T, E]) ok(): option[T] =
-  match o
-    ok(v) -> some(v)
-    err(e) -> none
-fn (r result[T, E]) err(): option[E] =
-  match o
-    ok(v) -> none
-    err(e) -> some(v)
 fn (r result) get(): T =
   match o
     ok(v) -> v
     err(e) -> panic("called `result.get()` on a `none` value")
-fn (r result) default(d: T): T =
+fn (r result) getOrElse(d: T): T =
   match o
     ok(v) -> v
     err(e) -> d
@@ -37,9 +33,9 @@ fn (r result) default(d: T): T =
 fn (r result) map(cb: fn(v: T)): result =
   match o
     ok(v) -> cb(v)
-    err(e) -> unreachable
+    err(e) -> r
-fn (r result) map_err(cb: fn(e: E)): result =
+fn (r result) mapErr(cb: fn(e: error)): result =
   match o
-    ok(v) -> unreachable
+    ok(v) -> r
-    err(e) -> cb(v)
+    err(e) -> cb(v)

std/str.mi CHANGED Viewed

@@ -1,14 +1,16 @@
 module std
-`ToStr defines any data that can be converted to a str
 trait ToStr(
+  `ToStr defines any data that can be converted to a str
   fn to_str(): str
 )
+record str(
-`A str is an array of contiguous data stored in memory with a null termination using hex 0x00 or ASCII 0x00.
+  `A str is an array of contiguous data stored in memory with a null termination using hex 0x00 or ASCII 0x00.
-`It is immutable and cannot be modified. It is copied for any changes and saved to a new memory location.
+  `It is immutable and cannot be modified. It is copied for any changes and saved to a new memory location.
-`The previous str is freed if its reference count is 0 within the block.
+  `The previous str is freed if its reference count is 0 within the block.
+  data: list[byte]
-record str(data: list[byte]): Comparable, ToStr
+): Comparable, ToStr
 fn str.of(bs ...byte): str =
   data.add(bs)

~repos /plum

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

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