plum

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

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

6a5b4e28 — pyrossh

increment spec

Files changed (13) hide show

example/fn.mi +306 -0
example/fn.palm +0 -300
example/std/bool.mi +7 -6
example/std/buffer.mi +0 -0
example/std/http.mi +83 -0
example/std/int.mi +0 -28
example/std/list.mi +33 -29
example/std/map.mi +9 -14
example/std/math.mi +22 -1
example/std/ranges.mi +18 -0
example/std/str.mi +81 -24
public/index.html +47 -0
public/llama.png +0 -0

example/fn.mi ADDED Viewed

@@ -0,0 +1,306 @@
+module lambda
+Sample syntax
+```
+fun sum(a: int, b: int): int = a + b
+fn sum_list(series: list[int]): int =
+  series.reduce(0, |v| v + 1)
+fn fib(n: int): int =
+  match n
+    0 | 1 -> n
+    else -> fib(n - 1) + fib(n - 2)
+fn fib(n: int): int =
+  if n == 0 || n == 1 then
+    n
+  else
+    fib(n - 1) + fib(n - 2)
+  end
+fn factorial(n: int): int =
+  match n
+    1 -> 1
+    _ -> n * factorial(n - 1)
+fn to-celsius(f: float) =
+  (f - 32) * (5 / 9)
+record Cat(
+  name: str
+  age:  int
+)
+fn (c: Cat) fullname(): str =
+  c.name + c.age.to_str()
+fn (c: Cat) to_str(): str =
+  "Cat<{c.fullname()}>"
+test("Cat", |v|
+  c := Cat(name = "123", age = 1)
+  c.talk()
+  Cat("rabby", 21).fullname() == "rabby21"
+  c2 := Cat(...c, age: c.age + 1)
+  [Cat("Molly", 9), Cat("Fenton", 6)]
+    .retain(|p| p.name.size > 5)
+    .map(|p| describe(p))
+    .each(|d| println(d))
+  // → cat Fenton is 6 years of age
+)
+type MapCallback = fn(v: a): v
+trait Comparable[A](
+  fn compare(left: A, right: A): bool
+)
+trait ToStr(
+  fn to_str(): str
+)
+struct Cat(name: str, age: int) =
+  fn fullname() =
+    name + age.str()
+  fn talk() =
+    println("cat ${name} says meow")
+  #[ToStr]
+  fn to_str(self): str =
+    "Cat<{self.fullname()}>"
+enum Temperature =
+  | celsius(float)
+  | fahrenheit(float)
+fn (s Temperature) to_str() =
+  match s
+    celsius(t) && t > 30 -> "${t}C is above 30 celsius"
+    celsius(t) -> "${t}C is below 30 celsius"
+    fahrenheit(t) && t > 86 -> "${t}F is above 86 fahrenheit"
+    fahrenheit(t) -> "${t}F is below 86 fahrenheit"
+test "enum ordinal value" {
+  expect(Value.zero).to_equal(0);
+  expect(Value.one).to_equal(1);
+  expect(Value.two).to_equal(2);
+}
+test("enum ordinal value") |t| {
+  expect(Value.zero).to_equal(0);
+  expect(Value.one).to_equal(1);
+  expect(Value.two).to_equal(2);
+}
+group("Group 1") |g| {
+}
+bench("1231") |t, n| {
+}
+```
+## Language Reference
+**Keywords**
+unreachable
+**Types**
+bool, byte, int, float, dec, str, time, duration
+[] for lists      list[int], list[list[int]]
+[] for maps       map[int], map[map[int]]
+? for optional    int? str?
+! for return error types int!, str!
+nil for optional assignment and pointers
+## Types
+**nil**
+A nil type is used to represent types that are nilable.
+**bool**
+A bool can be either `true` or `false`. It is used in logical operations and conditional statements.
+```
+assert true != false
+if true || false:
+  print("works")
+```
+**byte**
+A byte represents an unsigned 8 bit number. It is mainly used to represent strings and binary data.
+```
+let data: []byte?
+data = [104, 101, 197, 130, 197, 130, 111, 0]
+```
+**int**
+An int is a signed 64 bit number. It can be represented in various ways,
+0b - Binary (Base 2)
+0x - Hexadecimal (Base 16)
+13 - Standard (Base 10)
+```
+0b00101010
+0b1_1111_1
+0xff00ff
+0xFF00FF
+0xFF80_0000_0000_0000
+98762
+1_000_000
+```
+**float**
+A float represents a 64-bit floating point (52-bit mantissa) IEEE-754-2008 binary64
+**str**
+A str represents a slice of runes or unicode code points. It is encoded to UTF-8 by default.
+It supports interpolation of variables/values that implement the ToStr interface.
+```
+"Hello World"
+name := "Pacos"
+age := 1
+println("Name ${name} age ${age}")
+```
+"\u0061" == "a"
+**list**
+```
+a := [1, 2, 3]
+```
+**map**
+```
+tree = [
+  value: "Fred",
+  left: [
+    value: "Jim",
+  ],
+  right: [
+    value: "Shiela",
+    left: [
+      value: "Alice",
+    },
+    right: [
+      value: "Bob"
+    ],
+  ],
+]
+```
+**Assignment operator**
+low, mid, high := 0, 0, n.numItems
+x := 10
+y := 20
+xy_list := [x, y]
+xy_map := [x: x, y: y]
+assoc_list = [a: 1, b: 2]
+assoc_list[:a]
+assoc_list["b"]
+**While statement**
+while low < high
+  mid = (low + high) / 2
+  low = cmp > 0 > mid + 1 : low
+  high = cmp < 0 ? mid : high
+  if cmp == 0
+    return mid, true
+while (i < 10) : (i += 1) {}
+while (eventuallyErrorSequence()) |value| {
+  sum1 += value;
+else |err|
+  try expect(err == error.ReachedZero);
+**For statement**
+for players_list |value|
+  if value == 0
+    continue
+  sum += value
+for items[0..1] |v|
+  sum += v
+for 0..5 |v|
+  sum3 += v
+let list = for filter(players_list) |v|
+items
+  .map(|v| v + 1)
+  .each(|v| println("v", v))
+items
+  .each(v =>
+    if v == 2
+      break
+    if v == 0
+      continue
+    println(v)
+  )
+  .map {v => v * 2}
+  .reduce(0, |v| => v + 1)
+fn range(start: int, end: int, cb: (v: T) -> IterateResult) =
+range(0, 5, |v| =>
+  sum3 += v
+)
+// Iterate over multiple objects.
+// All lengths must be equal at the start of the loop, otherwise detectable
+// illegal behavior occurs.
+for items, items2 |i, j|
+  count += i + j
+**When expression/statement**
+when
+  cmp > 0 -> low = mid + 1
+  cmp < 0 -> high = mid
+  cmp == 0 -> return mid, true
+Arithmetic (+, -, /, *, @divFloor, @sqrt, @ceil, @log, etc.)
+Bitwise operators (>>, <<, &, |, ~, etc.)
+Comparison operators (<, >, ==, etc.)
+**if expression/statement**
+if (a) |value| {
+ try expect(value == 0);
+} else |err| {
+    _ = err;
+    unreachable;
+}
+### 5. Conditional operators
+**not operator**
+!a
+!true
+**ternary operator**
+x ? x : y
+**safe navigation operator**
+a?.b?.c?.d
+**elvis operator**
+x ?: y
+**elvis assignment operator**
+atomicNumber ?= 2
+**Range operator**
+for 5..10 |i|:
+**Safe index operator**
+array?[1]

example/fn.palm DELETED Viewed

@@ -1,300 +0,0 @@
-module lambda
-// binary, bool, int, float, str, decimal, time
-// [] for slices     []int []str
-// {} for maps       [int]int [str]str
-// ? for optional    int? str?
-// ! for error types int!, str!
-// nil for optional assignment
-// 2.0
-//  |> math.sqrt()
-//  |> math.log()
-//  |> math.round()
-alias MapCallback = fn(v: a): v
-trait Comparable<a> =
-  fn compare(left: a, right: a): bool
-enum Temperature(celsius(float) | fahrenheit(float)) =
-  fn str(self) =
-    match self
-      Temperature::celsius(t) && t > 30 -> "${t}C is above 30 celsius"
-      Temperature::celsius(t) -> "${t}C is below 30 celsius"
-      Temperature::fahrenheit(t) && t > 86 -> "${t}F is above 86 fahrenheit"
-      Temperature::fahrenheit(t) -> "${t}F is below 86 fahrenheit"
-struct Cat(name: str, age: int) =
-  fn fullname() =
-    name + age.str()
-  fn talk() =
-    println("cat ${name} says meow")
-  test "Cat" =
-    c = Cat(name = "123", age = 1)
-    c.talk()
-    Cat("rabby", 21).fullname() == "rabby21"
-fn fib(n: int): int =
-  match n
-    0 | 1 -> n
-    else -> fib(n - 1) + fib(n - 2)
-fn factorial(n: int): int =
-  match n
-    1 -> 1
-    _ -> n * factorial(n - 1)
-fn to-celsius(f: float) =
-  (f - 32) * (5 / 9)
-fn repeat(n: int, cb: fn(int)) =
-  if n != 0:
-    cb(n)
-    repeat(n-1, cb)
-fn range(start: int, e: int, cb: fn(int)) =
-  if (start < end):
-    cb(start)
-    range(start + 1, end, cb)
-  elif (start > end):
-    cb(start)
-    range(start - 1, end, cb)
-fn main() =
-  repeat(10) |i|
-    println(i)
-  range(10, 20) |i|
-    println(i)
-/// Http similar to rocket
-/// GET,DELETE Request -> fn params are got from query
-/// POST,PUT,PATCH Request -> fn params got from multi part form body
-/// DI at compiler level
-/// Controller similar to IHP
-#[path("/counters")]
-@path("/counters")
-struct CounterController(db: DB)
-  static path = "/counters"
-  fn all(): HttpResponse =
-    counters := db.query(Counter).fetchAll()
-    render(CounterList(counters))
-  fn view() =
-    counter := fetchOne(Counter) ?? createOne(Counter)
-    if counter := fetchOne(Counter)
-      render CounterView(counter)
-    else
-      counter <- newRecord @Counter |> set #count 0 |> createRecord
-      render CounterView(counter)
-  fn increment(id: str) =
-    counter <- fetch counterId
-    updatedCounter <- counter |> incrementField #count |> updateRecord
-    respondHtml $ counterView updatedCounter
-  fn decrement(id: str) =
-    counter <- fetch counterId
-    updatedCounter <- counter |> decrementField #count |> updateRecord
-    respondHtml $ counterView updatedCounter
-module palm
-primitive int is Stringable {
-  fn add(y: int) {
-    @"llvm.uadd.with.overflow.i32"(this, y)
-  }
-  fn sub() {
-  }
-  fn minus() {
-  }
-  fn str() {
-    if (this == 0) {
-      return "0";
-    }
-    let result = str(31)
-    let i = 0
-    let num = this
-    while (num != 0) {
-        const rem = num % 10
-        result.push((rem > 9) ? (rem - 10) + 'a' : rem + '0')
-        num = num / 10
-    }
-    if (this < 0) {
-      result.push("-")
-    }
-    return result.reverse()
-  }
-  // fn str() {
-  //   ipart = (int)n
-  //   fpart = n - (float)ipart
-  //      // convert integer part to string
-  //   int i = intToStr(ipart, res, 0)
-  //   // check for display option after point
-  //   if (afterpoint != 0) {
-  //       res[i] = '.'; // add dot
-  //       // Get the value of fraction part upto given no.
-  //       // of points after dot. The third parameter
-  //       // is needed to handle cases like 233.007
-  //       fpart = fpart * pow(10, afterpoint);
-  //       intToStr((int)fpart, res + i + 1, afterpoint);
-  //   }
-  // }
-}
-entity decimal {
-  mantissa: int
-  exponent: float
-}
-enum List
-  | first
-  | link(first: a, rest: List<a>)
-  fn sum():
-    case this:
-      | first => 0
-      | link(a, res) => a + sum(res)
-    end
-  end
-end
-enitity List<a> {
-  data: Pointer
-  length: int
-  fn construct(items ...a) {
-    repeat(items) |item| {
-      data.alloc(item)
-    }
-  }
-}
-enum List<a> {
-  first
-  link(first: a, rest: List<a>)
-  fn op_brackets(items ...a) {
-    l = link(items[0])
-    range(items.length-2) |i| {
-      l.rest = link(items[i+1])
-    }
-    return l
-  }
-  fn sum() {
-    match this {
-      first => 0
-      link(a, res) => a + sum(res)
-    }
-  }
-}
-test("List") |t| {
-  fn sum(l: List<int>) int {
-    return l.reduce(|it| it.value, 0)
-  }
-  sum(empty) is 0
-  sum(link(1, link(2, link(3, empty)))) is 6
-  sum([1, 2, 3]) is 6
-}
-enum Tree<a> {
-  leaf
-  node(value: a, left: Tree<a>, right: Tree<a>)
-}
-fn main() int {
-  repeat(10) |i| {
-    println(i)
-  }
-  range(10, 20) |i| {
-    println(i)
-  }
-}
-// fn decrement() {
-//   println("decrementing")
-//   Cat(...c, age: c.age + 1)
-// }
-// fn add(x: Int, y: Int) -> Int {
-//   x + y
-// }
-// list
-//   .map(|it| it + 1)
-//   .each(|_| println("it", it))
-// test "enum ordinal value" {
-//   expect(Value.zero).to_equal(0);
-//   expect(Value.one).to_equal(1);
-//   expect(Value.two).to_equal(2);
-// }
-// test("enum ordinal value") |t| {
-//   expect(Value.zero).to_equal(0);
-//   expect(Value.one).to_equal(1);
-//   expect(Value.two).to_equal(2);
-// }
-// group("Group 1") |g| {
-//   test("Test 1") |t| {
-//   }
-// }
-// bench("1231") |t, n| {
-// }
-// tree = {
-//   value: "Fred",
-//   left: {
-//     value: "Jim",
-//   },
-//   right: {
-//     value: "Shiela",
-//     left: {
-//       value: "Alice",
-//     },
-//     right: {
-//       value: "Bob"
-//     },
-//   },
-// }
-// Node "Fred" (Node "Jim" Leaf Leaf)
-//                 (Node "Sheila" (Node "Alice" Leaf Leaf)
-//                       (Node "Bob" Leaf  Leaf))
-fun sum(a: Int64, b: Int64): Int64 = a + b
-fun describe(pet: Pet): String = if pet
-  ... is Cat(let name, let lives) { "cat $name has $lives lives" }
-  ... is Dog(let name, let years) { "dog $name is $years of age" }
-List(Cat("Molly", 9), Dog("Fenton", 6))
-  .retain(|p| p.name.size > 5)
-  .map   (|p| describe(p))
-  .each  (|d| println(d))
-// → dog Fenton is 6 years of age

example/std/bool.mi CHANGED Viewed

@@ -1,10 +1,11 @@
 module std
-enum bool is (true | false) =
+type bool = true | false
   fn op_eq(x: bool, y: bool) = x == y
   fn op_ne(x: bool, y: bool) = x != y
-  fn op_and(x: bool, y: bool) = x && y
+  fn op_and(x: bool, y: bool) = x == false || y == false ? false : true
-  fn op_or(x: bool, y: bool) = x || y
+  fn op_or(x: bool, y: bool) = x == true || y == true ? true : false
-  fn op_xor(x: bool, y: bool) = x <> y
+  fn op_not(x: bool): bool = x == true ? false : true
-  fn op_not(x: bool,): bool = !x
+  #[ToStr]
-  fn str(x: bool) = x ? "true" : "false"
+  fn to_str(x: bool) = x ? "true" : "false"

example/std/buffer.mi DELETED Viewed

File without changes

example/std/http.mi ADDED Viewed

@@ -0,0 +1,83 @@
+import std/path
+import std/os
+import http/content_type
+fn file_response(file: str) =
+  ext := path::ext(file)
+  content := content_type::from_ext(ext)
+  data := try os.read_file(file)
+  Response(
+    header("Content-Type", content)
+    header("Content-Length", "2")
+    body(data)
+    status(200)
+  )
+  Response(
+    status = 200
+    header = [
+      Content-Type: content,
+      Content-Length: "2"
+    ]
+    body = data
+  )
+  Response::build()
+    .header("Content-Type", content)
+    .header("Content-Length", "2")
+    .body(data)
+    .status(200)
+  response.new(200)
+  |> response.header("Content-Type", content)
+  |> response.body(data)
+#[get("/")]
+fn index(): Response! =
+  file_response("index.html")
+#[get("/public/<...>")]
+fn public(file: str): Response! =
+  ext := path::ext(file)
+  content := content_type::from_ext(ext)
+  data := try os.read_file(file)
+  Response(
+    status: 200,
+    headers: [
+      ContentType: content,
+    ],
+    body: data,
+  )
+/// Http similar to rocket
+/// GET,DELETE Request -> fn params are got from query
+/// POST,PUT,PATCH Request -> fn params got from multi part form body
+/// DI at compiler level
+/// Controller similar to IHP
+#[path("/counters")]
+record CounterController(db: DB)
+  static path = "/counters"
+  fn all(): HttpResponse =
+    counters := db.query(Counter).fetchAll()
+    render(CounterList(counters))
+  fn view() =
+    counter := fetchOne(Counter) ?? createOne(Counter)
+    if counter := fetchOne(Counter)
+      render CounterView(counter)
+    else
+      counter <- newRecord @Counter |> set #count 0 |> createRecord
+      render CounterView(counter)
+  fn increment(id: str) =
+    counter <- fetch counterId
+    updatedCounter <- counter |> incrementField #count |> updateRecord
+    respondHtml $ counterView updatedCounter
+  fn decrement(id: str) =
+    counter <- fetch counterId
+    updatedCounter <- counter |> decrementField #count |> updateRecord
+    respondHtml $ counterView updatedCounter

example/std/int.mi DELETED Viewed

@@ -1,28 +0,0 @@
-module std
-primitive int =
-  MIN_VALUE = 0
-  MAX_VALUE = 0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF
-  fn random(): int =
-    0
-  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 = ""
-  fn op_add(x: int, y: int): int =
-    @"i64.add"(x, y)
-    sub
-    mul
-    div
-    rem
-    min
-    max
-    to_float()

example/std/list.mi CHANGED Viewed

@@ -1,35 +1,39 @@
 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.
-enum List is (first | link(v: a, rest: List)) =
+record list<V>(_ptr: *V): ToStr
-  // where a : Number & Stringable
-  fn each(self, cb: fn(v: a)) =
+  new create<V>(ptr: *V)
-    match self
+    _ptr = ptr
-      List::first -> List::first
-      List::link(v, rest) ->
-        cb(v)
-        each(rest, cb)
-  fn map(self, cb: fn(v: a): v) =
+  fn concat(): slice<V> =
-    match self
+    pass
-      List::first -> first
-      List::link(v, rest) -> List::link(cb(v), map(rest, cb))
-  fn get(i: int): a? =
+  fn length(): int =
+    len := 0
+    while *_ptr != 0x00
+      len += 1
-    match self
+      _ptr += 1
-      List::first -> List::first
-      List::link(v, rest) ->
-        each(rest, cb)
+    len
-  fun get<a>(lst :: List<a>, n :: Number) -> a:
+  fn each(cb: fn(v: V): void): void =
-    doc: "Returns the nth element of the given list, or raises an error if n is out of range"
-    fun help(l, cur):
-      if is-empty(l): raise("get: n too large " + tostring(n))
-      else if cur == 0: l.first
+    while *_ptr != 0x00
-      else: help(l.rest, cur - 1)
-      end
-    end
-    if n < 0: raise("get: invalid argument: " + tostring(n))
-    else: help(lst, n)
+      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())
-    end
+      else
+        res.write(@TypeToString(v))
-  end
+    )

example/std/map.mi CHANGED Viewed

@@ -1,14 +1,9 @@
+module std
+record map<V>(data: Pointer, length: int)
+  """
+  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.
+  """
+  new init(): Slice
-map
+    pass
-entity Map()
-fn new() =
-  alloc Map
-fn get()
-fn set()
-fn

example/std/math.mi CHANGED Viewed

@@ -97,4 +97,25 @@ fun sqrt(): F64 =>
   else
     @"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 = ""
+fn op_add(x: int, y: int): int =
+  @"i64.add"(x, y)
+  sub
+  mul
+  div
+  rem
+  min
+  max
+  to_float()

example/std/ranges.mi ADDED Viewed

@@ -0,0 +1,18 @@
+fn range(start: int, e: int, cb: fn(int)) =
+  if (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)) =
+  if n != 0:
+    cb(n)
+    repeat(n-1, cb)
+fn main() =
+  repeat(10) |i|
+    println(i)
+  range(10, 20) |i|
+    println(i)

example/std/str.mi CHANGED Viewed

@@ -1,34 +1,87 @@
 module std
+// Trait ToStr defines any data that can be converted to a str
-trait Stringable =
+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.
+// 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.
-struct str(data: Pointer<u16>, length: int) is Comparable, Stringable =
+struct str(_ptr: *u8) : Comparable, ToStr
-  fn get(i: int) = data[i]
-  fn concat(other: str): str =
+new (s str) create(ptr: *u8) =
+  // TODO: have a check in dev builds to throw an error if not null terminated
+  // to prevent undefined behavior
-    pass
+  _ptr = ptr
-  fn starts_with(search: str): bool =
+fn (s str) get(i: int) =
-    pass
+  data[i]
-  fn ends_with(search: str): bool =
+fn (s str) contains(search: str): bool =
-    pass
+  pass
-  fn contains(search: str): bool =
+fn (s str) index_of(sub: str): int =
-    pass
+  pass
-  fn index_of(sub: str): int =
+fn (s str) test(pattern: Regex): []str =
-    pass
+  pass
-  fn match(pattern: Regex): []str =
+fn (s str) search(key str): int, bool =
+	low, mid, high := 0, 0, n.numItems
+	while low < high
+		mid = (low + high) / 2
+ 		cmp := key > n.items[mid].key
+    low = cmp > 0 ? mid + 1 : low
+    high = cmp < 0 ? mid : high
+    if cmp == 0
+      return mid, true
-    pass
+	low, false
-  fn match_all(pattern: Regex): []str =
+fn (t BTree) delete(key str): bool =
+	if t.root == nil
+		return false
+	deletedItem := t.root.delete(key, false)
+	if t.root.numItems == 0
+		if t.root.isLeaf()
+			t.root = nil
-    pass
+		else
+			t.root = t.root.children[0]
+	if deletedItem != nil
+		return true
+	return false
-  fn pad_start(sub: str, count: int): str =
+fn (s str) Comparable::starts_with(search: str): bool =
-    pass
+  pass
+fn (s str) concat(other: str): str =
+  s + other
+fn (s str) to_str(): str = s
+fn (s str) concat(other: str): str =
+  s + s
+fn (s str) starts_with(search: str): bool =
+  pass
+fn (s str) ends_with(search: str): bool =
+  pass
+fn (s str) contains(search: str): bool =
+  pass
+fn (s str) index_of(sub: str): int =
+  pass
+fn (s str) match(pattern: Regex): []str =
+  pass
+fn (s str) match_all(pattern: Regex): []str =
+  pass
+fn (s str) pad_start(sub: str, count: int): str =
+  pass
   fn pad_end(sub: str, count: int): str =
     pass
@@ -60,9 +113,6 @@ struct str(data: Pointer<u16>, length: int) is Comparable, Stringable =
   fn to_upper(): str =
     pass
-  fn to_str(self): str =
-    self
   fn trim(): str =
     pass
@@ -72,7 +122,8 @@ struct str(data: Pointer<u16>, length: int) is Comparable, Stringable =
   fn trim_end(): str =
     pass
-  fn reverse(): str =
+  fn reverse(): str
+    """reverses a str
     start := 0
     end := length - 1
     result := []
@@ -88,4 +139,10 @@ struct str(data: Pointer<u16>, length: int) is Comparable, Stringable =
     0
   fn parse_float(): float! =
-    0.0
+    0.0
+  fn parse_bool(): bool! =
+    match to_lower()
+      "true" -> bool::true
+      "false" -> bool::false
+      _ -> error("could not parse bool '${this}'")

public/index.html ADDED Viewed

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <link rel="stylesheet" type="text/css" href="public/main.css" />
+    <script src="public/main.js"></script>
+    <style>
+      body {
+        color: #000000;
+        font-family: sans-serif;
+        font-size: small;
+        font-style: italic;
+        font-weight: bold;
+      }
+      table.hh {
+        border: 1px solid gray;
+      }
+      bor {
+        border: 1px;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="bor">
+      <table bgcolor="#f0f0f0" cellspacing="0" class="hh">
+        <tr>
+          <td><img src="/llama.png" align="left" /></td>
+          <td>
+            <table cellspacing="0">
+              <tr>
+                <td><b>pyros2097</b></td>
+              </tr>
+              <tr>
+                <td>Gdx Developer</td>
+              </tr>
+              <tr>
+                <td>"Awesomeness we can has"</td>
+              </tr>
+            </table>
+          </td>
+        </tr>
+        <tr></tr>
+      </table>
+    </div>
+  </body>
+</html>

public/llama.png ADDED Viewed

Binary file

~repos /plum

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

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