plum

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

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

2a44b7e0 — Peter John

more syntax

Files changed (5) hide show

sample.ks +266 -5
scratch.hs +10 -10
std/json.mi +13 -9
tree-sitter-kestrel/test/corpus/fn.txt +1 -1
tree-sitter-kestrel/test/corpus/match.txt +76 -0

sample.ks CHANGED Viewed

@@ -4,7 +4,6 @@ import std.{List, Map, Math, Random}
 Int.random()
 Float.random()
 Float.PI
 trait BinaryOp<T> {
@@ -84,11 +83,11 @@ record Cat(
     printLn("called deinit")
   }
-  fn fullname(): Str {
+  fn fullname() -> Str {
     return "${self.name} ${self.age}"
   }
-  override fn toStr(): Str {
+  override fn toStr() -> Str {
     return "Cat<${fullname()}, ${age}>"
   }
 }
@@ -188,9 +187,13 @@ fn mkPerson(name: Str, age: Int) -> Result<Person, ValidationError> = result {
   Person(validName(name).bind(), validAge(age).bind())
 }
-@get("/posts")
+@handler("GET", "/posts")
+fn getPosts() -> List<Post> {
+  return listOf(Post(id: 123))
+}
 fn handler(req: Request) -> Response {
-  Response()
+  return Response()
     .status(2)
     .body("213")
     .headers("1" => "2")
@@ -213,3 +216,261 @@ fn main(args: List[String]) {
   )
   Greeter(...g, name: "123")
 }
+fn main() {
+  val a = (1 * 5) + (2 + 3)
+  match a {
+    case a < b => {
+      printLn(a != b)
+    }
+    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}")
+    }
+  }
+}
+birds = 3
+iguanas = 2
+total = addAndStringify birds iguanas
+main() =
+    Stdout.line! "There are $(total) animals."
+addAndStringify(num1: Int, num2: Int) -> Str =
+    (num1 + num2) |> Int.toStr()
+addAndStringify = \num1: Int, num2: Int -> Str
+    Num.toStr (num1 + num2)
+val user = User(1, 2, 3)
+params = {"one" => 1, "two" => 2, "three" => 3}
+params.each do |k,v|
+  puts("#{k}=#{v}")
+end
+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
+  fun get(i: Int) -> Char
+    return data.get(i)
+  end
+  fun contains(search: Str) -> Bool
+  end
+  fun indexOf(sub: Str) -> Int
+  end
+  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
+  end
+  fun status(v: Int) -> Response
+    status = v
+  end
+end
+User::create()
+  .name("John Doe")
+  .email("john@example.com")
+  .todo(Todo::create().title("Make pizza"))
+  .todo(Todo::create().title("Finish Toasty"))
+  .todo(Todo::create().title("Sleep"))
+trait Result(a, b) permits Ok(a), Err(b)
+  fn ok() -> a
+  fn err() -> b
+  fn okOrElse(default: a) -> a
+end
+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 =
+      when stoplightColor is
+        Red -> "red"
+        Green -> "green"
+        Yellow -> "yellow"
+      end
+fn dddd(data: Option(Str)) -> Str =
+  if Some(v) = data then
+    v.subString(0, 3)
+  else if a ==  b then
+    "123"
+  else
+    "1231"
+fn dddd(data: Option(Str)) -> Str =
+  if Some(v) = data then
+    v.subString(0, 3)
+  else if a ==  b then
+    "123"
+  else
+    if a < 100 then
+      printLn("Data")
+    else
+      println("No Data")
+names = ["Sam", "Lee", "Ari"]
+names |> List.append("Jess")
+names |> List.map(\num -> num * 2)
+List.map([1, 2, 3], \num -> num * 2)
+range data, 1, 2, do k,v
+  puts(k, v)
+end

scratch.hs CHANGED Viewed

@@ -2,17 +2,17 @@ data.price?.take_if(|a| a != "")
 math.sqrt(math.pow(math.mod(1 + 2, 3), 2))
 if v == None
-  error.Error
+    error.Error
 else
-  c * 20
+    c * 20
-if v == None
+if v == None then
-  error.Error
+    error.Error
 else
-  Some(c) := v
+    Some(c) := v
-  c * 20
+    c * 20
-match v
+match v is
-  None -> return error.Error
+    None -> return error.Error
-  Some(c) ->
+    Some(c) ->
-    return c * 20
+      return c * 20

std/json.mi CHANGED Viewed

@@ -5,7 +5,7 @@ trait Json permits JsonStr, JsonBool, JsonNull, JsonFloat, JsonInt, JsonObject,
   fn parse() -> T
 }
-tuple JsonObject(Map[str, Json]) {
+tuple JsonObject(Map[str, Json]): Json {
   type = JsonObject
   fn parse() -> JsonObject {
@@ -14,27 +14,27 @@ tuple JsonObject(Map[str, Json]) {
 }
-tuple JsonArray(List[Json]) {
+tuple JsonArray(List[Json]): Json {
   fn parse() {}
 }
-tuple JsonInt(Int) {
+tuple JsonInt(Int): Json {
 }
-tuple JsonFloat(Float) {
+tuple JsonFloat(Float): Json {
 }
-tuple JsonString(Str) {
+tuple JsonString(Str): Json {
 }
-tuple JsonBool(Bool) {
+tuple JsonBool(Bool): Json {
 }
-tuple JsonNull {
+tuple JsonNull: Json {
 }
 fn Json.parse(src: str | Buffer | IO): Json | ParseError =
@@ -56,11 +56,15 @@ record JsonParser(
 fn JsonParser.withSrc(src: str | Buffer | IO): JsonParser =
   JsonParser(_buf = src)
-fn _is_space(c: U32): Bool => (c == ' ') or ((c >= '\t') and (c <= '\r'))
+fn isSpace(c: U32): Bool => (c == ' ') or ((c >= '\t') and (c <= '\r'))
-fn _is_delim(c: U32): Bool =>
+fn isDelim(c: U32): Bool =>
     (c == ',') or (c == '}') or (c == ':') or (c == ']') or (_is_space(c)) or (c == 0)
+fn isDigit(c: U32) -> Bool {
+  return (c >= '0') && (c <= '9')
+}
 fn _is_digit(c: U32): Bool => (c >= '0') and (c <= '9')
 fn (p: Parser) _err(msg: str) => printLn(msg)

tree-sitter-kestrel/test/corpus/fn.txt CHANGED Viewed

@@ -151,7 +151,7 @@ fn fetchAllPosts(req: Request) -> Response {
 fn - generics
 ================================================================================
-fn add[T: Int, Q: String + Compare](a: List[T], b: List[Q]) -> List[T] {
+add[T: Int, Q: String + Compare](a: List[T], b: List[Q]) -> List[T] {
 }
 --------------------------------------------------------------------------------

tree-sitter-kestrel/test/corpus/match.txt CHANGED Viewed

@@ -0,0 +1,76 @@
+================================================================================
+statement - match
+================================================================================
+fn main() {
+  val a = (1 * 5) + (2 + 3)
+  match a {
+    case a < b => {
+      printLn(a != b)
+    }
+    case a > 9 => {
+      printLn(a == 9)
+    }
+    case a < 9 => {
+      printLn(b == 0)
+    }
+    case _ => {
+      printLn(a == 9)
+    }
+  }
+}
+--------------------------------------------------------------------------------
+(source
+  (test
+    (string
+      (string_start)
+      (string_end))
+    (lambda
+      (identifier)
+      (body
+        (assignment_statement
+          (identifier)
+          (binary_operator
+            (parenthesized_expression
+              (binary_operator
+                (integer)
+                (integer)))
+            (parenthesized_expression
+              (binary_operator
+                (integer)
+                (integer)))))
+        (if_statement
+          (comparison_operator
+            (identifier)
+            (identifier))
+          (block
+            (assert_statement
+              (comparison_operator
+                (identifier)
+                (identifier))))
+          (else_if_clause
+            (comparison_operator
+              (identifier)
+              (integer))
+            (block
+              (assert_statement
+                (comparison_operator
+                  (identifier)
+                  (integer)))))
+          (else_if_clause
+            (comparison_operator
+              (identifier)
+              (integer))
+            (block
+              (assert_statement
+                (comparison_operator
+                  (identifier)
+                  (integer)))))
+          (else_clause
+            (block
+              (assert_statement
+                (comparison_operator
+                  (identifier)
+                  (integer))))))))))

~repos /plum

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

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