plum

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

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

c725b923 — pyrossh

update

Files changed (5) hide show

readme.md +119 -55
std/list.mi +29 -0
std/map.mi +3 -1
std/option.mi +7 -31
std/result.mi +3 -81

readme.md CHANGED Viewed

@@ -133,14 +133,6 @@ for,while,if,else,record,enum,fn,assert,match,type
 ### Types
-```
-nil, any, err, bool, byte, int, float, dec, str, time, duration, regex, uuid
-[1, 2, 3] for lists      list[int], list[list[int]]
-[:a => 1, :b => 2] for maps       map[int], map[map[int]]
-? for optional    int? str?
-! for return error types int!, str!
-```
 **nil**
 The nil type is used to represent types that are nilable
@@ -149,6 +141,10 @@ 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**
+The err type is an enum of all errors
 **bool**
 A bool can be either `true` or `false`. It is used in logical operations and conditional statements.
@@ -190,6 +186,10 @@ An int is a signed 64 bit number. It can be represented in various ways,
 A float represents a 64-bit floating point (52-bit mantissa) IEEE-754-2008 binary64
+**dec**
+A decimal type represents BCD number. It has a mantissa and exponent.
 **str**
 A str represents an array of runes or unicode code points. It is encoded to UTF-8 by default.
@@ -255,6 +255,22 @@ friends_tree
   .reduce(0, |k, v| v + 1)
 ```
+**time**
+TBD
+**duration**
+TBD
+**regex**
+TBD
+**uuid**
+TBD
 **Constants**
 Constants can be declared at the top level of a program. They cannot be reassigned.
@@ -263,11 +279,11 @@ Constants can be declared at the top level of a program. They cannot be reassign
 - 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
+const PI = 3.14159f
-ERR_MESSAGE = "An unknown error occured"
+const ERR_MESSAGE = "An unknown error occured"
-COUNT = count(10)
+const COUNT = count(10)
-COUNTRIES_LIST = ["US", "INDIA", "CANADA"]
+const COUNTRIES_LIST = ["US", "INDIA", "CANADA"]
-COUNTRY_CODES = [
+const COUNTRY_CODES = [
   :in => "INDIA",
   :us => "United States",
   :ca => "Canada"
@@ -383,44 +399,6 @@ match xs
   [a] -> "This list has 1 element"
   [a, b] -> "This list has 2 elements"
   _ -> "This list has more than 2 elements"
-enum Option<T> =
-  | None
-  | Some(T)
-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
-  match c
-    none -> print("no car")
-    some(car) -> car.getWheels()
-fn (o option[T]) unwrap(): T =
-  match o
-    some(val) -> val
-    none -> fail("called `option.unwrap()` on a `none` value")
-fn (o option[T: ToStr]) display(): T =
-  match o
-    some(v) -> v.to_str()
-    none -> "none"
 ```
 Arithmetic (+, -, /, \*, @divFloor, @sqrt, @ceil, @log, etc.)
@@ -532,13 +510,99 @@ fn divide(dividend: u32, divisor: u32) !u32 =
     )
     BrokenPipe, ConnectionResetByPeer -> return false
     _ -> error_handler(req, res, err)
-```
+error FileOpenError
+  | AccessDenied(str)
+  | OutOfMemory(str)
-### Error handling
+  | 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")
-> Exceptions are used as both a way to model extra “return values” of functions and as a failure handling mechanism, leading them to be lousy at both. Exceptions suck. Thats why we don't have exceptions. - Sir Whinesalot
+use std::num::ParseIntError;
-We have mutiple return values to solve this similar to golang. And failures/panic need to exit/restart the app.
+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
+```
 ### General naming convention

std/list.mi CHANGED Viewed

@@ -177,3 +177,32 @@ fn (l: list) join(sep: str = ","): str =
     else
       res.write(@TypeToString(v), sep)
   res.to_str()
+enum list<T> =
+  | empty
+  | link(v: T, rest: list<T>)
+fn list.of[A](values: ...A): list[A] =
+  list[A]().add(values)
+fn (o list<T>) each(cb: fn(v: T)) =
+  match o
+    empty -> return
+    link(a, rest) ->
+      cb(a)
+      rest.each(cb)
+fn (l: list) append(values: ...V) =
+  `adds the specified elements to the start of the list
+  range(values) |v|
+    l.add(v)
+fn (l: list) append(v: V) =
+  `adds the specified elements to the start of the list
+  l.last().rest = link(v, empty)
+fn (l: list) prepend(v: V) =
+  `adds the specified elements to the start of the list
+  l.first() = link(v, l.first())

std/map.mi CHANGED Viewed

@@ -28,4 +28,6 @@ fn (m: Map) update() =
   pass
 fn (m: Map) update_if() =
-  pass
+  pass
+data.price?.take_if(|a| a != "")

std/option.mi CHANGED Viewed

@@ -4,40 +4,16 @@ enum option[T] =
   | none
   | some(T)
+enum Option<T> =
+  | None
+  | Some(T)
-fn (o Option[T]) unwrap(): T =
+fn (o option[T]) get(): T =
   match o
     some(val) -> val
-    none -> fail("called `option.unwrap()` on a `none` value")
+    none -> fail("called 'option.get()' on a 'none' value")
-fn (o option[T: ToStr]) display(): T =
+fn (o option[T: ToStr]) to_str(): str =
   match o
     some(v) -> v.to_str()
     none -> "none"
-enum list<T> =
-  | empty
-  | link(v: T, rest: list<T>)
-fn list.of[A](values: ...A): list[A] =
-  list[A]().add(values)
-fn (o list<T>) each(cb: fn(v: T)) =
-  match o
-    empty -> return
-    link(a, rest) ->
-      cb(a)
-      rest.each(cb)
-fn (l: list) append(values: ...V) =
-  `adds the specified elements to the start of the list
-  range(values) |v|
-    l.add(v)
-fn (l: list) append(v: V) =
-  `adds the specified elements to the start of the list
-  l.last().rest = link(v, empty)
-fn (l: list) prepend(v: V) =
-  `adds the specified elements to the start of the list
-  l.first() = link(v, l.first())

std/result.mi CHANGED Viewed

@@ -1,6 +1,6 @@
 module std
-`result` is a type that represents either success ([`ok`]) or failure ([`err`]).
+`result is a type that represents either success ok or failure err.
 #[derive(Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
 enum result[T, E]
   | ok(T)
@@ -27,7 +27,7 @@ fn (o result[T, E]) err(): option[E] =
 fn (o result) get(): T =
   match o
     ok(v) -> v
-    err(e) -> panic("called `option.unwrap()` on a `none` value")
+    err(e) -> panic("called `result.get()` on a `none` value")
 fn (o result) default(d: T): T =
   match o
@@ -42,82 +42,4 @@ fn (o result) map(cb: fn(v: T)): result =
 fn (o result) map_err(cb: fn(e: E)): result =
   match o
     ok(v) -> unreachable
-    err(e) -> cb(v)
+    err(e) -> cb(v)
-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]
-)
-data.price?.take_if(|a| a != "")
-put_if

~repos /plum

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

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