mt-lang 0.3.8 → 0.3.10

data/std/color.mt

@@ -50,8 +50,8 @@ function fabs(x: float) -> float:
 function fmod(x: float, m: float) -> float:
     # x - floor(x / m) * m
     let div = x / m
-    let fl = float<-(int<-(div))
-    if div < 0.0 and float<-(int<-(div)) != div:
+    let fl = float<-(int<-div)
+    if div < 0.0 and float<-(int<-div) != div:
         return x - (fl - 1.0) * m
     return x - fl * m
 
@@ -143,9 +143,9 @@ extending Color:
 
 
     public function to_hsl() -> (float, float, float):
-        let rf = float<-(this.r) / 255.0
-        let gf = float<-(this.g) / 255.0
-        let bf = float<-(this.b) / 255.0
+        let rf = float<-this.r / 255.0
+        let gf = float<-this.g / 255.0
+        let bf = float<-this.b / 255.0
 
         let mx = fmax(fmax(rf, gf), bf)
         let mn = fmin(fmin(rf, gf), bf)
@@ -171,9 +171,9 @@ extending Color:
 
 
     public function to_hsv() -> (float, float, float):
-        let rf = float<-(this.r) / 255.0
-        let gf = float<-(this.g) / 255.0
-        let bf = float<-(this.b) / 255.0
+        let rf = float<-this.r / 255.0
+        let gf = float<-this.g / 255.0
+        let bf = float<-this.b / 255.0
 
         let mx = fmax(fmax(rf, gf), bf)
         let mn = fmin(fmin(rf, gf), bf)
@@ -198,11 +198,11 @@ extending Color:
 
 
     public function lerp(target: Color, t: float) -> Color:
-        let r = float<-(this.r) + (float<-(target.r) - float<-(this.r)) * t
-        let g = float<-(this.g) + (float<-(target.g) - float<-(this.g)) * t
-        let b = float<-(this.b) + (float<-(target.b) - float<-(this.b)) * t
-        let a = float<-(this.a) + (float<-(target.a) - float<-(this.a)) * t
-        return Color(r = ubyte<-(r), g = ubyte<-(g), b = ubyte<-(b), a = ubyte<-(a))
+        let r = float<-this.r + (float<-target.r - float<-this.r) * t
+        let g = float<-this.g + (float<-target.g - float<-this.g) * t
+        let b = float<-this.b + (float<-target.b - float<-this.b) * t
+        let a = float<-this.a + (float<-target.a - float<-this.a) * t
+        return Color(r = ubyte<-r, g = ubyte<-g, b = ubyte<-b, a = ubyte<-a)
 
 
     public function alpha_blend(background: Color) -> Color:
@@ -211,33 +211,33 @@ extending Color:
         if this.a == 255:
             return this
 
-        let sa = float<-(this.a) / 255.0
-        let da = float<-(background.a) / 255.0
+        let sa = float<-this.a / 255.0
+        let da = float<-background.a / 255.0
 
-        let r_out = float<-(this.r) * sa + float<-(background.r) * da * (1.0 - sa)
-        let g_out = float<-(this.g) * sa + float<-(background.g) * da * (1.0 - sa)
-        let b_out = float<-(this.b) * sa + float<-(background.b) * da * (1.0 - sa)
+        let r_out = float<-this.r * sa + float<-background.r * da * (1.0 - sa)
+        let g_out = float<-this.g * sa + float<-background.g * da * (1.0 - sa)
+        let b_out = float<-this.b * sa + float<-background.b * da * (1.0 - sa)
         let a_out = sa + da * (1.0 - sa)
 
         return Color(
-            r = ubyte<-(r_out),
-            g = ubyte<-(g_out),
-            b = ubyte<-(b_out),
+            r = ubyte<-r_out,
+            g = ubyte<-g_out,
+            b = ubyte<-b_out,
             a = ubyte<-(a_out * 255.0)
         )
 
 
     public function scale(factor: float) -> Color:
-        let r = fmin(fmax(float<-(this.r) * factor, 0.0), 255.0)
-        let g = fmin(fmax(float<-(this.g) * factor, 0.0), 255.0)
-        let b = fmin(fmax(float<-(this.b) * factor, 0.0), 255.0)
-        return Color(r = ubyte<-(r), g = ubyte<-(g), b = ubyte<-(b), a = this.a)
+        let r = fmin(fmax(float<-this.r * factor, 0.0), 255.0)
+        let g = fmin(fmax(float<-this.g * factor, 0.0), 255.0)
+        let b = fmin(fmax(float<-this.b * factor, 0.0), 255.0)
+        return Color(r = ubyte<-r, g = ubyte<-g, b = ubyte<-b, a = this.a)
 
 
     public function multiply(other: Color) -> Color:
-        let r = ubyte<-(int<-((int<-(this.r) * int<-(other.r)) / 255))
-        let g = ubyte<-(int<-((int<-(this.g) * int<-(other.g)) / 255))
-        let b = ubyte<-(int<-((int<-(this.b) * int<-(other.b)) / 255))
+        let r = ubyte<-((int<-this.r * int<-other.r) / 255)
+        let g = ubyte<-((int<-this.g * int<-other.g) / 255)
+        let b = ubyte<-((int<-this.b * int<-other.b) / 255)
         return Color(r = r, g = g, b = b, a = this.a)
 
 

data/std/encoding.mt

@@ -47,15 +47,15 @@ public function decode_utf8_codepoint(text: str, byte_offset: ptr_uint) -> Optio
         return Option[uint].none
 
     if len == 1:
-        return Option[uint].some(value = uint<-(b0))
+        return Option[uint].some(value = uint<-b0)
 
     var codepoint: uint = (b0)
     if len == 2:
-        codepoint = codepoint & uint<-(0x1F)
+        codepoint = codepoint & uint<-0x1F
     else if len == 3:
-        codepoint = codepoint & uint<-(0x0F)
+        codepoint = codepoint & uint<-0x0F
     else if len == 4:
-        codepoint = codepoint & uint<-(0x07)
+        codepoint = codepoint & uint<-0x07
     var i: ptr_uint = 1
     while i < len:
         codepoint = (codepoint << 6) | uint<-(text.byte_at(byte_offset + i) & 0x3F)

data/std/graph.mt

@@ -36,8 +36,7 @@ extending HeapEntry:
             return 1
         else if da > db:
             return -1
-        else:
-            return 0
+        return 0
 
 
 public struct ShortestPaths:

data/std/hash.mt

@@ -16,10 +16,10 @@ extending int:
             let fnv: uint = 0x811C9DC5
             let prime: uint = 0x01000193
             var h = fnv
-            h = (h ^ (as_uint & uint<-(0xFF))) * prime
-            h = (h ^ ((as_uint >> uint<-(8)) & uint<-(0xFF))) * prime
-            h = (h ^ ((as_uint >> uint<-(16)) & uint<-(0xFF))) * prime
-            h = (h ^ ((as_uint >> uint<-(24)) & uint<-(0xFF))) * prime
+            h = (h ^ (as_uint & uint<-0xFF)) * prime
+            h = (h ^ ((as_uint >> uint<-8) & uint<-0xFF)) * prime
+            h = (h ^ ((as_uint >> uint<-16) & uint<-0xFF)) * prime
+            h = (h ^ ((as_uint >> uint<-24) & uint<-0xFF)) * prime
             return h
 
 
@@ -49,10 +49,10 @@ extending uint:
             let fnv: uint = 0x811C9DC5
             let prime: uint = 0x01000193
             var h = fnv
-            h = (h ^ (uint<-(ubyte<-(v & uint<-(0xFF))))) * prime
-            h = (h ^ (uint<-(ubyte<-((v >> uint<-(8)) & uint<-(0xFF))))) * prime
-            h = (h ^ (uint<-(ubyte<-((v >> uint<-(16)) & uint<-(0xFF))))) * prime
-            h = (h ^ (uint<-(ubyte<-((v >> uint<-(24)) & uint<-(0xFF))))) * prime
+            h = (h ^ (uint<-(ubyte<-(v & uint<-0xFF)))) * prime
+            h = (h ^ (uint<-(ubyte<-((v >> uint<-8) & uint<-0xFF)))) * prime
+            h = (h ^ (uint<-(ubyte<-((v >> uint<-16) & uint<-0xFF)))) * prime
+            h = (h ^ (uint<-(ubyte<-((v >> uint<-24) & uint<-0xFF)))) * prime
             return h
 
 
@@ -141,7 +141,7 @@ extending double:
             if v == 0.0:
                 return 0
             let bits: ulong = reinterpret[ulong](v)
-            return uint<-((bits >> uint<-(32)) ^ bits)
+            return uint<-((bits >> uint<-32) ^ bits)
 
 
     public static function equal(a: const_ptr[double], b: const_ptr[double]) -> bool:
@@ -193,15 +193,15 @@ function hash_uint(value: uint) -> uint:
     let fnv: uint = 0x811C9DC5
     let prime: uint = 0x01000193
     var h = fnv
-    h = (h ^ (value & uint<-(0xFF))) * prime
-    h = (h ^ ((value >> uint<-(8)) & uint<-(0xFF))) * prime
-    h = (h ^ ((value >> uint<-(16)) & uint<-(0xFF))) * prime
-    h = (h ^ ((value >> uint<-(24)) & uint<-(0xFF))) * prime
+    h = (h ^ (value & uint<-0xFF)) * prime
+    h = (h ^ ((value >> uint<-8) & uint<-0xFF)) * prime
+    h = (h ^ ((value >> uint<-16) & uint<-0xFF)) * prime
+    h = (h ^ ((value >> uint<-24) & uint<-0xFF)) * prime
     return h
 
 
 function hash_ulong(value: ulong) -> uint:
-    return hash_uint(uint<-((value >> uint<-(32)) ^ value))
+    return hash_uint(uint<-((value >> uint<-32) ^ value))
 
 
 extending byte:

data/std/http/server.mt

@@ -407,7 +407,7 @@ const READ_BUFFER_SIZE: ptr_uint = 4096
 
 
 function parse_port(args: span[str]) -> int:
-    var index: ptr_uint = 0
+    var index: ptr_uint = 1
     while index < args.len:
         let arg = unsafe: read(args.data + index)
         if arg.equal("--port") or arg.equal("-p"):
@@ -419,7 +419,7 @@ function parse_port(args: span[str]) -> int:
             var port: int = 0
             var digit_index: ptr_uint = 0
             while digit_index < port_arg.len:
-                let digit = int<-(port_arg.byte_at(digit_index)) - 48
+                let digit = int<-port_arg.byte_at(digit_index) - 48
                 if digit < 0 or digit > 9:
                     return 0
                 port = port * 10 + digit
@@ -436,7 +436,7 @@ function parse_port(args: span[str]) -> int:
 
 
 function parse_serve_dir(args: span[str]) -> str:
-    var index: ptr_uint = 0
+    var index: ptr_uint = 1
     while index < args.len:
         let arg = unsafe: read(args.data + index)
         if arg.equal("--root") or arg.equal("-r"):

data/std/input.mt

@@ -45,7 +45,7 @@ extending InputMap:
 
     public editable function add_action(name: str) -> ptr_uint:
         let id = this.actions.len()
-        var action = InputAction(name = name, bindings = vec.Vec[InputBinding].create())
+        let action = InputAction(name = name, bindings = vec.Vec[InputBinding].create())
         this.actions.push(action)
         return id
 

data/std/json.mt

@@ -401,7 +401,7 @@ public function parse(text_value: str) -> Result[Value, Error]:
         let error_ptr = raw.cJSON_GetErrorPtr()
         if error_ptr == null:
             return Result[Value, Error].failure(error = error_message("json parse failed"))
-        let error_text = text.cstr_as_str(unsafe: cstr<-error_ptr)
+        let error_text = text.cstr_as_str(error_ptr)
         if error_text.len == 0:
             return Result[Value, Error].failure(error = error_message("json parse failed"))
         return Result[Value, Error].failure(error = Error(message = string.String.from_str(error_text)))

data/std/linear_algebra.mt

@@ -22,7 +22,7 @@ extending vec2:
 
 
     public function length() -> float:
-        return float<-math.sqrt(double<-(this.length_squared()))
+        return float<-math.sqrt(double<-this.length_squared())
 
 
     public function normalized() -> vec2:
@@ -37,7 +37,7 @@ extending vec2:
 
 
     public function distance_to(v: vec2) -> float:
-        return float<-math.sqrt(double<-(this.distance_squared_to(v)))
+        return float<-math.sqrt(double<-this.distance_squared_to(v))
 
 
     public function lerp(target: vec2, t: float) -> vec2:
@@ -65,7 +65,7 @@ extending vec3:
 
 
     public function length() -> float:
-        return float<-math.sqrt(double<-(this.length_squared()))
+        return float<-math.sqrt(double<-this.length_squared())
 
 
     public function normalized() -> vec3:
@@ -81,7 +81,7 @@ extending vec3:
 
 
     public function distance_to(v: vec3) -> float:
-        return float<-math.sqrt(double<-(this.distance_squared_to(v)))
+        return float<-math.sqrt(double<-this.distance_squared_to(v))
 
 
     public function cross(v: vec3) -> vec3:
@@ -117,7 +117,7 @@ extending vec4:
 
 
     public function length() -> float:
-        return float<-math.sqrt(double<-(this.length_squared()))
+        return float<-math.sqrt(double<-this.length_squared())
 
 
     public function normalized() -> vec4:
@@ -134,7 +134,7 @@ extending vec4:
 
 
     public function distance_to(v: vec4) -> float:
-        return float<-math.sqrt(double<-(this.distance_squared_to(v)))
+        return float<-math.sqrt(double<-this.distance_squared_to(v))
 
 
     public function lerp(target: vec4, t: float) -> vec4:

data/std/net/mux.mt

@@ -807,7 +807,7 @@ function find_frag_buffer(buffers: ref[vec.Vec[FragBuffer]], peer_id: uint, grou
 
 
 function prune_frag_buffers(buffers: ref[vec.Vec[FragBuffer]], frame: uint, timeout_frames: uint) -> void:
-    var index: int = int<-(buffers.len())
+    var index: int = int<-buffers.len()
     index -= 1
     while index >= 0:
         let buf_ptr = buffers.get(ptr_uint<-index) else:

data/std/noise.mt

@@ -47,8 +47,8 @@ function grad3d(hash: int, x: float, y: float, z: float) -> float:
 # ── internal noise functions ──
 
 function perlin2d_impl(perm: array[ubyte, 512], x: float, y: float) -> float:
-    let ix = int<-(x)
-    let iy = int<-(y)
+    let ix = int<-x
+    let iy = int<-y
     let X = ix & 255
     let Y = iy & 255
     let xf = x - float<-(ix - (ix & ~255))
@@ -57,12 +57,12 @@ function perlin2d_impl(perm: array[ubyte, 512], x: float, y: float) -> float:
     let u = fade(if xf < 0.0: xf + 1.0 else: xf)
     let v = fade(if yf < 0.0: yf + 1.0 else: yf)
 
-    let A = int<-(perm[X]) + Y
-    let B = int<-(perm[X + 1]) + Y
-    let aa = int<-(perm[A])
-    let ab = int<-(perm[A + 1])
-    let ba = int<-(perm[B])
-    let bb = int<-(perm[B + 1])
+    let A = int<-perm[X] + Y
+    let B = int<-perm[X + 1] + Y
+    let aa = int<-perm[A]
+    let ab = int<-perm[A + 1]
+    let ba = int<-perm[B]
+    let bb = int<-perm[B + 1]
 
     let x1 = lerp(grad2d(aa, xf, yf), grad2d(ba, xf - 1.0, yf), u)
     let x2 = lerp(grad2d(ab, xf, yf - 1.0), grad2d(bb, xf - 1.0, yf - 1.0), u)
@@ -71,9 +71,9 @@ function perlin2d_impl(perm: array[ubyte, 512], x: float, y: float) -> float:
 
 
 function perlin3d_impl(perm: array[ubyte, 512], x: float, y: float, z: float) -> float:
-    let ix = int<-(x)
-    let iy = int<-(y)
-    let iz = int<-(z)
+    let ix = int<-x
+    let iy = int<-y
+    let iz = int<-z
     let X = ix & 255
     let Y = iy & 255
     let Z = iz & 255
@@ -85,19 +85,19 @@ function perlin3d_impl(perm: array[ubyte, 512], x: float, y: float, z: float) ->
     let v = fade(if yf < 0.0: yf + 1.0 else: yf)
     let w = fade(if zf < 0.0: zf + 1.0 else: zf)
 
-    let A = int<-(perm[X]) + Y
-    let AA = int<-(perm[A]) + Z
-    let AB = int<-(perm[A + 1]) + Z
-    let B = int<-(perm[X + 1]) + Y
-    let BA = int<-(perm[B]) + Z
-    let BB = int<-(perm[B + 1]) + Z
+    let A = int<-perm[X] + Y
+    let AA = int<-perm[A] + Z
+    let AB = int<-perm[A + 1] + Z
+    let B = int<-perm[X + 1] + Y
+    let BA = int<-perm[B] + Z
+    let BB = int<-perm[B + 1] + Z
 
-    let x1 = lerp(grad3d(int<-(perm[AA]), xf, yf, zf), grad3d(int<-(perm[BA]), xf - 1.0, yf, zf), u)
-    let x2 = lerp(grad3d(int<-(perm[AB]), xf, yf - 1.0, zf), grad3d(int<-(perm[BB]), xf - 1.0, yf - 1.0, zf), u)
+    let x1 = lerp(grad3d(int<-perm[AA], xf, yf, zf), grad3d(int<-perm[BA], xf - 1.0, yf, zf), u)
+    let x2 = lerp(grad3d(int<-perm[AB], xf, yf - 1.0, zf), grad3d(int<-perm[BB], xf - 1.0, yf - 1.0, zf), u)
     let y1 = lerp(x1, x2, v)
 
-    let x3 = lerp(grad3d(int<-(perm[AA + 1]), xf, yf, zf - 1.0), grad3d(int<-(perm[BA + 1]), xf - 1.0, yf, zf - 1.0), u)
-    let x4 = lerp(grad3d(int<-(perm[AB + 1]), xf, yf - 1.0, zf - 1.0), grad3d(int<-(perm[BB + 1]), xf - 1.0, yf - 1.0, zf - 1.0), u)
+    let x3 = lerp(grad3d(int<-perm[AA + 1], xf, yf, zf - 1.0), grad3d(int<-perm[BA + 1], xf - 1.0, yf, zf - 1.0), u)
+    let x4 = lerp(grad3d(int<-perm[AB + 1], xf, yf - 1.0, zf - 1.0), grad3d(int<-perm[BB + 1], xf - 1.0, yf - 1.0, zf - 1.0), u)
     let y2 = lerp(x3, x4, v)
 
     return lerp(y1, y2, w)
@@ -106,8 +106,8 @@ function perlin3d_impl(perm: array[ubyte, 512], x: float, y: float, z: float) ->
 # ── float floor for negative numbers ──
 
 function floor_f(x: float) -> int:
-    let i = int<-(x)
-    if x < 0.0 and float<-(i) != x:
+    let i = int<-x
+    if x < 0.0 and float<-i != x:
         return i - 1
     return i
 

data/std/parse.mt

@@ -6,8 +6,8 @@ import std.libc as c
 
 
 public function parse_int(text: str, base: int) -> int:
-    return int<-(c.parse_long_to_end(text, null, base))
+    return int<-c.parse_long_to_end(text, null, base)
 
 
 public function parse_float(text: str) -> float:
-    return float<-(c.parse_double(text))
+    return float<-c.parse_double(text)

data/std/process.mt

@@ -73,8 +73,7 @@ public function parent_environment() -> vec.Vec[EnvironmentEntry]:
         return result
     result.reserve(count)
     unsafe:
-        let raw_ptr_opt = c.mt_process_environ_accessor()
-        if raw_ptr_opt == null:
+        let raw_ptr_opt = c.mt_process_environ_accessor() else:
             return result
         let env_array = read(raw_ptr_opt)
         var i: ptr_uint = 0
@@ -94,7 +93,7 @@ public function parent_environment() -> vec.Vec[EnvironmentEntry]:
             nname.reserve(eq_pos)
             var ni: ptr_uint = 0
             while ni < eq_pos:
-                nname.push_byte(ubyte<-(read(entry_cstr + ni)))
+                nname.push_byte(ubyte<-read(entry_cstr + ni))
                 ni += 1
             var nvalue = string.String.create()
             let vlen = len - eq_pos - 1
@@ -102,7 +101,7 @@ public function parent_environment() -> vec.Vec[EnvironmentEntry]:
                 nvalue.reserve(vlen)
                 var vi: ptr_uint = 0
                 while vi < vlen:
-                    nvalue.push_byte(ubyte<-(read(entry_cstr + eq_pos + 1 + vi)))
+                    nvalue.push_byte(ubyte<-read(entry_cstr + eq_pos + 1 + vi))
                     vi += 1
             result.push(EnvironmentEntry(
                 name = nname.as_str(),

data/std/sparse_set.mt

@@ -18,7 +18,7 @@ extending SparseSet[T]:
         return SparseSet[T](
             sparse = vec.Vec[ptr_uint].create(),
             dense = vec.Vec[T].create(),
-            keys = vec.Vec[ptr_uint].create(),
+            keys = vec.Vec[ptr_uint].create()
         )
 
 

data/std/steering.mt

@@ -81,8 +81,8 @@ extending vec2:
             return zero[vec2]
         let forward = set_magnitude(velocity, 1.0)
         let circle_center = forward * wander_distance
-        let wx = circle_center.x + wander_radius * float<-(math.cos(double<-(wander_angle)))
-        let wy = circle_center.y + wander_radius * float<-(math.sin(double<-(wander_angle)))
+        let wx = circle_center.x + wander_radius * float<-math.cos(double<-wander_angle)
+        let wy = circle_center.y + wander_radius * float<-math.sin(double<-wander_angle)
         let displacement = vec2(x = wx, y = wy)
         return displacement
 
@@ -98,7 +98,7 @@ extending vec2:
                 steer = steer + repulsion
                 count += 1
         if count > 0:
-            steer = steer / float<-(count)
+            steer = steer / float<-count
         return steer
 
 
@@ -109,7 +109,7 @@ extending vec2:
             sum = sum + nv
             count += 1
         if count > 0:
-            let avg = sum / float<-(count)
+            let avg = sum / float<-count
             return avg - velocity
         return zero[vec2]
 
@@ -123,7 +123,7 @@ extending vec2:
                 sum = sum + np
                 count += 1
         if count > 0:
-            let center = sum / float<-(count)
+            let center = sum / float<-count
             return center - position
         return zero[vec2]
 

data/std/str.mt

@@ -208,7 +208,7 @@ extending str:
 
         if not utf8_boundary(this, start):
             fatal(c"str slice start must be a UTF-8 boundary")
-        var actual_stop = start + len
+        let actual_stop = start + len
         if not utf8_boundary(this, actual_stop):
             fatal(c"str slice end must be a UTF-8 boundary")
 

data/std/tween.mt

@@ -61,19 +61,19 @@ public struct Tween:
 # ── math helpers ──
 
 function pow_f(base: float, exp: float) -> float:
-    return float<-(math.pow(double<-(base), double<-(exp)))
+    return float<-math.pow(double<-base, double<-exp)
 
 
 function sin_f(x: float) -> float:
-    return float<-(math.sin(double<-(x)))
+    return float<-math.sin(double<-x)
 
 
 function cos_f(x: float) -> float:
-    return float<-(math.cos(double<-(x)))
+    return float<-math.cos(double<-x)
 
 
 function sqrt_f(x: float) -> float:
-    return float<-(math.sqrt(double<-(x)))
+    return float<-math.sqrt(double<-x)
 
 
 function ease_out_bounce_f(t: float) -> float:

data/std/utility.mt

@@ -64,8 +64,8 @@ function combine_scores(mode: CombineMode, scores: ref[vec.Vec[float]]) -> float
                 return 0.0
             product = product * s
             i += 1
-        let exponent = 1.0 / float<-(n)
-        return float<-(math.pow(double<-(product), double<-(exponent)))
+        let exponent = 1.0 / float<-n
+        return float<-math.pow(double<-product, double<-exponent)
 
     if mode == CombineMode.multiplicative:
         var product: float = 1.0
@@ -88,7 +88,7 @@ function combine_scores(mode: CombineMode, scores: ref[vec.Vec[float]]) -> float
                 break
             sum = sum + unsafe: read(s_ptr)
             i += 1
-        return sum / float<-(n)
+        return sum / float<-n
 
     if mode == CombineMode.minimum:
         var best: float = 1.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.10
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -603,7 +603,7 @@ metadata:
   homepage_uri: https://teefan.github.io/mt-lang/
   source_code_uri: https://github.com/teefan/mt-lang
 post_install_message: |
-  Milk Tea 0.3.8 installed!
+  Milk Tea 0.3.10 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH