plum

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

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

66f4a645 — pyrossh

improve

Files changed (10) hide show

readme.md +81 -15
std/bool.mi +39 -9
std/coding/base64.mi +170 -0
std/http.mi +5 -5
std/map.mi +12 -0
std/math.mi +39 -27
std/option.mi +43 -0
std/ranges.mi +65 -8
std/result.mi +123 -0
std/str.mi +60 -62

readme.md CHANGED Viewed

@@ -1,34 +1,42 @@
 # 👾 Pacos Programming Language
-A simple, statically typed, imperative, minimalistic programming language. Its main aim to be simple and easy to code correct programs. It takes inspiration for golang, ponylang, and dart. It comes packed with linting, formatting, test runner, language server, and package management in-built.
+* A statically typed, functional programming language inspired by rust, koka.
+* The compiler users the tree-sitter parser so has out of the box syntax highlighting support for helix and zed editor.
+**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
+**Todo**
+linter, formatter, test runner, language server, package manager
-The compiler users the tree-sitter parser so has out of the box syntax highlighting support for helix and zed editor.
 Here is some sample code, please enjoy.
-```rb
+```go
 module lambda
 import pacos/list
 import pacos/math
 import pacos/http
-START_YEAR = 2101
+const START_YEAR = 2101
-END_YEAR = 2111
+const END_YEAR = 2111
-NAME = "Gleam"
+const NAME = "Gleam"
-SIZE = 100
+const SIZE = 100
 fn sum(a: int, b: int): int = a + b
 fn sum_all(series: list[int]): int =
   series.reduce(0, |v| v + 1)
-fn fib(n: int) -> int
+fn fib(n: int): int =
   match n
     0 | 1 -> n
     _ -> fib(n - 1) + fib(n - 2)
-fn fib(n: int) -> int
+fn fib(n: int): int =
   if n == 0 || n == 1
     n
   else
@@ -120,13 +128,13 @@ bench("1231") |n|
 **Keywords**
 ```rs
-for,while,if,else,record,enum,fn,assert,when,match,type
+for,while,if,else,record,enum,fn,assert,match,type
 ```
 ### Types
 ```
-nil, any, bool, byte, int, float, dec, str, time, duration, regex, uuid
+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?
@@ -199,10 +207,11 @@ println("Name ${name} age ${age}")
 ```py
 import pacos/list
-a := [1, 2, 3]                // list[int]
+a := list.of(1, 2, 3)                             # list[int]
-b := [[1, 2], [3, 4], [5, 6]] // list[list[int]]
+b := list.of(list.of(1), list.of(2), list.of(3))  # list[list[int]]
+c := list.of(1, 2, 3 * 4, 8, n)
-actors := ["Krabs", "Squidward"]
+actors := list.of("Krabs", "Squidward")
 actors.add("Spongebob")
 actors.length() // ==> 3
 actors.contains("Krabs") // ==> true
@@ -374,6 +383,44 @@ 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.)
@@ -464,7 +511,7 @@ fn add[T: int | float](a: List[T], b: List[T]): List[T] =
 ```
 ```
-fn create_post_action(req: Request): Response =
+fn create_post_action(req: Request): Result[Response] =
   post := Post(title = req.params.title, body = req.params.body)
   if post.valid()
     RenderNewView()
@@ -472,8 +519,27 @@ fn create_post_action(req: Request): Response =
     post := createRecord(post)
     setSuccessMessage("Post created")
     redirectTo("/posts")
+fn divide(dividend: u32, divisor: u32) !u32 =
+  if divisor == 0
+    error.DivideByZero
+  else
+    dividend / divisor
+  dispatch(action, req, res) catch |err|
+    BodyTooBig -> Response(
+      status: 431,
+      body: "Request body is too big",
+    )
+    BrokenPipe, ConnectionResetByPeer -> return false
+    _ -> error_handler(req, res, err)
 ```
+### Error handling
+> 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
+We have mutiple return values to solve this similar to golang. And failures/panic need to exit/restart the app.
 ### General naming convention
 | Item                    | Convention               |

std/bool.mi CHANGED Viewed

@@ -1,11 +1,41 @@
 module std
-type bool = true | false
+enum bool =
+  | true
-  fn op_eq(x: bool, y: bool) = x == y
+  | false
-  fn op_ne(x: bool, y: bool) = x != y
+fn (x: bool) op_ne(y: bool) = x != y
-  fn op_and(x: bool, y: bool) = x == false || y == false ? false : true
+fn (x: bool) op_and(y: bool) = x == false || y == false ? false : true
-  fn op_or(x: bool, y: bool) = x == true || y == true ? true : false
+fn (x: bool) op_or(y: bool) = x == true || y == true ? true : false
-  fn op_not(x: bool): bool = x == true ? false : true
+fn (x: bool) op_not(): bool = x == true ? false : true
-  #[ToStr]
-  fn to_str(x: bool) = x ? "true" : "false"
+fn (x: bool) to_str() = x ? "true" : "false"
+trait Iterator(
+  fun has_next(): Bool
+  fun next(): T?
+)
+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

std/coding/base64.mi ADDED Viewed

@@ -0,0 +1,170 @@
+module base64
+import std/collections
+import std/testing/assert
+fun encode_pem(data: ReadSeq[U8]): str =
+  `Encode for PEM (RFC 1421)
+  encode(data, '+', '/', '=', 64)
+fun encode_mime(data: ReadSeq[U8]): str =
+  `Encode for MIME (RFC 2045)
+  encode(data, '+', '/', '=', 76)
+fun encode_url[A: Seq[U8]](data: ReadSeq[U8], pad: Bool = false): A =
+  `Encode for URLs (RFC 4648). Padding characters are stripped by default
+  c := pad ? '=' else 0
+  encode[A](data, '-', '_', c)
+fun encode[A: Seq[U8]](data: ReadSeq[U8], at62: U8 = '+', at63: U8 = '/', pad: U8 = '=', linelen: USize = 0, linesep: str = "\r\n"): A =
+  `Configurable encoding. The defaults are for RFC 4648.
+  len := ((data.size() + 2) / 3) * 4
+  out := recover A(len) end
+  lineblocks := linelen / 4
+  srclen := data.size()
+  blocks := USize(0)
+  i := USize(0)
+  try
+    while srclen >= 3 do
+      let in1 = data(i)?
+      let in2 = data(i + 1)?
+      let in3 = data(i + 2)?
+      let out1 = in1 >> 2
+      let out2 = ((in1 and 0x03) << 4) + (in2 >> 4)
+      let out3 = ((in2 and 0x0f) << 2) + (in3 >> 6)
+      let out4 = in3 and 0x3f
+      out.push(_enc_byte(out1, at62, at63)?)
+      out.push(_enc_byte(out2, at62, at63)?)
+      out.push(_enc_byte(out3, at62, at63)?)
+      out.push(_enc_byte(out4, at62, at63)?)
+      i = i + 3
+      blocks = blocks + 1
+      srclen = srclen - 3
+      if (lineblocks > 0) and (blocks == lineblocks) then
+        out.append(linesep)
+        blocks = 0
+      end
+    end
+    if srclen >= 1 then
+      let in1 = data(i)?
+      let in2 = if srclen == 2 then data(i + 1)? else 0 end
+      let out1 = in1 >> 2
+      let out2 = ((in1 and 0x03) << 4) + (in2 >> 4)
+      let out3 = (in2 and 0x0f) << 2
+      out.push(_enc_byte(out1, at62, at63)?)
+      out.push(_enc_byte(out2, at62, at63)?)
+      if srclen == 2 then
+        out.push(_enc_byte(out3, at62, at63)?)
+      else
+        out.push(pad)
+      end
+      out.push(pad)
+    end
+    if lineblocks > 0 then
+      out.append(linesep)
+    end
+  else
+    out.clear()
+  end
+  out
+fun decode_url[A: Seq[U8] iso = Array[U8] iso](data: ReadSeq[U8]): A^ ? =>
+  """
+  Decode for URLs (RFC 4648).
+  """
+  decode[A](data, '-', '_')?
+fun decode[A: Seq[U8] iso = Array[U8] iso](
+  data: ReadSeq[U8],
+  at62: U8 = '+',
+  at63: U8 = '/',
+  pad: U8 = '=')
+  : A^ ?
+=>
+  """
+  Configurable decoding. The defaults are for RFC 4648. Missing padding is
+  not an error. Non-base64 data, other than whitespace (which can appear at
+  any time), is an error.
+  """
+  let len = (data.size() * 4) / 3
+  let out = recover A(len) end
+  var state = U8(0)
+  var input = U8(0)
+  var output = U8(0)
+  for i in Range(0, data.size()) do
+    input = data(i)?
+    let value =
+      match input
+      | ' ' | '\t' | '\r' | '\n' => continue
+      | pad => break
+      | at62 => 62
+      | at63 => 63
+      | if (input >= 'A') and (input <= 'Z') =>
+        (input - 'A')
+      | if (input >= 'a') and (input <= 'z') =>
+        ((input - 'a') + 26)
+      | if (input >= '0') and (input <= '9') =>
+        ((input - '0') + 52)
+      else
+        error
+      end
+    match state
+    | 0 =>
+      output = value << 2
+      state = 1
+    | 1 =>
+      out.push(output or (value >> 4))
+      output = (value and 0x0f) << 4
+      state = 2
+    | 2 =>
+      out.push(output or (value >> 2))
+      output = (value and 0x03) << 6
+      state = 3
+    | 3 =>
+      out.push(output or value)
+      state = 0
+    else
+      error
+    end
+  end
+  if output != 0 then
+    Fact(input != pad)?
+    match state
+    | 1 | 2 => out.push(output)
+    end
+  end
+  out
+fun _enc_byte(i: U8, at62: U8, at63: U8): U8 ? =>
+  """
+  Encode a single byte.
+  """
+  match i
+  | 62 => at62
+  | 63 => at63
+  | if i < 26 => 'A' + i
+  | if i < 52 => ('a' - 26) + i
+  | if i < 62 => ('0' - 52) + i
+  else
+    error
+  end

std/http.mi CHANGED Viewed

@@ -2,17 +2,17 @@ import std/path
 import std/os
 import http/content_type
-fn file_response(file: str) =
+fn file_response(file: str): Response! =
   ext := path::ext(file)
   content := content_type::from_ext(ext)
   data := try os.read_file(file)
   Response(
-    status = 200,
+    status: 200,
-    headers = [
+    headers: map.of(
       "Content-Type" => content,
       "Content-Length" => "2"
-    ],
+    ),
-    body = data
+    body: data
   )
   Response()

std/map.mi CHANGED Viewed

@@ -17,3 +17,15 @@ fn (m: map) add(kvs: ...Pair[K, V]) =
 fn (m: Map) op_range() =
   yield k, v
+fn (m: Map) put() =
+  pass
+fn (m: Map) put_if() =
+  pass
+fn (m: Map) update() =
+  pass
+fn (m: Map) update_if() =
+  pass

std/math.mi CHANGED Viewed

@@ -1,23 +1,41 @@
 module math
-E = 2.718f       // Represents Euler's number, the base of natural logarithms, e
+`Euler's number, the base of natural logarithms, e
+const E = 2.718f
-LN10 = 2.302f    // Represents the natural logarithm of 10
+`The natural logarithm of 10
+const LN10 = 2.302f
-LN2 = 0.693f     // Represents the natural logarithm of 2
+`The natural logarithm of 2
+const LN2 = 0.693f
-LOG10E = 0.434f  // Represents the base 10 logarithm of e
+`The base 10 logarithm of e
+const LOG10E = 0.434f
-LOG2E = 1.442f   // Represents the base 2 logarithm of e
+`The base 2 logarithm of e
+const LOG2E = 1.442f
-PI = 3.14159f    // Represents the ratio of the circumference of a circle to its diameter
+`The ratio of the circumference of a circle to its diameter
+const PI = 3.14159f
-SQRT1_2 = 0.707f // Represents the square root of 1/2
+`The square root of 1/2
+const SQRT1_2 = 0.707f
-SQRT2 = 1.414f   // Represents the square root of 2
+`The square root of 2
+const SQRT2 = 1.414f
-EPSILON = 2.220446049250313e-16f // Represents the difference between 1 and the smallest floating point number greater than 1
+`The difference between 1 and the smallest floating point number greater than 1
-MAX_SAFE_INTEGER
+const EPSILON = 2.220446049250313e-16f
-MAX_VALUE
-MIN_SAFE_INTEGER
-MIN_VALUE
-NEGATIVE_INFINITY
+`Lowest valur of i64
+const MIN_INT_VALUE = -0x8000_0000_0000_0000
-POSITIVE_INFINITY
+`Highest valur of i64
+const MAX_INT_VALUE = 0x7FFF_FFFF_FFFF_FFFF
+fn abs(v: float): float =
-// Returns the absolute value of a number
+  `returns the absolute value of a number v
-fn abs(v: float): float = a < 0 ? -a : a
+  a < 0 ? -a : a
 fn acos(v: float) =
   if v < 0.1
@@ -47,11 +65,10 @@ fn random(): float =
 fn is_int(): bool =
   pass
-// Check whether this number is finite, ie not +/-infinity and not NaN.
 fn is_finite(): bool = true
+  ` Check whether this number is finite, ie not +/-infinity and not NaN.
-  // True if exponent is not all 1s
+  ` True if exponent is not all 1s
-  // (bits() and 0x7FF0_0000_0000_0000) != 0x7FF0_0000_0000_0000
+  (bits() and 0x7FF0_0000_0000_0000) != 0x7FF0_0000_0000_0000
 // Check whether this number is +/-infinity
 is_infinite:  Bool =>
@@ -98,11 +115,6 @@ fun sqrt(): F64 =>
     @"llvm.sqrt.f64"(this)
   end
-MIN_INT_VALUE = 0
-MAX_INT_VALUE = 0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF
-fn min_value() => -0x8000_0000_0000_0000
-fn max_value() => 0x7FFF_FFFF_FFFF_FFFF
 fn abs(a: int): int => a < 0 ? -a : a
 fn to_str(v: int): str = ""

std/option.mi ADDED Viewed

@@ -0,0 +1,43 @@
+module std
+enum option[T] =
+  | none
+  | some(T)
+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"
+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/ranges.mi CHANGED Viewed

@@ -1,18 +1,75 @@
 fn range(start: int, e: int, cb: fn(int)) =
-  if (start < end):
+  match start < end ->
     cb(start)
     range(start + 1, end, cb)
-  elif (start > end):
-    cb(start)
-    range(start - 1, end, cb)
-fn repeat(n: int, cb: fn(int)) =
+fn repeat(n: int, cb: fn(int): void) =
-  if n != 0:
+  match n != 0
-    cb(n)
+    cb()
-    repeat(n-1, 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)
+  //support unocss
+  html(class: "123") |_|
+    head() |_|
+      title("name")
+      link(href: "123")
+    body(class: "bg-white") |_|
+      div(class: "132") |_|
+        text("Hello")
+      div()
+  html(class: "123") {
+    head() {
+      title("name")
+      link(href: "123")
+    }
+    body(class: "class") {
+      div(class: "132") {
+        text("Hello")
+      }
+    }
+  }
+  `kotlin
+  html("lang": "en") {
+    head {
+      meta("charset": "UTF-8")
+      title {
+        text("Kotlin HTML DSL")
+      }
+    }
+    body {
+      h1 {
+        text("Hello, World!")
+      }
+    }
+  }
+  `dart
+  Html(
+    class: "123",
+    head: list.of(
+      titl("name")
+      link(href: "123")
+    ),
+    body: list.of(
+        div(class: "class", list.of(
+          text("Hello")
+        ),
+      )
+    )
+  )

std/result.mi ADDED Viewed

@@ -0,0 +1,123 @@
+module std
+`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)
+  | err(E)
+fn (o result) is_ok(): bool =
+  match o
+    ok(v) -> return true
+    err(e) -> return false
+fn (o result) is_err(): bool =
+  !o.is_ok()
+fn (o result[T, E]) ok(): option[T] =
+  match o
+    ok(v) -> some(v)
+    err(e) -> none
+fn (o result[T, E]) err(): option[E] =
+  match o
+    ok(v) -> none
+    err(e) -> some(v)
+fn (o result) get(): T =
+  match o
+    ok(v) -> v
+    err(e) -> panic("called `option.unwrap()` on a `none` value")
+fn (o result) default(d: T): T =
+  match o
+    ok(v) -> v
+    err(e) -> d
+fn (o result) map(cb: fn(v: T)): result =
+  match o
+    ok(v) -> cb(v)
+    err(e) -> unreachable
+fn (o result) map_err(cb: fn(e: E)): result =
+  match o
+    ok(v) -> unreachable
+    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

std/str.mi CHANGED Viewed

@@ -1,18 +1,17 @@
 module std
-// Trait ToStr defines any data that can be converted to a str
+`ToStr defines any data that can be converted to a str
-trait ToStr
+trait ToStr(
   fn to_str(): 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.
-struct str(_ptr: *u8) : Comparable, ToStr
+record str(data: list[byte]): Comparable, ToStr
-new (s str) create(ptr: *u8) =
+fn str.of(bs ...byte): str =
-  // TODO: have a check in dev builds to throw an error if not null terminated
-  // to prevent undefined behavior
-  _ptr = ptr
+  data.add(bs)
 fn (s str) get(i: int) =
   data[i]
@@ -50,10 +49,9 @@ fn (t BTree) delete(key str): bool =
 		return true
 	return false
-fn (s str) Comparable::starts_with(search: str): bool =
+fn (s str) starts_with(search: str): bool =
   pass
 fn (s str) concat(other: str): str =
   s + other
@@ -83,69 +81,69 @@ fn (s str) match_all(pattern: Regex): []str =
 fn (s str) pad_start(sub: str, count: int): str =
   pass
-  fn pad_end(sub: str, count: int): str =
+fn (s str) pad_end(sub: str, count: int): str =
-    pass
+  pass
-  fn repeat(count: int): str =
-    pass
-  fn replace(pattern: Regex, sub: str): str =
-    pass
-  fn replace_all(pattern: Regex, sub: str): str =
-    pass
-  fn search(pattern: Regex): str =
+fn (s str) repeat(count: int): str =
-    pass
+  pass
-  fn slice(start: int, end: int): str =
+fn (s str) replace(pattern: Regex, sub: str): str =
-    pass
+  pass
-  fn split(separator: str, limit: int): []str =
+fn (s str) replace_all(pattern: Regex, sub: str): str =
-    pass
+  pass
-  fn sub(start: int, end: int): str =
+fn (s str) search(pattern: Regex): str =
-    pass
+  pass
-  fn to_lower(): str =
+fn slice(start: int, end: int): str =
-    pass
+  pass
-  fn to_upper(): str =
+fn split(separator: str, limit: int): []str =
-    pass
+  pass
-  fn trim(): str =
+fn sub(start: int, end: int): str =
-    pass
+  pass
-  fn trim_start(): str =
+fn to_lower(): str =
-    pass
+  pass
-  fn trim_end(): str =
+fn to_upper(): str =
-    pass
+  pass
-  fn reverse(): str
+fn trim(): str =
-    """reverses a str
-    start := 0
-    end := length - 1
-    result := []
-    while start < end
-      const temp = data[start]
-      result[start] = data[end]
-      result[end] = temp
-      end = end - 1
-      start = start + 1
-    result
+  pass
-  fn parse_int(): int! =
+fn trim_start(): str =
-    0
+  pass
-  fn parse_float(): float! =
+fn trim_end(): str =
-    0.0
+  pass
+fn reverse(): str
+  """reverses a str
+  start := 0
+  end := length - 1
+  result := []
+  while start < end
+    const temp = data[start]
+    result[start] = data[end]
+    result[end] = temp
+    end = end - 1
+    start = start + 1
+  result
+fn parse_int(): int! =
+  0
+fn parse_float(): float! =
+  0.0
-  fn parse_bool(): bool! =
+fn parse_bool(): bool! =
-    match to_lower()
+  match to_lower()
-      "true" -> bool::true
+    "true" -> bool::true
-      "false" -> bool::false
+    "false" -> bool::false
-      _ -> error("could not parse bool '${this}'")
+    _ -> error("could not parse bool '${this}'")
 _.camelCase

~repos /plum

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

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