plum

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

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

19b8452f — pyrossh

improve syn

Files changed (14) hide show

.gitignore +1 -0
readme.md +126 -236
scratch.pc +218 -0
std/bool.mi +1 -30
std/coding/base64.mi +0 -170
std/html.mi +43 -0
std/http.mi +15 -53
std/list.mi +4 -33
std/map.mi +0 -2
std/os.mi +5 -0
std/ranges.mi +0 -75
std/regex.mi +1 -0
std/time.mi +3 -0
std/uuid.mi +1 -0

.gitignore CHANGED Viewed

@@ -9,3 +9,4 @@ static/bundle/
 static/monaco-editor-workers/
 static/worker/
 syntaxes/
+website

readme.md CHANGED Viewed

@@ -1,17 +1,17 @@
 # 👾 Pacos Programming Language
-* A statically typed, functional programming language inspired by rust, koka.
+- A statically typed, imperative 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.
+- 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.
+- 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
+- Strict naming convention
-* Only one way of doing things ex: loops, condition
+- Only one way of doing things ex: loops, condition
 **Todo**
 linter, formatter, test runner, language server, package manager
 Here is some sample code, please enjoy.
 ```go
@@ -47,21 +47,21 @@ fn factorial(n: int): int =
     a -> 1
     _ -> n * factorial(n - 1)
-fn first_item(l: list[int]): int? =
+fn firstItem(l: list[int]): int? =
   l[0]
-fn first_item(l: list[int]): int? =
+fn firstItem(l: list[int]): int? =
   match l
     [] -> nil
     [head, ...rest] -> head
-fn first_item(l: list[int]): int? =
+fn firstItem(l: list[int]): int? =
   if l.size > 0
     l[0]
   else
     nil
-fn to-celsius(f: float): float =
+fn toCelsius(f: float): float =
   (f - 32) * (5 / 9)
 record Cat[A: Comparable & Stringable](
@@ -69,16 +69,16 @@ record Cat[A: Comparable & Stringable](
   age:  int
 )
-fn Cat.with_name(name: str): Cat =
+fn Cat.withName(name: str): Cat =
   Cat(name: name, age: 0)
 fn (c: Cat) fullname(): str =
   c.name + c.age.to_str()
 fn (c: Cat) talk() =
-  println("cat ${c.name} says meow")
+  printLn("cat ${c.name} says meow")
-fn (c: Cat) to_str(): str =
+fn (c: Cat) toStr(): str =
   "Cat<{c.fullname()}, ${c.age}>"
 type MapCallback = fn(v: a): v
@@ -115,12 +115,12 @@ test("to_str") |t|
   items := [Cat("Molly", 9), Cat("Fenton", 6)]
       .retain(|p| p.name.size > 5)
       .map(|p| describe(p))
-      .each(|d| println(d))
+      .each(|d| printLn(d))
   assert items[0].to_str() == "Cat<Fenton, 6>"
 bench("1231") |n|
   for i := range n
-    println(i)
+    printLn(i)
 ```
 ## Language Reference
@@ -128,7 +128,7 @@ bench("1231") |n|
 **Keywords**
 ```rs
-for,while,if,else,record,enum,fn,assert,match,type
+for,while,if,else if,else,record,enum,fn,assert,match,type
 ```
 ### Types
@@ -158,7 +158,7 @@ if true || false
 **byte**
-A byte represents an unsigned 8 bit number. It is mainly used to represent strings and binary data.
+A byte represents an unsigned 8-bit number. It is mainly used to represent strings and binary data.
 ```rb
 let data: []byte?
@@ -167,10 +167,13 @@ 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,
+An int is a signed 64-bit number. It can be represented in various ways,
+```
 0b - Binary (Base 2)
 0x - Hexadecimal (Base 16)
 27 - Standard (Base 10)
+```
 ```rb
 0b00101010
@@ -184,11 +187,25 @@ An int is a signed 64 bit number. It can be represented in various ways,
 **float**
-A float represents a 64-bit floating point (52-bit mantissa) IEEE-754-2008 binary64
+A float represents a 64-bit floating point [IEEE-754-2008](https://en.wikipedia.org/wiki/Double-precision_floating-point_format).
+```java
+1.2
+-0.4
+12.0f
+15.03f
+```
 **dec**
-A decimal type represents BCD number. It has a mantissa and exponent.
+A dec is a decimal floating-point numbering format which is 64-bit data type.
+It is intended for applications where it is necessary to emulate decimal rounding exactly, such as financial and tax computations.
+It supports 16 decimal digits of significand and an exponent range of −383 to +384.
+```java
+2.4d
+-13.3d
+```
 **str**
@@ -199,7 +216,7 @@ It supports interpolation of variables/values that implement the ToStr interface
 "Hello World"
 name := "Pacos"
 age := 1
-println("Name ${name} age ${age}")
+printLn("Name ${name} age ${age}")
 ```
 **list**
@@ -207,11 +224,15 @@ println("Name ${name} age ${age}")
 ```py
 import pacos/list
-a := list.of(1, 2, 3)                             # list[int]
+a := List.of(1, 2, 3)   # List[int]
-b := list.of(list.of(1), list.of(2), list.of(3))  # list[list[int]]
+b := List.of(          # List[List[int]]
+  List.of(1),
+  List.of(2),
+  List.of(3),
+)
-c := list.of(1, 2, 3 * 4, 8, n)
+c := List.of(1, 2, 3 * 4, 8, n)
-actors := list.of("Krabs", "Squidward")
+actors := List.of("Krabs", "Squidward")
 actors.add("Spongebob")
 actors.length() // ==> 3
 actors.contains("Krabs") // ==> true
@@ -220,58 +241,41 @@ actors.get(5) // => nil
 items
   .map(|v| v + 1)
-  .each(|v| println("v", v))
+  .each(|v| printLn("v", v))
   .reduce(0, |v| v + 1)
 ```
 **map**
-```rb
+```rs
 import pacos/map
-nums := Map.new(:one => 1, :two => 2)
+nums := Map.of(:one => 1, :two => 2)
-map.get(:one) // =>`
+map.get(:one) // => 1
 map.get(:unknown) // => nil
-friends_tree := [
+friends_tree := Map.of(
   :value => "Fred",
-  :left => [
+  :left => Map.of(
     :value => "Jim",
-  ],
+  ),
-  :right => [
+  :right => Map.of(
     :value => "Shiela",
-    :left => [
+    :left => Map.of(
       :value => "Alice",
-    },
+    ),
-    :right => [
+    :right => Map.of(
       :value => "Bob"
-    ],
+    ),
-  ],
+  ),
-]
+)
 friends_tree
   .map(|k, v| v)
-  .each(|k, v| println("v", v))
+  .each(|k, v| printLn("v", v))
   .reduce(0, |k, v| v + 1)
 ```
-**time**
-TBD
-**duration**
-TBD
-**regex**
-TBD
-**uuid**
-TBD
-**Constants**
+**constants**
 Constants can be declared at the top level of a program. They cannot be reassigned.
@@ -279,15 +283,17 @@ 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
+const START_YEAR = 2101
-const PI = 3.14159f
+const PI = 3.14159
-const ERR_MESSAGE = "An unknown error occured"
+const NAME = "pacos"
+const DEBUG_ENABLED = true
 const COUNT = count(10)
-const COUNTRIES_LIST = ["US", "INDIA", "CANADA"]
+const COUNTRIES_LIST = ist.of("US", "INDIA", "CANADA")
-const COUNTRY_CODES = [
+const COUNTRY_CODES = map.of(
-  :in => "INDIA",
+  "in" => "INDIA",
-  :us => "United States",
+  "us" => "United States",
-  :ca => "Canada"
+  "ca" => "Canada"
-]
+)
 fn count(n: int): int = n * 1
 ```
@@ -305,22 +311,6 @@ assoc_list[:a]
 assoc_list["b"]
 ```
-**Assignment Operators**
-```go
-  x := 5
-	y := 3
-	x += y  // 8
-	x -= y  // 5
-	x *= y  // 15
-	x /= y  // 5
-	x %= y  // 2
-	x &= y  // 2
-	x |= y  // 3
-	x <<= y // 24
-	x >>= y // 3
-```
 **While statement**
 ```rb
@@ -338,10 +328,6 @@ while a > b
 **For statement**
-type Seq0 = fn(yield: fn(): bool): bool
-type Seq1[V] = fn(yield: fn(V): bool): bool
-type Seq2[K, V] = fn(yield: fn(K, V): bool): bool
 ```rb
 for i := range 10
   sum += i
@@ -355,24 +341,45 @@ for k, v := range json_map
 for v := range list
   sum += k + v
+```
+**For Custom Iterator**
+```rb
+type Seq0 = fn(yield: fn(): bool): bool
+type Seq1[V] = fn(yield: fn(V): bool): bool
+type Seq2[K, V] = fn(yield: fn(K, V): bool): bool
 record Tree[E](
   value E,
-  left: Tree[E]?,
+  left: optional[Tree[E]],
-  right: Tree[E]?,
+  right: optional[Tree[E]],
 )
 fn (t Tree[E]) op_range(yld: fn(E): bool): bool =
-  t ? true : t.left.in_order(yld) && yld(t.val) && t.right.in_order(yld)
+  t ? true : t.left?.in_order(yld) && yld(t.val) && t.right?.in_order(yld)
-tt := Tree(
+tree := Tree(
   value: 10,
   left: Tree(20, Tree(30), Tree(39)),
   right: Tree(40),
 )
-for t := range tt
+for t := range tree
-  println(v)
+  printLn(v)
+```
+**if expression/statement**
+```py
+if name == "Andreas"
+  printLn("What a nice name!")
+else if name == "Pacman"
+  printLn("Game from the 80s")
+else if name == ""
+  printLn("Don't you have a name?")
+else
+  printLn("Boring name...")
 ```
 **When expression/statement**
@@ -394,26 +401,13 @@ when number
   1 | 3 | 5 | 7 -> "This is an odd number"
   _ -> "I'm not sure"
-match xs
+when 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"
 ```
-Arithmetic (+, -, /, \*, @divFloor, @sqrt, @ceil, @log, etc.)
-Bitwise operators (>>, <<, &, |, ~, etc.)
-Comparison operators (<, >, ==, etc.)
-**if expression/statement**
-```rb
-if post.valid()
-  render_create_view()
-else
-  render_post(post: post)
-```
 ### Conditional operators
 **not operator**
@@ -474,13 +468,29 @@ paint := Paint()
   ..strokeWidth = 5.0
 ```
-**variadic function**
+**variadic operator**
 ```go
 fn add(items ...str) =
   list.add(items)
 ```
+**assignment operator**
+```go
+  x := 5
+	y := 3
+	x += y  // 8
+	x -= y  // 5
+	x *= y  // 15
+	x /= y  // 5
+	x %= y  // 2
+	x &= y  // 2
+	x |= y  // 3
+	x <<= y // 24
+	x >>= y // 3
+```
 **generics**
 ```
@@ -488,134 +498,14 @@ fn add[T: int | float](a: List[T], b: List[T]): List[T] =
   pass
 ```
-```
-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
-  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 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
-```
 ### General naming convention
-| Item                    | Convention               |
+| Item                     | Convention              |
-| ----------------------- | ------------------------ |
+| ------------------------ | ----------------------- |
-| Modules                 | snake_case               |
+| Modules                  | snake_case              |
-| Types                   | UpperCamelCase           |
-| Traits                  | UpperCamelCase           |
+| Types/Traits/Enum        | UpperCamelCase          |
-| Enum variants           | UpperCamelCase           |
+| Fields/Functions/Methods | lowerCamelCase          |
-| Functions               | snake_case               |
-| Methods                 | snake_case               |
-| General constructors    | new or with_more_details |
-| Conversion constructors | from_some_other_type     |
+| Conversion constructors  | from_some_other_type    |
-| Local variables         | snake_case               |
+| Local variables          | snake_case              |
-| Constants               | SCREAMING_SNAKE_CASE     |
+| Constants                | SCREAMING_SNAKE_CASE    |
-| Generics                | single uppercase letter  |
+| Generics                 | single uppercase letter |

scratch.pc ADDED Viewed

@@ -0,0 +1,218 @@
+data.price?.take_if(|a| a != "")
+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
+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())
+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)))
+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

std/bool.mi CHANGED Viewed

@@ -4,38 +4,9 @@ enum bool =
   | true
   | false
+fn (x: bool) op_eq(y: bool) = x == y
 fn (x: bool) op_ne(y: bool) = x != y
 fn (x: bool) op_and(y: bool) = x == false || y == false ? false : true
 fn (x: bool) op_or(y: bool) = x == true || y == true ? true : false
 fn (x: bool) op_not(): bool = x == true ? false : true
 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 DELETED Viewed

@@ -1,170 +0,0 @@
-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/html.mi ADDED Viewed

@@ -0,0 +1,43 @@
+module std
+test("HTML DSL") |_|
+  tree := html(class: "123")
+    head() |_|
+      title("Pacos")
+      link(href: "https://pacos.dev")
+    body(class: "bg-white") |_|
+      div(class: "box") |_|
+        text("Hello")
+      div() |_|
+        text("World")
+  assert tree.to_str() == ```
+    <html>
+      <head>
+        <title>Pacos</title>
+        <link href="https://pacos.dev" />
+      </head>
+      <body>
+        <div class="box">
+          Hello
+        </div>
+        <div>
+          World
+        </div>
+      </body>
+    </html>
+  ```
+html(class: "123") {
+  head() {
+    title("name")
+    link(href: "123")
+  }
+  body(class: "class") {
+    div(class: "132") {
+      text("Hello")
+    }
+    div() {
+      text("World")
+    }
+  }
+}

std/http.mi CHANGED Viewed

@@ -1,20 +1,18 @@
 import std/path
 import std/os
-import http/content_type
+import std/http/content_type
+#[builder]
+record Response(
+  headers: map[str, str]
+  body: Buffer
+  status: int
+)
 fn file_response(file: str): Response! =
   ext := path::ext(file)
-  content := content_type::from_ext(ext)
+  content := contentTypeFromExt(ext)
   data := try os.read_file(file)
-  Response(
-    status: 200,
-    headers: map.of(
-      "Content-Type" => content,
-      "Content-Length" => "2"
-    ),
-    body: data
-  )
   Response()
     .header("Content-Type", content)
     .header("Content-Length", "2")
@@ -28,45 +26,9 @@ fn index(): Response! =
 #[get("/public/<...>")]
 fn public(file: str): Response! =
   ext := path::ext(file)
-  content := content_type::from_ext(ext)
+  content := contentTypeFromExt(ext)
-  data := try os.read_file(file)
+  data := os.readFile?(file)
-  Response(
+  Response()
+    .header("Content-Type", content)
+    .body(data)
-    status: 200,
+    .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

std/list.mi CHANGED Viewed

@@ -15,7 +15,7 @@ record node[V](
   next: node[V]?
 )
-fn List.of[A](values: ...A): list[A] =
+fn listOf[A](values: ...A): list[A] =
   list[A]().add(values)
 fn (l: list) get(i: int) -> A =
@@ -44,7 +44,7 @@ fn (l: list) add(values: ...V) =
     l.head.next.prev = l.head
     l._size += 1
-fn (l: list) remove_at(i int) =
+fn (l: list) removeAt(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
@@ -102,7 +102,7 @@ fn (l: list) map[B](cb: fn(v: V): B): list[A] =
     nl.push(item)
   nl
-fn (l: list) flat_map() =
+fn (l: list) flatMap() =
   `returns a new list with all elements shuffled`
   pass
@@ -165,7 +165,7 @@ fn (l: list) chunk() =
   `returns a new list with all elements shuffled`
   pass
-fn (l: list) group_by() =
+fn (l: list) groupBy() =
   `returns a new list with all elements grouped`
   pass
@@ -177,32 +177,3 @@ 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

@@ -29,5 +29,3 @@ fn (m: Map) update() =
 fn (m: Map) update_if() =
   pass
-data.price?.take_if(|a| a != "")

std/os.mi ADDED Viewed

@@ -0,0 +1,5 @@
+module std
+fn printLn(): result[unit, unit] =
+  `Writes the specified data, followed by the current line terminator, to the standard output stream.
+  pass

std/ranges.mi DELETED Viewed

@@ -1,75 +0,0 @@
-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)
-  //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/regex.mi ADDED Viewed

	@@ -0,0 +1 @@
1	+ TBD

std/time.mi ADDED Viewed

@@ -0,0 +1,3 @@
+record time()
+record duration()

std/uuid.mi ADDED Viewed

	@@ -0,0 +1 @@
1	+ type uuid = string

~repos /plum

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

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