plum

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

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

5f5d99d4 — Peter John

new syntax

Files changed (24) hide show

.gitignore +0 -1
.vscode/launch.json +11 -11
libs/std/bool.ks +0 -53
libs/std/bool.plum +23 -0
libs/std/encode/base64.plum +199 -0
libs/std/err.plum +8 -0
libs/std/float.ks +0 -0
libs/std/float.plum +33 -0
libs/std/html.mi +0 -34
libs/std/{http.mi → http.plum} +8 -11
libs/std/int.ks +0 -178
libs/std/int.plum +140 -0
libs/std/{json.mi → json.plum} +42 -55
libs/std/{list.mi → list.plum} +0 -1
libs/std/map.mi +0 -75
libs/std/map.plum +39 -0
libs/std/option.ks +0 -36
libs/std/result.ks +0 -38
libs/std/str.mi +0 -182
libs/std/str.plum +177 -0
test/add.plum +1 -1
test/sample.plum +83 -432
tooling/vscode-plum/language-configuration.json +15 -3
tooling/vscode-plum/syntaxes/plum.tmLanguage.json +182 -0

.gitignore CHANGED Viewed

@@ -8,6 +8,5 @@ src/language/generated/
 static/bundle/
 static/monaco-editor-workers/
 static/worker/
-syntaxes/
 node_modules
 *.vsix

.vscode/launch.json CHANGED Viewed

@@ -3,15 +3,15 @@
 // Hover to view descriptions of existing attributes.
 // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
 {
-	"version": "0.2.0",
+  "version": "0.2.0",
-    "configurations": [
+  "configurations": [
-        {
+    {
-            "name": "Extension",
+      "name": "Extension",
-            "type": "extensionHost",
+      "type": "extensionHost",
-            "request": "launch",
+      "request": "launch",
-            "args": [
+      "args": [
-                "--extensionDevelopmentPath=${workspaceFolder}/vscode-kestrel"
+        "--extensionDevelopmentPath=${workspaceFolder}/tooling/vscode-plum"
-            ]
+      ]
-        }
+    }
-    ]
+  ]
 }

libs/std/bool.ks DELETED Viewed

@@ -1,53 +0,0 @@
-module std
-trait Bool : ToStr permits True, False {
-  operator fn eq(other: Bool) -> Bool
-  operator fn neq(other: Bool) -> Bool
-  operator fn and(other: Bool) -> Bool
-  operator fn or(other: Bool) -> Bool
-  operator fn not() -> Bool
-  override fn toStr() -> Str
-}
-tuple True() : Bool {
-  operator fn eq(other: Bool) -> Bool {
-    return other is True
-  }
-  operator fn neq(other: Bool) -> Bool {
-    return !self.eq()
-  }
-  operator fn and(other: Bool) -> Bool {
-    return other is False ? False : True
-  }
-  operator fn or(other: Bool) -> Bool {
-    return True
-  }
-  operator fn not() -> Bool {
-    return False
-  }
-  override fn toStr() -> Str {
-    return "True"
-  }
-}
-tuple False() : Bool {
-  operator fn eq(other: Bool) -> Bool {
-    return other is False
-  }
-  operator fn neq(other: Bool) -> Bool {
-    return !self.eq()
-  }
-  operator fn and(other: Bool) -> Bool {
-    return False
-  }
-  operator fn or(other: Bool) -> Bool {
-    return other is True ? True : False
-  }
-  operator fn not() -> Bool {
-    return True
-  }
-  override fn toStr() -> Str {
-    return "False"
-  }
-}

libs/std/bool.plum ADDED Viewed

@@ -0,0 +1,23 @@
+module std
+Bool =
+  | True
+  | False
+# Might not be needed
+Bool\toStr() -> Str =
+  "True"
+Bool\and(other: Bool) -> Bool =
+  match self, other is
+    True, True => True
+    True, False => False
+    False, True => False
+    False, False => False
+Bool\or(other: Bool) -> Bool =
+  match self, other is
+    True, True => True
+    True, False => True
+    False, True => True
+    False, False => False

libs/std/encode/base64.plum ADDED Viewed

@@ -0,0 +1,199 @@
+```
+# Base64 package
+The Base64 package contains support for doing Base64 binary-to-text encodings.
+We currently have support 3 encodings: PEM, MIME and URL.
+To learn more about Base64, we suggest you check out the
+[wikipedia entry](https://en.wikipedia.org/wiki/Base64).
+## Example code
+use "encode/base64"
+actor Main
+  new create(env: Env) =>
+    env.out.print(Base64.encode("foobar"))
+    try
+      env.out.print(Base64.decode[String iso]("Zm9vYmFy")?)
+    end
+```
+module base64
+# Encode for PEM (RFC 1421).
+encodePEM(data: ReadSeq[U8]) -> String =
+  encode(data, '+', '/', '=', 64)
+# Encode for MIME (RFC 2045).
+encodeMIME(data: ReadSeq[U8]) -> String =
+  encode(data, '+', '/', '=', 76)
+# Encode for URLs (RFC 4648). Padding characters are stripped by default.
+encodeURL(data: ReadSeq[U8], pad: Bool = False) -> String =
+  let c: U8 = if pad then '=' else 0 end
+  encode[A](data, '-', '_', c)
+# Configurable encoding. The defaults are for RFC 4648.
+encode(
+  data: ReadSeq[U8],
+  at62: U8 = '+',
+  at63: U8 = '/',
+  pad: U8 = '=',
+  linelen: USize = 0,
+  linesep: String = "\r\n"
+) -> String =
+  len = ((data.size() + 2) / 3) * 4
+  out = A(len)
+  lineblocks = linelen / 4
+  srclen = data.size()
+  blocks = USize(0)
+  i = USize(0)
+  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(encodeByte(out1, at62, at63)?)
+    out.push(encodeByte(out2, at62, at63)?)
+    out.push(encodeByte(out3, at62, at63)?)
+    out.push(encodeByte(out4, at62, at63)?)
+    i = i + 3
+    blocks = blocks + 1
+    srclen = srclen - 3
+    if (lineblocks > 0) and (blocks == lineblocks) then
+      out.append(linesep)
+      blocks = 0
+    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(encodeByte(out1, at62, at63)?)
+      out.push(encodeByte(out2, at62, at63)?)
+      if srclen == 2 then
+        out.push(encodeByte(out3, at62, at63)?)
+      else
+        out.push(pad)
+      out.push(pad)
+    if lineblocks > 0 then
+      out.append(linesep)
+  else
+    out.clear()
+  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
+# Encode a single byte
+encodeByte(i: Byte, at62: Byte, at63: Byte) -> Byte =
+  match
+    i == 62 => at62
+    i == 63 => at63
+    i < 26 => 'A' + i
+    i < 52 => ('a' - 26) + i
+    i < 62 => ('0' - 52) + i
+# Test base64 encoding.
+# Using test examples from RFC 4648.
+encodeDecodeTest() =
+  assert
+    encode(a) == b
+    decode(b) == a
+  where:
+    a         | b
+    ""        | ""
+    "f"       | "Zg=="
+    "fo"      | "Zm8="
+    "foo"     |  "Zm9v"
+    "foob"    | "Zm9vYg=="
+    "fooba"   | "Zm9vYmE="
+    "foobar"  | "Zm9vYmFy"
+# a | b | c << sql.rows("select a, b, c from maxdata")

libs/std/err.plum ADDED Viewed

@@ -0,0 +1,8 @@
+module std
+# This is used to represent an error value across the language
+Err = (
+  code() -> Int
+  msg() -> Str
+  cause() -> Err | Nil
+)

libs/std/float.ks DELETED Viewed

File without changes

libs/std/float.plum ADDED Viewed

@@ -0,0 +1,33 @@
+Float::PI=3.14
+fn acosh(v: float): float =
+  when
+    x < 1 | IsNaN(x) -> // first case is special case
+      NaN()
+    x == 1 ->
+      0
+    x >= Large ->
+      Log(x) + Ln2 // x > 2**28
+    x > 2 ->
+      Log(2*x - 1/(x+Sqrt(x*x-1))) // 2**28 > x > 2
+    _ ->
+      t := x - 1
+      // ((2*t+t*t).sqrt() + t).log1p()
+      Log1p(t + Sqrt(2*t+t*t)) // 2 >= x > 1
+fn is_finite(): bool = true
+  ` Check whether this number is finite, ie not +/-infinity and not NaN.
+  ` True if exponent is not all 1s
+  (bits() and 0x7FF0_0000_0000_0000) != 0x7FF0_0000_0000_0000
+# Check whether this number is +/-infinity
+is_infinite:  Bool =>
+  # True if exponent is all 1s and mantissa is 0
+  ((bits() and 0x7FF0_0000_0000_0000) == 0x7FF0_0000_0000_0000) and  # exp
+  ((bits() and 0x000F_FFFF_FFFF_FFFF) == 0)  // mantissa
+// Check whether this number is NaN.
+fn is_nan(): Bool =>
+  // True if exponent is all 1s and mantissa is non-0
+  ((bits() and 0x7FF0_0000_0000_0000) == 0x7FF0_0000_0000_0000) and  // exp
+  ((bits() and 0x000F_FFFF_FFFF_FFFF) != 0)  // mantissa

libs/std/html.mi DELETED Viewed

@@ -1,34 +0,0 @@
-module std
-test("HTML DSL") {
-  val 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>
-  ```
-}

libs/std/{http.mi → http.plum} RENAMED Viewed

@@ -4,27 +4,24 @@ import std/path
 import std/os
 import std/http/content_type
-#[builder]
-record Response(
+Response = (
   headers: Map[Str, Str]
-  body: str | Buffer | IO
+  body: Str | Buffer | IO
-  status: int
+  status: Int
 )
-fn file_response(path: str): Response | IOError =
+createFileResponse(path: Str) -> Response | IOError =
-  content := contentTypeFromExt(path.ext())
+  content := content_type.fromExt(path.ext())
   data := os.readFile(file)?
   Response()
     .header("Content-Type", content)
     .body(data)
     .status(200)
-#[get("/")]
-fn index(): Response! =
+index() -> Response! =
-  file_response("index.html")
+  createFileResponse("index.html")
-#[get("/public/<...>")]
-fn public(file: str): Response | IOError =
+serveFile(file: Str) -> Response | IOError =
   ext := path::ext(file)
   content := contentTypeFromExt(ext)
   data := os.readFile(file)?

libs/std/int.ks DELETED Viewed

@@ -1,178 +0,0 @@
-tuple Int() {
-  `Euler's number, the base of natural logarithms, e
-  `https://oeis.org/A001113
-  const E = 2.718f
-  `The natural logarithm of 10
-  `https://oeis.org/A002392
-  const LN10 = 2.302f
-  `The natural logarithm of 2
-  `https://oeis.org/A002162
-  const LN2 = 0.693f
-  `The base 10 logarithm of e
-  `formula: 1 / LN10
-  const LOG10E = 0.434f
-  `The base 2 logarithm of e
-  `formula: 1 / LN2
-  const LOG2E = 1.442f
-  `The ratio of the circumference of a circle to its diameter
-  `https://oeis.org/A000796
-  const PI = 3.14159f
-  `https://oeis.org/A001622
-  const PHI = 1.6180f
-  `The square root of 1/2
-  const SQRT1_2 = 0.707f
-  `The square root of 2
-  `https://oeis.org/A002193
-  const SQRT2 = 1.414f
-  `https://oeis.org/A019774
-  const SQRT_E = 1.64872f
-  `https://oeis.org/A002161
-  const SQRT_PI  = 1.77245f
-  `https://oeis.org/A139339
-  const SQRT_PHI = 1.27201f
-  `The difference between 1 and the smallest floating point number greater than 1
-  `formula: 7/3 - 4/3 - 1
-  const EPSILON = 2.220446049250313e-16f
-  `Lowest value of int
-  const MIN_INT_VALUE = -0x8000_0000_0000_0000
-  `Highest value of int
-  const MAX_INT_VALUE = 0x7FFF_FFFF_FFFF_FFFF
-  `Lowest valur of float
-  const MIN_FLOAT_VALUE = 4.9406564584124654417656879286822137236505980e-324
-  `Highest valur of float
-  const MAX_FLOAT_VALUE = 1.79769313486231570814527423731704356798070e+308
-  fn abs(v: float): float =
-    `returns the absolute value of a number v
-    a < 0 ? -a : a
-  fn acos(v: float) =
-    if v < 0.1
-      asin(v)
-    else
-      asin(-1v)
-  `2**28
-  const LARGE = 1 << 28
-  fn acosh(v: float): float =
-    when
-      x < 1 | IsNaN(x) -> // first case is special case
-        NaN()
-      x == 1 ->
-        0
-      x >= Large ->
-        Log(x) + Ln2 // x > 2**28
-      x > 2 ->
-        Log(2*x - 1/(x+Sqrt(x*x-1))) // 2**28 > x > 2
-      _ ->
-        t := x - 1
-        // ((2*t+t*t).sqrt() + t).log1p()
-        Log1p(t + Sqrt(2*t+t*t)) // 2 >= x > 1
-  fn asin(v: float) = 0f
-  fn asinh(v: float) = 0f
-  fn atan(v: float) = 0f
-  fn atan2(v: float) = 0f
-  fn atanh(v: float) = 0f
-  fn cbrt(v: float) = 0f
-  fn ceil(v: float) = 0f
-  fn clz32(v: float) = 0f
-  fn cos(v: float) = 0f
-  fn cosh(v: float) = 0f
-  fn exp(v: float) = 0f
-  fn to_int(): int = 0
-  fn to_str(): str = ""
-  fn random(): float =
-    pass
-  fn is_int(): bool =
-    pass
-  fn is_finite(): bool = true
-    ` Check whether this number is finite, ie not +/-infinity and not NaN.
-    ` True if exponent is not all 1s
-    (bits() and 0x7FF0_0000_0000_0000) != 0x7FF0_0000_0000_0000
-  // Check whether this number is +/-infinity
-  is_infinite:  Bool =>
-    // True if exponent is all 1s and mantissa is 0
-    ((bits() and 0x7FF0_0000_0000_0000) == 0x7FF0_0000_0000_0000) and  // exp
-    ((bits() and 0x000F_FFFF_FFFF_FFFF) == 0)  // mantissa
-  // Check whether this number is NaN.
-  fn is_nan(): Bool =>
-    // True if exponent is all 1s and mantissa is non-0
-    ((bits() and 0x7FF0_0000_0000_0000) == 0x7FF0_0000_0000_0000) and  // exp
-    ((bits() and 0x000F_FFFF_FFFF_FFFF) != 0)  // mantissa
-  fn to_exponential(v: float): str = ""
-  fn to_fixed(v: float): str = ""
-  fn to_precision(v: float): str = ""
-  fn abs(): F64 = @"llvm.fabs.f64"(this)
-  fn ceil(): F64 = @"llvm.ceil.f64"(this)
-  fn floor(): F64 = @"llvm.floor.f64"(this)
-  fn round(): F64 = @"llvm.round.f64"(this)
-  fn trunc(): F64 = @"llvm.trunc.f64"(this)
-    fun log(): F64 => @"llvm.log.f64"(this)
-  fun log2(): F64 => @"llvm.log2.f64"(this)
-  fun log10(): F64 => @"llvm.log10.f64"(this)
-  fun logb(): F64 => @logb(this)
-  fun pow(y: F64): F64 => @"llvm.pow.f64"(this, y)
-  fun powi(y: I32): F64 =>
-    ifdef windows then
-      pow(y.f64())
-    else
-      @"llvm.powi.f64"(this, y)
-    end
-  fun sqrt(): F64 =>
-    if this < 0.0 then
-      _nan()
-    else
-      @"llvm.sqrt.f64"(this)
-    end
-  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()
-}

libs/std/int.plum ADDED Viewed

@@ -0,0 +1,140 @@
+module std/int
+# Euler's number, the base of natural logarithms, e, https://oeis.org/A001113
+E = 2.718f
+# The natural logarithm of 10, https://oeis.org/A002392
+LN10 = 2.302f
+# The natural logarithm of 2 https://oeis.org/A002162
+LN2 = 0.693f
+# The base 10 logarithm of e # formula: 1 / LN10
+LOG10E = 0.434f
+# The base 2 logarithm of e # formula: 1 / LN2
+LOG2E = 1.442f
+# The ratio of the circumference of a circle to its diameter https://oeis.org/A000796
+PI = 3.14159f
+# https://oeis.org/A001622
+PHI = 1.6180f
+# The square root of 1/2
+SQRT1_2 = 0.707f
+# The square root of 2 https://oeis.org/A002193
+SQRT2 = 1.414f
+# https://oeis.org/A019774
+SQRT_E = 1.64872f
+# https://oeis.org/A002161
+SQRT_PI  = 1.77245f
+# https://oeis.org/A139339
+SQRT_PHI = 1.27201f
+# The difference between 1 and the smallest floating point number greater than 1 formula: 7/3 - 4/3 - 1
+EPSILON = 2.220446049250313e-16f
+# Lowest value of int
+MIN_INT_VALUE = -0x8000_0000_0000_0000
+# Highest value of int
+MAX_INT_VALUE = 0x7FFF_FFFF_FFFF_FFFF
+# Lowest valur of float
+MIN_FLOAT_VALUE = 4.9406564584124654417656879286822137236505980e-324
+# Highest valur of float
+MAX_FLOAT_VALUE = 1.79769313486231570814527423731704356798070e+308
+# 2**28
+LARGE = 1 << 28
+Int: Comparable, ToStr = ByteArray
+Int::random(): Float =
+    todo
+# returns the absolute value of the Int
+Int\abs() -> Int =
+  self < 0 ? -self : self
+Int\ceil() -> Float =
+  todo
+Int\floor() -> Float =
+  todo
+Int\round() -> Float =
+  todo
+Int\trunc() -> Float =
+  todo
+Int\log() -> Float =
+  todo
+Int\log2() -> Float =
+  todo
+Int\log10() -> Float =
+  todo
+Int\logb() -> Float =
+  todo
+Int\pow(y: Float) -> Float =
+    LibM.pow(self, y)
+Int\pow(y: Int) -> Float =
+    pow(y.toFloat())
+Int\sqrt() -> Float =
+  if this < 0.0 then
+    _nan()
+  else
+    LibM.sqrt(self)
+  end
+Int\asin(v: Float) =
+  todo
+Int\acos(v: Float) =
+  if v < 0.1
+    asin(v)
+  else
+    asin(-v)
+Int\asinh(v: Float) =
+  todo
+Int\atan(v: Float) =
+  todo
+Int\atan2(v: Float) =
+  todo
+Int\atanh(v: Float) =
+  todo
+Int\cbrt(v: Float) =
+  todo
+Int\ceil(v: Float) =
+  todo
+Int\clz32(v: Float) =
+  todo
+Int\cos(v: Float) =
+  todo
+Int\cosh(v: Float) =
+  todo
+Int\exp(v: Float) =
+  todo

libs/std/{json.mi → json.plum} RENAMED Viewed

@@ -1,59 +1,50 @@
 module std/json
-trait Json permits JsonStr, JsonBool, JsonNull, JsonFloat, JsonInt, JsonObject, JsonArray {
-  type = T
+Json =
+  | None
+  | Str
+  | Bool
+  | Float
+  | Int
+  | List
+  | Map
-  fn parse() -> T
+JsonParseError = {
+  line: Int
+  pos: Int
+  token: Char
 }
-tuple JsonObject(Map[str, Json]): Json {
+Json\\parse(src: Str | Buffer | IO) -> Json | JsonParseError =
-  type = JsonObject
-  fn parse() -> JsonObject {
+  JsonParser.withSrc(src).parse()
-  }
-}
-tuple JsonArray(List[Json]): Json {
-  fn parse() {}
-}
-tuple JsonInt(Int): Json {
+Json\parseNone() -> None | JsonParseError =
-}
+  parser.find("null")
+Json\parseStr() -> Str | JsonParseError =
+  parser.find("null")
-tuple JsonFloat(Float): Json {
+Json\parseFloat() -> Float | JsonParseError =
+  parser.find("null")
+Json\parseInt() -> Int | JsonParseError =
-}
+  parser.find("null")
+Json\parseList() -> List | JsonParseError =
+  parser.find("null")
+Json\parseMap() -> Map | JsonParseError =
-tuple JsonString(Str): Json {
+  parser.find("null")
-}
-tuple JsonBool(Bool): Json {
-}
-tuple JsonNull: Json {
-}
-fn Json.parse(src: str | Buffer | IO): Json | ParseError =
-  JsonParser.withSrc(src).parse()
-#[error(400, "Failed to parse json ${object} at: ${line} ${pos}")]
-record ParseError(
+JsonParser = (
-  line: str
+  cur: Int = ' '
-  pos:  str
+  _pos: Int = 0
+  _next: Int = ' '
+  _buf: Str | Buffer | IO
 )
-record JsonParser(
-  cur: int = ' '
-  _pos: int = 0
-  _next: int = ' '
-  _buf: str | Buffer | IO
-)
-fn JsonParser.withSrc(src: str | Buffer | IO): JsonParser =
+JsonParser::withSrc(src: Str | Buffer | IO) -> JsonParser =
   JsonParser(_buf = src)
 fn isSpace(c: U32): Bool => (c == ' ') or ((c >= '\t') and (c <= '\r'))
@@ -356,29 +347,25 @@ fn _get_fals(): bool? =
       error
   end
-test("parse int") {
+Json\test("parseInt") =
   assert Json.parse("123") == 123
-}
-test("parse str") {
+Json\test("parseStr") =
   assert Json.parse(`"hello"`) == "hello"
-}
-test("parse bool") {
+Json\test("parseBool") =
   assert Json.parse("true") == true
   assert Json.parse("false") == false
-}
-test("parse null") {
+Json\test("parse null") =
   assert Json.parse("null") == nil
-}
-test("parse array") {
+Json\test("parse array") =
   assert Json.parse(`[]`) == List[Json]()
   assert Json.parse(`[1, 2]`) == List.of[Json](1, 2)
-}
-test("parse object") {
+Json\test("parse object") =
   assert Json.parse(`{}`) == Map[str, Json]()
-  assert Json.parse(`{"a": 1, "b": 2}`) == Map.of[str, Json]("a" => 1, "b" => 2)
+  assert Json.parse(`{"a": 1, "b": 2}`) == Map.of[str, Json]("a" => 1, "b" => 2)
-}

libs/std/{list.mi → list.plum} RENAMED Viewed

@@ -8,7 +8,6 @@ record List[V](
   _size: int
 ) {
   fn of(values: ...V) -> List[V] {
   }
 }

libs/std/map.mi DELETED Viewed

@@ -1,75 +0,0 @@
-module std
-record pair[K: Comparable, V] where
-  | k: K
-  | v: V
-`A Map is a data structure describing a contiguous section of an array stored separately from the slice variable itself.
-`A Map is not an array. A slice describes a piece of an array.
-struct Map[K, V] where
-  let items: list[pair[K, V]]
-  static fn of[K, V](kvs: ...pair[K, V]): Map[K, V] =
-    Map[K, V]().add(kvs)
-  fn add(kvs: ...pair[K, V]) =
-    `adds the specified elements to the start of the list
-  fn op_range(yld: fn(k: K, v: V): bool): bool =
-    `allows the range operator to iterate over the Map
-    for item := range items
-      if !yld(item.k, item.v)
-        false
-    true
-  fn get(k K): Option[V] =
-    `get a value from the Map using key k
-    for k, v := range m
-      if k == k
-        return v
-    nil
-  fn set(k K, v V) =
-    `put a value into the Map
-    list.add(pair(k, v))
-  fn putIf(k K, v V) =
-    `put a value into the Map if its not already present
-    pass
-`A Map is a data structure describing a contiguous section of an array stored separately from the slice variable itself.
-`A Map is not an array. A slice describes a piece of an array.
-record Map[K, V](
-  items: List[Pair[K, V]]
-)
-fn Map.add(kvs: ...pair[K, V]) =
-  `adds the specified elements to the start of the list
-  items.add(kvs)
-fn (Map) get(k K): V? =
-  for k, v := range m
-    if k == k
-      return v
-  nil
-fn (Map) put(k K, v V) =
-  list.add(pair(k, v))
-fn (Map) put_if(k K, v V) =
-  if
-fn (Map) update() =
-  pass
-fn (Map) update_if() =
-  pass
-fn (Map->Range) range(yld: fn(k: K, v: V): bool): bool =
-  for item := range items
-    if !yld(item.k, item.v)
-      false
-  true

libs/std/map.plum ADDED Viewed

@@ -0,0 +1,39 @@
+module std
+Pair(a, b) = (
+  key: a
+  val: b
+)
+```
+A Map is a data structure describing a contiguous section of an array stored separately from the slice variable itself.
+A Map is not an array. A slice describes a piece of an array.
+```
+Map(a, b) = {
+  items: List(Pair(a, b))
+}
+mapOf(kvs: ...Pair) -> Map =
+  Map(a, b)().add(kvs)
+# adds the specified elements to the start of the list
+Map\add(kvs: ...Pair) =
+  items.add(kvs)
+# Get a value from the Map using key k
+Map\get(k: a) -> b | Nil =
+  for k, v in self
+    if k == k
+      return v
+  Nil
+# Put a value into the Map
+Map\set(k: a, v: b) =
+  items.add(pair(k, v))
+# `put a value into the Map if its not already present
+Map\putIfAbsent(k K, v V) =
+  todo
+Map\map(cb: (Pair(a, b)) -> Pair(c, d)) -> Map(c, d) =
+  items.map(cb)

libs/std/option.ks DELETED Viewed

@@ -1,36 +0,0 @@
-module std
-`Option is a type that represents either value present `Some` or nothing present `None`
-trait Option[T] permits Some, None {
-  fn get() -> T
-  `get if present otherwise return default value
-  fn getOrElse(default: T) -> T
-  fn toStr() -> Str
-}
-tuple Some[T](T) : Option[T] {
-  fn get() -> T {
-    return self.0
-  }
-  fn getOrElse(default: T) -> T {
-    return self.0
-  }
-  fn toStr() -> Str {
-    return "Some(${self.0.toStr()})"
-  }
-}
-tuple None() : Option[_] {
-  fn get() -> T {
-    fail("called 'Option.get()' on a 'None' value")
-  }
-  fn getOrElse(default: T) -> T {
-    return default
-  }
-  fn toStr() -> Str {
-    return "None"
-  }
-}

libs/std/result.ks DELETED Viewed

@@ -1,38 +0,0 @@
-module std
-`This is used to represent an error value across the language
-trait Error {
-  fn code(): Int
-  fn msg(): Str
-  fn cause(): Option[Error]
-}
-`Result is a type that represents either success `Ok` or failure `Err`
-trait Result[T, E: Error] permits Ok[T], Err[E] {
-  fn get() -> T
-  fn getOrElse(default: T) -> T
-}
-tuple Ok[T](T) : Result[T, _] {
-  fn get() -> T {
-    return self.0
-  }
-  fn getOrElse(default: T) -> T {
-    return self.0
-  }
-  fn map(cb: fn(a) -> b) -> Result[b, _] {
-    return Ok(cb(self.0))
-  }
-}
-tuple Err[E](E) : Result[_, E] {
-  fn get() -> T {
-    fail("called 'Result.get()' on an 'Err' value")
-  }
-  fn getOrElse(default: T) -> T {
-    return default
-  }
-  fn mapErr(cb: fn(a) -> b) -> Result[_, b] {
-    return Err(cb(self.0))
-  }
-}

libs/std/str.mi DELETED Viewed

@@ -1,182 +0,0 @@
-module std
-`ToStr defines any data that can be converted to a str
-trait ToStr(
-  fn toStr(): 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.
-record Str(data: Buffer): Comparable, ToStr {
-  fn get(i: int) {
-    return data.get(i)
-  }
-  fn contains(search: Str) -> Bool {
-    pass
-  }
-  fn index_of(sub: Str) -> Int {
-    pass
-  }
-  fn test(pattern: Regex) -> Bool {
-    pass
-  }
-  fn search(key: Str) -> (Int, Bool) {
-    val (low, mid, high) = (0, 0, n.numItems)
-    while low < high {
-      mid = (low + high) / 2
-      val cmp := key > n.items[mid].key
-      low = cmp > 0 ? mid + 1 : low
-      high = cmp < 0 ? mid : high
-      if cmp == 0 {
-        return (mid, True)
-      }
-    }
-    return (low, False)
-  }
-}
-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
-		else
-			t.root = t.root.children[0]
-	if deletedItem != nil
-		return true
-	return false
-fn (str) starts_with(search: str): bool =
-  pass
-fn (str) concat(other: str): str =
-  s + other
-fn (str) to_str(): str = s
-fn (str) concat(other: str): str =
-  s + s
-fn (str) starts_with(search: str): bool =
-  pass
-fn (str) ends_with(search: str): bool =
-  pass
-fn (str) contains(search: str): bool =
-  pass
-fn (str) index_of(sub: str): int =
-  pass
-fn (str) match(pattern: Regex): []str =
-  pass
-fn (str) match_all(pattern: Regex): []str =
-  pass
-fn (str) pad_start(sub: str, count: int): str =
-  pass
-fn (str) pad_end(sub: str, count: int): str =
-  pass
-fn (str) repeat(count: int): str =
-  pass
-fn (str) replace(pattern: Regex, sub: str): str =
-  pass
-fn (str) replace_all(pattern: Regex, sub: str): str =
-  pass
-fn (str) search(pattern: Regex): str =
-  pass
-fn slice(start: int, end: int): str =
-  pass
-fn split(separator: str, limit: int): []str =
-  pass
-fn sub(start: int, end: int): str =
-  pass
-fn to_lower(): str =
-  pass
-fn to_upper(): str =
-  pass
-fn trim(): str =
-  pass
-fn trim_start(): str =
-  pass
-fn trim_end(): str =
-  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 parseInt(): int! =
-  0
-fn parseFloat(): float! =
-  0.0
-fn parseBool(): bool! =
-  match to_lower()
-    "true" -> bool::true
-    "false" -> bool::false
-    _ -> error("could not parse bool '${this}'")
-_.camelCase
-_.capitalize
-_.deburr
-_.endsWith
-_.escape
-_.escapeRegExp
-_.kebabCase
-_.lowerCase
-_.lowerFirst
-_.pad
-_.padEnd
-_.padStart
-_.parseInt
-_.repeat
-_.replace
-_.snakeCase
-_.split
-_.startCase
-_.startsWith
-_.template
-_.toLower
-_.toUpper
-_.trim
-_.trimEnd
-_.trimStart
-_.truncate
-_.unescape
-_.upperCase
-_.upperFirst
-_.words

libs/std/str.plum ADDED Viewed

@@ -0,0 +1,177 @@
+module std/str
+# ToStr defines any data that can be converted to a str
+ToStr = (
+  toStr() -> 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.
+```
+Str : Comparable + ToStr = {
+  data: Buffer
+}
+Str\get(i: Int) -> Char =
+  data.get(i)
+Str\contains(search: Str) -> Bool =
+  todo
+Str\indexOf(sub: Str) -> Int =
+  todo
+Str\test(pattern: Regex) -> Bool =
+  todo
+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 then
+      return (mid, True)
+  (low, False)
+Str\startsWith(search: str) -> Bool =
+  todo
+Str\concat(other: Str) -> Str =
+  s + other
+Str\toStr() -> Str =
+  self
+Str\matchPattern(pattern: Regex) -> List<Str> =
+  todo
+Str\matchAll(pattern: Regex) -> List<Str> =
+  todo
+Str\padStart(sub: Str, count: Int) -> Str =
+  todo
+Str\padEnd(sub: Str, count: Int) -> Str =
+  todo
+Str\repeat(count: Int) -> Str =
+  todo
+Str\replace(pattern: Regex, sub: Str) -> Str =
+  todo
+Str\replaceAll(pattern: Regex, sub: Str) -> Str =
+  todo
+Str\search(pattern: Regex) -> Str =
+  todo
+Str\slice(start: Int, e: Int) -> Str =
+  todo
+Str\split(separator: Str, limit: Int) -> []Str =
+  todo
+Str\sub(start: Int, e: Int) -> Str =
+  todo
+Str\toLower() -> Str =
+  todo
+`reverses a Str
+Str\reverse() -> 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
+Str\parseInt() -> Int =
+  0
+Str\parseFloat() -> Float =
+  0.0
+Str\parseBool() -> Bool =
+  match self.to_lower()
+    "true" -> True
+    "false" -> False
+    _ -> error("could not parse bool '${this}'")
+  if self.lower() == "true"
+    True
+  else if self.lower() == "false"
+    False
+  else
+    error("could not parse bool '${this}'")
+Str\camelCase() -> Str =
+  todo
+Str\snakeCase() -> Str =
+  todo
+Str\capitalize() -> Str =
+  todo
+Str\kebabCase() -> Str =
+  todo
+Str\lowerCase() -> Str =
+  todo
+Str\lowerFirst() -> Str =
+  todo
+Str\upperCase() -> Str =
+  todo
+Str\upperFirst() -> Str =
+  todo
+Str\startCase() -> Str =
+  todo
+Str\deburr() -> Str =
+  todo
+Str\escape() -> Str =
+  todo
+Str\escapeRegExp() -> Str =
+  todo
+Str\pad() -> Str =
+  todo
+Str\template() -> Str =
+  todo
+Str\trim() -> Str =
+  todo
+Str\trimEnd() -> Str =
+  todo
+Str\trimStart() -> Str =
+  todo
+Str\truncate() -> Str =
+  todo
+Str\unescape() -> Str =
+  todo
+Str\words() -> Str =
+  todo

test/add.plum CHANGED Viewed

@@ -24,7 +24,7 @@ branch(x: Int) -> Int
 main() -> Int =
   result = 0
-  for i in 0..10
+  for i in 0...10
     result += i
     if i == 4
       continue

test/sample.plum CHANGED Viewed

@@ -6,425 +6,30 @@ Int.random()
 Float.random()
 Float.PI
-trait Comparable {
-  fn compareTo(other: T) -> Compare
-}
-trait Shape permits Circle, Square, Rectangle {
-  fn area() -> Float
-}
-tuple Circle(Int): Shape {
-  fn area() = PI * self.0 * self.0
-}
-tuple Square(Int): Shape {
-  fn area() = self.0 * self.0
-}
-tuple Rectangle(Int, Int): Shape {
-  fn area() = self.0 * self.1
-}
-tuple Metre(Float): Shape {
-  static fn fromInt(v: Int) -> Metre {
-    return Metre(v)
-  }
-  fn toFloat() -> Float {
-    return self.0
-  }
-}
-`A Cat is new a new type of animal
-record Cat(
+User = {
-  name: Option[Str],
-  age: Int
+  name: Str
-): ToStr {
+  email: Str
-  static fn withName(name: Str): Cat(name: name, age: 0)
-  static fn withAge(age: Int): Cat(name: "", age: age)
-  fn init() {
-    printLn("called init")
-    require(name.isNotEmpty()) {
-      "name shouldn't be empty"
-    }
-    ensure(name.size > 20) {
-      ValidationErr("name too long")
-    }
-  }
-  fn deinit() {
-    printLn("called deinit")
-  }
-  fn fullname() -> Str {
-    return "${self.name} ${self.age}"
-  }
-  override fn toStr() -> Str {
-    return "Cat<${fullname()}, ${age}>"
-  }
-}
-record Response(
-  body: Buffer = emptyBuffer(),
-  headers: Map[Str, Str] = emptyMap(),
-  status: Int = 0,
+  todos: List(Todo)
-) {
-  fn header(kv: Pair): Self {
-    headers.add(kv)
-  }
-  fn body(b: Buffer): Self {
-    body = b
-  }
-  fn status(v int): Self {
-    status = v
-  }
-}
-record LoopScope(running: Bool) {
-  fn stop() {
-    self.running = False
-  }
-}
-fn loop(scope: LoopScope = LoopScope(), cond: Option<() -> Bool> = None(), builder: LoopScope.() -> Unit) {
-  scope.apply(builder)
-  if cond is Some {
-    if cond() == True && scope.running == True {
-      loop(scope, cond, builder)
-    }
-  } else {
-    if scope.running == True {
-      loop(scope, cond, builder)
-    }
-  }
-}
-fn example() {
-  val items = listOf(1, 2, 3, 4, 5)
-  items.each { i ->
-    if i == 2 {
-      continue()
-    }
-    if i == 4 {
-      break()
-    }
-  }
-  range(0, 10).step(1).each { i ->
-    print("int ${i}")
-  }
-  loop().cond({ i < 5 }).do {
-    print("forever")
-  }
-  loop {
-    if (a > 5) {
-      break()
-    }
-  }
-  val list = "a b c d e f g h i j".split(" ")
-  list.groupBy(3) { group ->
-    puts group.join ""
-  }
-}
-@result()
-fn mkPerson(name: Str, age: Int) -> Result<Person, ValidationError> = result {
-  Person(validName(name).bind(), validAge(age).bind())
-}
-@handler("GET", "/posts")
-fn getPosts() -> List<Post> {
-  return listOf(Post(id: 123))
-}
-fn handler(req: Request) -> Response {
-  return Response()
-    .status(2)
-    .body("213")
-    .headers("1" => "2")
-}
-fn hasFlag(b: bool, d: List) {
-  return data
-}
-record Greeter(name: String) {
-  fn greet() {
-    println("Hello, ${name}")
-  }
-}
-fn main(args: List[String]) {
-  let g = Greeter(name: "abc")
-  g = g.copy(
-    name = "123"
-  )
-  Greeter(...g, name: "123")
 }
-fn main() {
-  val a = (1 * 5) + (2 + 3)
-  match a {
+Todo = {
-    case a < b => {
-      printLn(a != b)
+  title: Str
-    }
-    case a > 9 => {
-      printLn(a == 9)
-    }
-    case a < 9 => {
-      printLn(b == 0)
-    }
-    case _ => {
-      printLn(a == 9)
-    }
-  }
-  val list = listOf<Shape>(Circle(123), Square(20))
-  match list.get(0) {
-    case Circle(c): {
-      printLn("${c}")
-    }
-    case Square(a): {
-      printLn("${a}")
-    }
-  }
 }
-lib LibM
-  fun sqrt(x: LibC::Double) -> LibC::Double
-  fun pow(x: LibC::Double, y: LibC::Double) -> LibC::Double
-end
-primitive Int : Comparable, ToStr
-  fn abs() -> Float
-  fn ceil() -> Float
-  fn floor() -> Float
-  fn round() -> Float
-  fn trunc() -> Float
-  fun log() -> Float
-  fun log2() -> Float
-  fun log10() -> Float
-  fun logb() -> Float
-  fun pow(y: Float) -> Float
-    LibM.pow(self, y)
-  end
-  fun pow(y: Int) -> Float
-    pow(y.toFloat())
-  end
-  fun sqrt() -> Float
-    LibM.sqrt(self)
-  end
-end
-primitive Str : Comparable, ToStr
-  val data: Buffer
-  get(i: Int) -> Char =
-    data.get(i)
-  contains(search: Str) -> Bool
-  indexOf(sub: Str) -> Int
-  fun test(pattern: Regex) -> Bool
-  end
-  fun search(key: Str) -> (Int, Bool)
-    val (low, mid, high) = (0, 0, n.numItems)
-    while low < high do
-      mid = (low + high) / 2
-      val cmp = key > n.items[mid].key
-      low = cmp > 0 ? mid + 1 : low
-      high = cmp < 0 ? mid : high
-      if cmp == 0 then
-        return (mid, True)
-      end
-    end
-    return (low, False)
-  end
-  fun startsWith(search: str) -> Bool
-  end
-  fun endsWith(search: Str) -> Bool
-  end
-  fun concat(other: Str) -> Str
-    s + other
-  end
-  fun toStr() -> Str
-  end
-  fun matchPattern(pattern: Regex) -> []Str
-  end
-  fun matchAll(pattern: Regex) -> []Str
-  end
-  fun padStart(sub: Str, count: Int) -> Str
-  end
-  fun padEnd(sub: Str, count: Int) -> Str
-  end
-  fun repeat(count: Int) -> Str
-  end
-  fun replace(pattern: Regex, sub: Str) -> Str
-  end
-  fun replaceAll(pattern: Regex, sub: Str) -> Str
-  end
-  fun search(pattern: Regex) -> Str
-  end
-  fun slice(start: Int, e: Int) -> Str
-  end
-  fun split(separator: Str, limit: Int) -> []Str
-  end
-  fun sub(start: Int, e: Int) -> Str
-  end
-  fun toLower() -> Str
-  end
-end
-record Response(a): Option(a, _)
-  val body: Buffer = emptyBuffer()
-  val headers: Map(Str, Str) = emptyMap()
-  val status: Int = 0
-  fun header(k: Str, v: Str) -> Response
-    headers.add(kv)
-  end
-  fun body(buf: Buffer) -> Response
-    body = buf
-    if something > 0 then
-        Red
-    else if something == 0 then
-        Yellow
-    else
-        Green
-    end
-  end
-  fun status(v: Int) -> Response
-    status = v
-  end
-  fun delat()
-    User::create()
+User()
-    .name("John Doe")
+  .name("John Doe")
-    .email("john@example.com")
+  .email("john@example.com")
-    .todo(Todo::create().title("Make pizza"))
+  .todo(Todo().title("Make pizza"))
-    .todo(Todo::create().title("Finish Toasty"))
+  .todo(Todo().title("Finish Toasty"))
-    .todo(Todo::create().title("Sleep"))
+  .todo(Todo().title("Sleep"))
-  end
-end
-trait Result(a, b) permits Ok(a), Err(b)
-  fn ok() -> a
-  fn err() -> b
-  fn okOrElse(default: a) -> a
-  fn isOk() -> Bool
-  fn isErr() -> Bool
-tuple Ok(a): Result(a, _)
-  fn ok() -> a = self.0
-  fn err() -> fail("called 'Result.err()' on an 'Ok' value")
-  fn okOrElse(default: a) -> a = self.0
-  fn map(cb: fn(a) -> b) -> Result(b) = Ok(cb(self.0))
-tuple Err(a): Result(_, a)
-  fn get() -> a = fail("called 'Result.get()' on an 'Err' value")
-  fn err() -> self.1
-  fn okOrElse(default: a) -> a = default
-  fn mapErr(cb: fn(a) -> b) -> Result(_, b) = Err(cb(self.1))
-trait Option(a) permits Some(a), None
-  fn some() -> a
-  fn someOrElse(default: a) -> a
-  fn map(cb: fn(a) -> b) -> Option(b)
-tuple Some(a): Option(a)
-  fn some() -> a = self.0
-  fn someOrElse(default: a) -> a = self.0
-  fn map(cb: fn(a) -> b) -> Option(b) = Some(cb(self.0))
-tuple None(a): Option(_)
-  fn some() -> a = fail("called 'Option.some()' on an 'Some' value")
-  fn someOrElse(default: a) -> a = default
-  fn stoplightColor(something: Int) -> Color =
-    if something > 0 then
-        Red
-    else if something == 0 then
-        Yellow
-    else
-        Green
-  fn stoplightStr(stoplightColor: Color) -> Str
-    match stoplightColor
-      Red -> "red"
-      Green -> "green"
-      Yellow -> "yellow"
-  fun stoplightStr(stoplightColor: Color) -> Str
-    when stoplightColor is
-      Red -> "red"
-      Green -> "green"
-      Yellow -> "yellow"
-    end
-  end
-record Response(a): Option(a, _)
-  val body: Buffer = emptyBuffer()
-  val headers: Map(Str, Str) = emptyMap()
-  val status: Int = 0
-  fn header(k: Str, v: Str) -> Response =
-    headers.add(kv)
-    self
-  fn body(buf: Buffer) -> Response =
-    body = buf
-    self
-  fn status(v: Int) -> Response =
-    status = v
-    self
-record Response(
-  body: Buffer = emptyBuffer()
-  headers: Map(Str, Str) = emptyMap()
-  status: Int = 0
-): Option(a, _)
-  fn header(k: Str, v: Str) -> Response =
-    headers.add(kv)
-    self
-  fn body(buf: Buffer) -> Response =
-    body = buf
-    self
-  fn status(v: Int) -> Response =
-    status = v
-    self
+fn stoplightColor(something: Int) -> Color =
+  if something > 0 then
+      Red
+  else if something == 0 then
+      Yellow
+  else
+      Green
 Response = {
   body: Buffer = emptyBuffer()
@@ -432,27 +37,15 @@ Response = {
   status: Int = 0
 }
-Response\header(k: Str, v: Str) -> Response =
-  headers.add(kv)
-  self
-Response\body(buf: Buffer) -> Response =
-  body = buf
-  self
-Response\status(v: Int) -> Response =
-  status = v
-  self
 main() -> Unit =
   printLn("123")
 main() -> Int, Err =
     Stdout.line! "There are $(total) animals."
+# calculate to str
 Int\toStr() -> Str =
   todo
-  # calculate to str
 Int::random() -> Int =
   24
@@ -463,10 +56,10 @@ sub(arg1: Int, arg2: Int) -> Int =
   local1 - local2
 addAndStringify(num1: Int, num2: Int) -> Str =
-    (num1 + num2).toStr()
+  (num1 + num2).toStr()
 factorial(x: Int) -> Int =
-  if x < 2 then
+  if x < 2
     x
   else
     x * factorial(x - 1)
@@ -477,7 +70,6 @@ Result(a, b) =
 ```
 Checks whether the result is an `Ok` value
 isOk(Ok(1)) # => True
 isOk(Err(Nil)) # => False
 ```
@@ -510,7 +102,8 @@ User = {
 }
 user = User(1, 2, 3)
-params = {"one" => 1, "two" => 2, "three" => 3}
+params = Map("one" => 1, "two" => 2, "three" => 3)
+arr = List(1, 2, 3, 4)
 User\isAuthorized() -> Bool =
   False
@@ -552,4 +145,62 @@ match v
 names = ["Sam", "Lee", "Ari"]
 names.append("Jess")
-names.map(\num -> num * 2)
+names.map(\num -> num * 2)
+module std/http
+import std/path
+import std/os
+import std/http/content_type
+import std/libc
+extern sqrt(x: libc.Double) -> libc.Double
+extern pow(x: libc.Double, y: libc.Double) -> libc.Double
+WriteError = EOF | Closed
+Writer = (
+	write(p: Str | Buffer) -> Int | WriteError
+)
+ReadError = EOF | Closed
+Reader = (
+	read(p: Str | Buffer) -> Int | ReadError
+)
+IO = Reader + Writer
+IOError = ReadError | WriteError
+Response(
+  headers: Map[Str, Str]
+  body: Str | Buffer | IO
+  status: Int
+)
+createFileResponse(path: Str) -> Response | IOError =
+  content := content_type.fromExt(path.ext())
+  data := os.readFile(file)?
+  Response()
+    .header("Content-Type", content)
+    .body(data)
+    .status(200)
+index() -> Response =
+  createFileResponse("index.html")
+serveFile(file: Str) -> Response | IOError =
+  ext := path::ext(file)
+  content := contentTypeFromExt(ext)
+  data := os.readFile(file)?
+  Response()
+    .header("Content-Type", content)
+    .body(data)
+    .status(200)
+http.createFileResponse("./src/sample.plum")
+http.index()
+http.serveFile("./src/sample.plum")
+g = Greeter(name: "abc")
+g = Greeter(...g, name: "123")

tooling/vscode-plum/language-configuration.json CHANGED Viewed

@@ -1,7 +1,11 @@
 {
   "comments": {
     // symbol used for single line comment. Remove this entry if your language does not support line comments
-    "lineComment": "//",
+    "lineComment": "#",
+    "blockComment": [
+      "```",
+      "```"
+    ]
   },
   // symbols used as brackets
   "brackets": [
@@ -39,7 +43,11 @@
     [
       "'",
       "'"
-    ]
+    ],
+    [
+      "```",
+      "```"
+    ],
   ],
   // symbols that can be used to surround a selection
   "surroundingPairs": [
@@ -62,6 +70,10 @@
     [
       "'",
       "'"
-    ]
+    ],
+    [
+      "```",
+      "```"
+    ],
   ]
 }

tooling/vscode-plum/syntaxes/plum.tmLanguage.json ADDED Viewed

@@ -0,0 +1,182 @@
+{
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  "name": "plum",
+  "patterns": [
+    {
+      "include": "#comments"
+    },
+    {
+      "include": "#keywords"
+    },
+    {
+      "include": "#strings"
+    },
+    {
+      "include": "#constant"
+    },
+    {
+      "include": "#entity"
+    },
+    {
+      "include": "#discards"
+    }
+  ],
+  "repository": {
+    "keywords": {
+      "patterns": [
+        {
+          "name": "keyword.control.plum",
+          "match": "\\b(return|continue|break|match|if|else|while|for|module|as|is|import|assert|todo|crash)\\b"
+        },
+        {
+          "name": "keyword.operator.arrow.plum",
+          "match": "(<\\-|\\->)"
+        },
+        {
+          "name": "keyword.operator.pipe.plum",
+          "match": "\\|>"
+        },
+        {
+          "name": "keyword.operator.splat.plum",
+          "match": "\\.\\."
+        },
+        {
+          "name": "keyword.operator.comparison.plum",
+          "match": "(==|!=)"
+        },
+        {
+          "name": "keyword.operator.comparison.float.plum",
+          "match": "(<=\\.|>=\\.|<\\.|>\\.)"
+        },
+        {
+          "name": "keyword.operator.comparison.int.plum",
+          "match": "(<=|>=|<|>)"
+        },
+        {
+          "name": "keyword.operator.logical.plum",
+          "match": "(&&|\\|\\|)"
+        },
+        {
+          "name": "keyword.operator.arithmetic.float.plum",
+          "match": "(\\+\\.|\\-\\.|/\\.|\\*\\.)"
+        },
+        {
+          "name": "keyword.operator.arithmetic.int.plum",
+          "match": "(\\+|\\-|/|\\*|%)"
+        },
+        {
+          "name": "keyword.operator.assignment.plum",
+          "match": "="
+        }
+      ]
+    },
+    "strings": {
+      "name": "string.quoted.double.plum",
+      "begin": "\"",
+      "end": "\"",
+      "patterns": [
+        {
+          "name": "constant.character.escape.plum",
+          "match": "\\\\."
+        }
+      ]
+    },
+    "comments": {
+      "patterns": [
+        {
+          "name": "comment.line.plum",
+          "match": "#.*"
+        },
+        {
+          "begin": "```",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.comment.begin.plum"
+            }
+          },
+          "end": "```",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.comment.end.plum"
+            }
+          },
+          "name": "comment.block.plum"
+        }
+      ]
+    },
+    "constant": {
+      "patterns": [
+        {
+          "include": "#binary_number"
+        },
+        {
+          "include": "#octal_number"
+        },
+        {
+          "include": "#hexadecimal_number"
+        },
+        {
+          "include": "#decimal_number"
+        },
+        {
+          "include": "#boolean"
+        },
+        {
+          "name": "entity.name.type.plum",
+          "match": "[[:upper:]][[:alnum:]]*"
+        }
+      ]
+    },
+    "binary_number": {
+      "name": "constant.numeric.binary.plum",
+      "match": "\\b0[bB]0*1[01_]*\\b",
+      "patterns": []
+    },
+    "octal_number": {
+      "name": "constant.numeric.octal.plum",
+      "match": "\\b0[oO]0*[1-7][0-7]*\\b",
+      "patterns": []
+    },
+    "decimal_number": {
+      "name": "constant.numeric.decimal.plum",
+      "match": "\\b(0*[1-9][0-9_]*|0)(\\.(0*[1-9][0-9_]*|0)?(e-?0*[1-9][0-9]*)?)?\\b",
+      "patterns": []
+    },
+    "hexadecimal_number": {
+      "name": "constant.numeric.hexadecimal.plum",
+      "match": "\\b0[xX]0*[1-9a-zA-Z][0-9a-zA-Z]*\\b",
+      "patterns": []
+    },
+    "entity": {
+      "patterns": [
+        {
+          "begin": "\\b([[:lower:]][[:word:]]*)\\b[[:space:]]*\\(",
+          "end": "\\)",
+          "patterns": [
+            {
+              "include": "$self"
+            }
+          ],
+          "captures": {
+            "1": {
+              "name": "entity.name.function.plum"
+            }
+          }
+        },
+        {
+          "name": "variable.parameter.plum",
+          "match": "\\b([[:lower:]][[:word:]]*):\\s"
+        },
+        {
+          "name": "entity.name.namespace.plum",
+          "match": "\\b([[:lower:]][[:word:]]*):"
+        }
+      ]
+    },
+    "discards": {
+      "name": "comment.unused.plum",
+      "match": "\\b_(?:[[:word:]]+)?\\b"
+    }
+  },
+  "scopeName": "source.plum"
+}

~repos /plum

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

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