plum

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

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

e502e58c — pyrossh

add more code

Files changed (9) hide show

readme.md +31 -10
scratch.pc +67 -1
std/bool.mi +1 -3
std/http.mi +9 -9
std/json.mi +339 -0
std/list.mi +9 -0
std/map.mi +19 -10
std/math.mi +47 -3
std/result.mi +10 -10

readme.md CHANGED Viewed

@@ -81,6 +81,17 @@ fn (c: Cat) talk() =
 fn (c: Cat) toStr(): str =
   "Cat<{c.fullname()}, ${c.age}>"
+enum Temperature =
+  | celsius(float)
+  | fahrenheit(float)
+fn (s: Temperature) to_str(): 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"
 type MapCallback = fn(v: a): v
 trait Comparable(
@@ -91,17 +102,27 @@ trait ToStr(
   fn to_str(): str
 )
-enum Temperature =
+fn connect_db(conn_url: str): DB! =
-  | celsius(float)
-  | fahrenheit(float)
+  db := postgres_connect(conn_url)?
+  db.exec("select 1")?
-fn (s: Temperature) to_str(): str =
+fn db_select(conn_url: str): void! =
-  match s
-    celsius(t) && t > 30 -> "${t}C is above 30 celsius"
+  db := new_db(conn_url)?
-    celsius(t) -> "${t}C is below 30 celsius"
+  db.exec("select 1")?
-    fahrenheit(t) && t > 86 -> "${t}F is above 86 fahrenheit"
-    fahrenheit(t) -> "${t}F is below 86 fahrenheit"
+record DB(conn_url: str)
+error DatabaseError
+  DatabaseNotOnline(conn_url: str)
+  RowReadFailure(query: str)
+fn new_db(conn_url: str) DB! =
+  db := DB(conn_url: str)
+  online := db.check()?
+  if !online
+    Err(errors.DatabaseNotOnline(conn_url))
+  else
+    db
 test("talks") |t|
   c := Cat(name: "123", age: 1)
@@ -343,7 +364,7 @@ for v := range list
   sum += k + v
 ```
-**For Custom Iterator**
+**Range Over Function**
 ```rb
 type Seq0 = fn(yield: fn(): bool): bool

scratch.pc CHANGED Viewed

@@ -215,4 +215,70 @@ repeat(|_| i < 9) |i|
   pass
 repeat(|_| a > b && c < d) |i|
-  pass
+  pass
+let v = list.of(1, 2, 3)
+  |> list.add(1, 2)
+  |> list.get(0)
+let v = list.of(1, 2, 3)
+  ..add(1, 2)
+  ..get(0)
+if v == nil
+  error.Error
+else
+  c * 20
+if v == None
+  error.Error
+else
+  Some(c) := v
+  c * 20
+match v
+  None -> return error.Error
+  Some(c) ->
+    return c * 20
+#[json]
+record UserData(
+  id: int,
+  name: str,
+  roles: List[str]
+)
+`This is to follow the http standards
+trait Error(
+  fn code(): int
+  fn msg(): str
+)
+`derive implements this func
+`Derive is a compiler plugin/generator similar to dart
+`which runs automatically. Its not a macro more like a decorator.
+fn UserData.fromJsonStr(data: str): UserData | JsonParseError =
+  // JsonParseError(line: line, pos: post, object: "UserData")
+  pass
+type FetchDataError =  FetchError | IOError |  JsonParseError
+fn fetch_data(route: str): map[str, any] | UserData | FetchError | IOError |  JsonParseError =
+  res := fetch(route)?
+  data := res.body.read_all()?
+  parse_json(data)?
+fn main() =
+  res := fetch_data()
+  if res is UserData
+    printLn("Success ${res.id}")
+  else if res is IOError
+    printLn("IO failed")
+  else if res is Error
+    printLn("generic error ${res.msg()}")
+  when res
+    UserData -> printLn("Success ${res.id}")
+    IOError -> printLn("IO failed")
+    _ -> printLn("generic error ${res.msg()}")

std/bool.mi CHANGED Viewed

@@ -1,8 +1,6 @@
 module std
-enum bool =
+type bool = true | false
-  | true
-  | false
 fn (x: bool) op_eq(y: bool) = x == y
 fn (x: bool) op_ne(y: bool) = x != y

std/http.mi CHANGED Viewed

@@ -1,21 +1,21 @@
+module std/http
 import std/path
 import std/os
 import std/http/content_type
 #[builder]
 record Response(
-  headers: map[str, str]
+  headers: Map[str, str]
-  body: Buffer
+  body: str | Buffer | IO
   status: int
 )
-fn file_response(file: str): Response! =
+fn file_response(path: str): Response | IOError =
-  ext := path::ext(file)
-  content := contentTypeFromExt(ext)
+  content := contentTypeFromExt(path.ext())
-  data := try os.read_file(file)
+  data := os.readFile(file)?
   Response()
     .header("Content-Type", content)
-    .header("Content-Length", "2")
     .body(data)
     .status(200)
@@ -24,10 +24,10 @@ fn index(): Response! =
   file_response("index.html")
 #[get("/public/<...>")]
-fn public(file: str): Response! =
+fn public(file: str): Response | IOError =
   ext := path::ext(file)
   content := contentTypeFromExt(ext)
-  data := os.readFile?(file)
+  data := os.readFile(file)?
   Response()
     .header("Content-Type", content)
     .body(data)

std/json.mi ADDED Viewed

@@ -0,0 +1,339 @@
+module std/json
+type Json = Map[str, Json] | List[Json] | int | float | str | bool | nil
+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(
+  line: str
+  pos:  str
+)
+record JsonParser(
+  cur: int = ' '
+  _pos: int = 0
+  _next: int = ' '
+  _buf: str | Buffer | IO
+)
+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 _is_delim(c: U32): Bool =>
+    (c == ',') or (c == '}') or (c == ':') or (c == ']') or (_is_space(c)) or (c == 0)
+fn _is_digit(c: U32): Bool => (c >= '0') and (c <= '9')
+fn (p: Parser) _err(msg: str) => printLn(msg)
+fn _get_next_raw(): U32 =>
+  try
+      _inc_pos()
+      let chr: (U32, U8) = _buf.utf32(_pos-1)?
+      cur = _next = chr._1
+  else
+      cur = _next = 0
+  end
+fn _get_next(): U32 =>
+  try
+      repeat
+          _inc_pos()
+          let chr: (U32, U8) = _buf.utf32(_pos-1)?
+          cur = _next = chr._1
+      until not _is_space(cur) end
+      cur
+  else
+      cur = _next = 0
+  end
+fn _expect(chr: U32, msg: String): Bool =>
+  if cur == chr then
+      _get_next()
+      true
+  else
+      _err(msg)
+      false
+  end
+fn _inc_pos(i: ISize = 1) => _pos = _pos.add(i)
+fn (p JsonParser) parse(): Json =
+  match parser.get_next()
+    '{' -> p.parseObject()
+    '[' -> p.parseList()
+    _ -> nil
+fn (p JsonParser) parseObject(): Map[str, Json] =
+  object := Map[str, Json]()
+  p._get_next() // '{'
+  while true
+    if p.cur != '"'
+      p._err("JSON: Object: expected '\"'\n")
+      break
+    val_key := p.parse_string()
+    if !p._expect(':', "JSON: Object: expected ':'\n")
+      break
+    val_val := Json(nil)
+    when p.cur
+      '{' ->
+        val_val = parse_object(p)
+        p._expect('}', "JSON: Object: expected '}'\n")
+      '[' ->
+        val_val = parse_array(p)
+        p._expect(']', "JSON: Object: expected ']'\n")
+      '"' ->
+        val_val = p.parseString()
+      'n' ->
+        val_val = try p._get_n()? end // null?
+      't' ->
+        val_val = try p._get_t()? end // true?
+      'f' ->
+        val_val = try p._get_f()? end // false?
+      ch ->
+        if p._is_digit(ch) || ch == '.'
+          val_val = p.parseNum()
+        else
+          p._err("invalid value\n")
+          break
+    object.set(val_key, val_val)
+    if p.cur == '}'
+      break
+    if !p._expect(',', "JSON: Object: expected ','\n")
+      printLn("failed at: %s\n".cstring(), val_key.cstring())
+  object
+fn (p: JsonParser) parseList(): List[Json] =
+  p._get_next() // '['
+  while true
+    when p.cur
+      '{' -> _values.push(JSONObject.create_with_parser(p)); p._expect('}', "JSON: Array: expected object delimiter\n")
+      '[' -> _values.push(JSONArray.create_with_parser(p)); p._expect(']', "JSON: Array: expected array delimiter\n")
+      '"' -> _values.push(p.parseString())
+      't' ->
+        t: Bool := p._get_t()?
+        _values.push(t)
+      'f' ->
+        f: Bool := p._get_f()?
+        _values.push(f)
+      'n' ->
+        n: None := p._get_n()?
+        _values.push(n)
+      _ ->
+        if p._is_digit(p.cur)
+          let n = p.parseNum()
+          _values.push(n)
+    if p.cur == ']'
+      break
+    if !p._expect(',', "JSON: Array: expected ','\n")
+      break
+fn (p: Parser) parseUtf16(): int =
+  result := 0
+  count := 0
+  while count <= 4
+    p._get_next_raw()
+    if _is_digit(cur)
+      result = ((result << 4) or (cur - '0').i32())
+    else if (cur >= 'a') and (cur <= 'f')
+      result = ((result << 4) or ((cur - 'a').i32() + 10))
+    else if (cur >= 'A') and (cur <= 'F')
+      result = ((result << 4) or ((cur - 'A').i32() + 10))
+    count = count+1
+  result
+fn (p: JsonParser) parseStr(): str =
+  result := ""
+  while true
+    p._get_next_raw()
+    match cur
+      0 -> _err("JSON: parseString: expected '\"'\n"); return ""
+      '"' -> _get_next(); break
+      '\\' ->
+        match _next
+          '\\' -> result.push('\\'); p._get_next_raw()
+          '"' -> result.push('"'); p._get_next_raw()
+          '\'' -> result.push('\''); p._get_next_raw()
+          '/' -> result.push('/'); p._get_next_raw()
+          'b' -> result.push('\b'); p._get_next_raw()
+          'f' -> result.push('\f'); p._get_next_raw()
+          'n' -> result.push('\n'); p._get_next_raw()
+          'r' -> result.push('\r'); p._get_next_raw()
+          't' -> result.push('\t'); p._get_next_raw()
+          'u' ->
+            _get_next_raw()
+            ures := p.parseUtf16()
+            if ures < 0
+              _err("invalid utf escape\n")
+              break
+            result.push_utf32(ures.u32())
+      _ ->
+        result.push_utf32(cur.u32())
+    result
+fn (p: JsonParser) parseNum(): int | float =
+  result := ""
+  is_float := false
+  if cur == '-'
+    result.push('-')
+    _get_next_raw()
+  if cur == '.'
+      result.push('0')
+      result.push('.')
+      is_float = true
+      _get_next_raw()
+  else
+    while _is_digit(cur)
+      result.push(cur.u8())
+      _get_next_raw()
+    if cur == '.'
+      result.push('.')
+      _get_next_raw()
+  while _is_digit(cur)
+    result.push(cur.u8())
+    _get_next_raw()
+  is_exp := when cur
+    'e' ->
+      result.push('e'); _get_next_raw()
+      true
+    'E' ->
+      result.push('E'); _get_next_raw()
+      true
+    _ -> false
+  if is_exp
+    sign := when cur
+      '+' ->
+        result.push('+'); _get_next_raw()
+        true
+      '-' ->
+        result.push('-'); _get_next_raw()
+        true
+      _ -> false
+    if sign
+      while _is_digit(cur)
+        result.push(cur.u8())
+        _get_next_raw()
+  res := is_float ? result.f64() : result.i64()
+  if _is_space(cur)
+    _get_next() // skip to the next non-whitespace character
+  res
+fn _get_n(): None? =>
+    _get_next_raw()
+    if cur == 'u' then
+        _get_nu()?
+    else
+        error
+    end
+fn _get_nu(): None? =>
+    _get_next_raw()
+    if cur == 'l' then
+        _get_nul()?
+    else
+        error
+    end
+fn _get_nul(): None? =>
+    _get_next_raw()
+    if cur == 'l' then
+        _get_next()
+        None
+    else
+        error
+    end
+fn _get_t(): bool? =
+    _get_next_raw()
+    if cur == 'r' then
+        _get_tr()?
+    else
+        error
+    end
+fn _get_tr(): bool? =
+  _get_next_raw()
+  if cur == 'u' then
+      _get_tru()?
+  else
+      error
+  end
+fn _get_tru(): bool? =
+  _get_next_raw()
+  if cur == 'e' then
+      _get_next()
+      true
+  else
+      error
+  end
+fn _get_f(): bool? =
+  _get_next_raw()
+  if cur == 'a' then
+      _get_fa()?
+  else
+      error
+  end
+fn _get_fa(): bool? =
+  _get_next_raw()
+  if cur == 'l' then
+      _get_fal()?
+  else
+      error
+  end
+fn _get_fal(): bool? =
+  _get_next_raw()
+  if cur == 's' then
+    _get_fals()?
+  else
+      error
+  end
+fn _get_fals(): bool? =
+  _get_next_raw()
+  if cur == 'e' then
+      _get_next()
+      false
+  else
+      error
+  end
+test("parse int") |t|
+  assert Json.parse("123") == 123
+test("parse str") |t|
+  assert Json.parse(`"hello"`) == "hello"
+test("parse bool") |t|
+  assert Json.parse("true") == true
+  assert Json.parse("false") == false
+test("parse null") |t|
+  assert Json.parse("null") == nil
+test("parse array") |t|
+  assert Json.parse(`[]`) == List[Json]()
+  assert Json.parse(`[1, 2]`) == List.of[Json](1, 2)
+test("parse object") |t|
+  assert Json.parse(`{}`) == Map[str, Json]()
+  assert Json.parse(`{"a": 1, "b": 2}`) == Map.of[str, Json]("a" => 1, "b" => 2)p-

std/list.mi CHANGED Viewed

@@ -82,6 +82,15 @@ fn (l: list) contains(v: V): bool =
   `returns the index of an item in the list if present and comparable otherwise nil
   pass
+fn (l: list[T]) op_range(yld: fn(v: T): bool): bool =
+  `range over func for a list
+  current := l.head
+  while current != nil
+    if !yld(current.value)
+      return false
+    current = current.next
+  true
 fn (l: list) op_spread(other: list): list[A] =
   `combines this list with other list and returns a new list
   pass

std/map.mi CHANGED Viewed

@@ -4,25 +4,34 @@ record Pair[K: Comparable, V](k: K, v: V)
 `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.
-record map[K, V](
+record Map[K, V](
   items: list[Pair[K, V]]
 )
-fn map.of[K, V](kvs: ...Pair[K, V]): map[K, V] =
+fn Map.of[K, V](kvs: ...Pair[K, V]): map[K, V] =
   map[K, V]().add(kvs)
-fn (m: map) add(kvs: ...Pair[K, V]) =
+fn (m: Map) add(kvs: ...Pair[K, V]) =
   `adds the specified elements to the start of the list
-  items.add(pair)
+  items.add(kvs)
+fn (m: Map[K, V]) op_range(yld: fn(k: K, v: V): bool): bool =
-fn (m: Map) op_range() =
+  for item := range items
-  yield k, v
+    if !yld(item.k, item.v)
+      false
+  true
-fn (m: Map) put() =
+fn (m: Map[K, V]) get(k K): V? =
+  for k, v := range m
+    if k == k
+      return v
-  pass
+  nil
+fn (m: Map) put(k K, v V) =
+  list.add(Pair(k, v))
-fn (m: Map) put_if() =
+fn (m: Map) put_if(k K, v V) =
-  pass
+  if
 fn (m: Map) update() =
   pass

std/math.mi CHANGED Viewed

@@ -1,38 +1,64 @@
 module math
 `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 valur of i64
+`Lowest value of int
 const MIN_INT_VALUE = -0x8000_0000_0000_0000
-`Highest valur of i64
+`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
@@ -44,7 +70,25 @@ fn acos(v: float) =
     asin(-1v)
+`2**28
+const LARGE = 1 << 28
-fn acosh(v: float) = 0f
+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

std/result.mi CHANGED Viewed

@@ -2,44 +2,44 @@ module std
 `result is a type that represents either success ok or failure err.
 #[derive(Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
-enum result[T, E]
+enum result[T]
   | ok(T)
-  | err(E)
+  | err(error)
-fn (o result) is_ok(): bool =
+fn (r result) is_ok(): bool =
   match o
     ok(v) -> return true
     err(e) -> return false
-fn (o result) is_err(): bool =
+fn (r result) is_err(): bool =
   !o.is_ok()
-fn (o result[T, E]) ok(): option[T] =
+fn (r result[T, E]) ok(): option[T] =
   match o
     ok(v) -> some(v)
     err(e) -> none
-fn (o result[T, E]) err(): option[E] =
+fn (r result[T, E]) err(): option[E] =
   match o
     ok(v) -> none
     err(e) -> some(v)
-fn (o result) get(): T =
+fn (r result) get(): T =
   match o
     ok(v) -> v
     err(e) -> panic("called `result.get()` on a `none` value")
-fn (o result) default(d: T): T =
+fn (r result) default(d: T): T =
   match o
     ok(v) -> v
     err(e) -> d
-fn (o result) map(cb: fn(v: T)): result =
+fn (r result) map(cb: fn(v: T)): result =
   match o
     ok(v) -> cb(v)
     err(e) -> unreachable
-fn (o result) map_err(cb: fn(e: E)): result =
+fn (r result) map_err(cb: fn(e: E)): result =
   match o
     ok(v) -> unreachable
     err(e) -> cb(v)

~repos /plum

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

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