chore: apply formatting

FIXME: Moonwave doc comments are broken due to indentation issues.

Implements the rust match idiom/syntax.

lib/conversion.luau

@@ -98,9 +98,11 @@ end
 function Result.transpose<T, E>(self: Result<Option<T>, E>): Option<Result<T, E>>
     if self._value == None() then
         return None()
-	elseif self:isOkAnd(function(val): boolean
+    elseif
+        self:isOkAnd(function(val): boolean
             return val._optValue == nil
-	end) then
+        end)
+    then
         return Some(Ok(self._value._optValue))
     elseif self:isErr() then
         return Some(Err(self._error))
@@ -187,7 +189,10 @@ end
 function Option.transpose<T, E>(self: Option<Result<T, E>>): Result<Option<T>, E>
     if self:isSome() then
         local inner = self._optValue
-		assert(self.typeId == "Option" and inner.typeId == "Result", "Only an `Option` of a `Result` can be transposed")
+        assert(
+            self.typeId == "Option" and inner.typeId == "Result",
+            "Only an `Option` of a `Result` can be transposed"
+        )
 
         if inner:isOk() then
             return Some(Ok(inner._value))

lib/future.luau

@@ -110,12 +110,14 @@ end
 	@return Future<T> -- The constructed future
 ]=]
 function Future.new<T>(fn: (...any) -> T, args: { any })
-	return _constructor(function(spawnEvt: Signal<()>, retEvt: Signal<T, Status>)
+    return _constructor(
+        function(spawnEvt: Signal<()>, retEvt: Signal<T, Status>)
             spawnEvt:Fire()
 
             local ret = fn(table.unpack(args))
             retEvt:Fire(ret, "ready")
-	end)
+        end
+    )
 end
 
 --[=[
@@ -128,13 +130,18 @@ end
 	@return Future<Result<T>> -- The constructed future
 ]=]
 function Future.try<T>(fn: (...any) -> T, args: { any })
-	return _constructor(function(spawnEvt: Signal<()>, retEvt: Signal<Result<T, string>, Status>)
+    return _constructor(
+        function(
+            spawnEvt: Signal<()>,
+            retEvt: Signal<Result<T, string>, Status>
+        )
             spawnEvt:Fire()
 
             local ok, ret = pcall(fn, table.unpack(args))
             local res: Result<T, string> = if ok then Ok(ret) else Err(ret)
             retEvt:Fire(res, "ready")
-	end)
+        end
+    )
 end
 
 --[=[

lib/match.luau

@@ -0,0 +1,122 @@
+--[=[
+	@class Match
+
+	A match expression branches on a pattern. 
+	
+	Match expressions must be exhaustive, meaning that every possible 
+	pattern must be matched, i.e., have an arm handling it. The catch all 
+	arm (`_`), which matches any value, can be used to do this.
+
+	Match expressions also ensure that all of the left-sided arms match the 
+	same type of the scrutinee expression, and the right-sided arms are all
+	of the same type.
+
+	```lua
+	local word = match "hello" {
+		["hello"] = "hi",
+		["bonjour"] = "salut",
+		["hola"] = "hola",
+		_ = "<unknown>",
+	}
+
+	assert(word == "hi")
+	```
+]=]
+local Match = {}
+
+--[=[
+	@private
+	@interface Arm<L, R>
+	@within Match
+
+	Represents an arm (right-side) of a match expression.
+	
+	@type type L -- The type of the scrutinee expression or the left side of the arm
+	@field result R -- The resolved value of the match expression or the right side of the arm
+
+]=]
+type Arm<L, R> = R | (L?) -> R
+
+--[=[
+	@private
+	@interface Arms<T, U>
+	@within Match
+
+	Represents a constructed matcher.
+	
+	@type type T -- The type of the scrutinee expression or the left side of the arm
+	@field result U -- The resolved value of the match expression or the right side of the arm
+
+]=]
+type Arms<T, U> = ({ [T]: Arm<T, U> }) -> U
+
+--[=[
+	@function match
+	@within Match
+
+	A match expression branches on a pattern. A match expression has a 
+	scrutinee expression (the value to match on) and a list of patterns.
+
+	:::note
+	Currently, most traditional pattern matching is not supported, with 
+	the exception of the catch all pattern (`_`).
+	:::
+	
+	A common use-case of match is to prevent repetitive `if` statements, when
+	checking against various possible values of a variable:
+
+	```lua
+	local function getGreetingNumber(greeting: string): number
+		return match(greeting) {
+		   ["hello, world"] = 1,
+		   ["hello, mom"] = 2,
+		   _ = function(val)
+			   return #val
+		   end,
+	   }
+   end
+
+   assert(getGreetingNumber("hello, world") == 1)
+   assert(getGreetingNumber("hello, mom") == 2)
+   assert(getGreetingNumber("hello, john") == 11)
+
+   @param value T -- The value to match on
+   @return matcher Arms<T, U> -- A matcher function to call with the match arms
+   ```
+]=]
+function Match.match<T, U>(value: T): Arms<T, U>
+    local function handleArmType(arm: Arm<T, U>, fnArg: T?): U
+        if typeof(arm) == "function" then
+            return arm(fnArg)
+        end
+
+        return arm
+    end
+
+    return function(arms)
+        for l, r in arms do
+            -- Skip the catch all arm for now, get back to it
+            -- when we have finished checking for all other
+            -- arms
+            if l == "_" then
+                continue
+            end
+
+            if value == l then
+                local ret = handleArmType(r, nil)
+                return ret
+            end
+        end
+
+        -- Since we didn't get any matches, we invoke the catch
+        -- all arm, giving it the value we have
+        local catchAll = arms["_"]
+            or error(
+                `Non exhaustive match pattern, arm not satisfied for: {value}`
+            )
+
+        return handleArmType(catchAll, value)
+    end
+end
+
+return Match.match

lib/option.luau

@@ -74,7 +74,10 @@ function Option.new<T>(val: T?)
             end,
 
             __eq = function<T>(self: Option<T>, other: Option<T>): boolean
-				if typeof(self._optValue) == "table" and typeof(other._optValue) == "table" then
+                if
+                    typeof(self._optValue) == "table"
+                    and typeof(other._optValue) == "table"
+                then
                     return tableEq(self._optValue, other._optValue)
                 else
                     return self._optValue == other._optValue
@@ -165,7 +168,9 @@ function Option.expect<T>(self: Option<T>, msg: string): T | never
         return self._optValue :: T
     end
 
-	return error(`panic: {msg}; expected Option to be type Option::Some(T), got Option::None`)
+    return error(
+        `panic: {msg}; expected Option to be type Option::Some(T), got Option::None`
+    )
 end
 
 --[=[
@@ -371,7 +376,11 @@ end
 	@param op (val: T) -> U -- The function to apply
 	@return Option<T>
 ]=]
-function Option.mapOrElse<T, U>(self: Option<T>, default: () -> U, op: (val: T) -> U): U
+function Option.mapOrElse<T, U>(
+    self: Option<T>,
+    default: () -> U,
+    op: (val: T) -> U
+): U
     if self:isSome() then
         return op(self._optValue :: T)
     end
@@ -492,7 +501,10 @@ end
 	@param predicate (val: T) -> boolean -- The predicate function which must match an element 
 	@return Option<T>
 ]=]
-function Option.filter<T>(self: Option<T>, predicate: (val: T) -> boolean): Option<T>
+function Option.filter<T>(
+    self: Option<T>,
+    predicate: (val: T) -> boolean
+): Option<T>
     if self:isSome() then
         if predicate(self._optValue :: T) then
             return self
@@ -787,7 +799,7 @@ end
 ]=]
 function Option.zip<T, U>(self: Option<T>, other: Option<U>): Option<{ T | U }>
     if self:isSome() and other:isSome() then
-		return Some({ self._optValue, other._optValue })
+        return Some { self._optValue, other._optValue }
     end
 
     return None()
@@ -829,7 +841,11 @@ end
 	@param op (x: T, y: U) -> R?
 	@return Option<R>
 ]=]
-function Option.zipWith<T, U, R>(self: Option<T>, other: Option<U>, op: (x: T, y: U) -> R?): Option<R>
+function Option.zipWith<T, U, R>(
+    self: Option<T>,
+    other: Option<U>,
+    op: (x: T, y: U) -> R?
+): Option<R>
     if self:isSome() and other:isSome() then
         local computed = op(self._optValue :: T, other._optValue :: U)
 
@@ -862,7 +878,11 @@ end
 ]=]
 function Option.unzip<T, A, B>(self: Option<T>): (Option<A>, Option<B>)
     if self:isSome() then
-		if self:isSome() and typeof(self._optValue) == "table" and #self._optValue == 2 then
+        if
+            self:isSome()
+            and typeof(self._optValue) == "table"
+            and #self._optValue == 2
+        then
             return Some(self._optValue[1] :: A), Some(self._optValue[2] :: B)
         end
     end

lib/result.luau

@@ -133,10 +133,12 @@ function Result.new<T, E>(val: T, err: E)
                     and typeof(other._value) ~= "table"
                     and typeof(other._error) ~= "table"
                 then
-					return self._value == other._value and self._error == other._error
+                    return self._value == other._value
+                        and self._error == other._error
                 end
 
-				return tableEq(self._value, other._value) and tableEq(self._error, other._error)
+                return tableEq(self._value, other._value)
+                    and tableEq(self._error, other._error)
             end,
 
             -- TODO: Implement equality and arithmetic metamethods
@@ -190,7 +192,10 @@ end
 	@param predicate (val: T?) -> boolean
 	@return boolean
 ]=]
-function Result.isOkAnd<T, E>(self: Result<T, E>, predicate: (val: T?) -> boolean): boolean
+function Result.isOkAnd<T, E>(
+    self: Result<T, E>,
+    predicate: (val: T?) -> boolean
+): boolean
     return self:isOk() and predicate(self._value)
 end
 
@@ -235,7 +240,10 @@ end
 	@param predicate (val: T?) -> boolean
 	@return boolean
 ]=]
-function Result.isErrAnd<T, E>(self: Result<T, E>, predicate: (val: E) -> boolean): boolean
+function Result.isErrAnd<T, E>(
+    self: Result<T, E>,
+    predicate: (val: E) -> boolean
+): boolean
     if self:isErr() then
         return predicate(self._error)
     end
@@ -339,7 +347,11 @@ end
 	@param op (val: T) -> U
 	@return U
 ]=]
-function Result.mapOrElse<T, E, U>(self: Result<T, E>, default: (val: E) -> U, op: (val: T) -> U): U
+function Result.mapOrElse<T, E, U>(
+    self: Result<T, E>,
+    default: (val: E) -> U,
+    op: (val: T) -> U
+): U
     if self:isOk() then
         return op(self._value)
     end
@@ -537,7 +549,9 @@ function Result.unwrap<T, E>(self: Result<T, E>): T | never
         return self._value
     end
 
-	return error(`panic: \`Result:unwrap()\` called on an \`Err\` value: {self._error}`)
+    return error(
+        `panic: \`Result:unwrap()\` called on an \`Err\` value: {self._error}`
+    )
 end
 
 -- TODO: default values for types
@@ -594,7 +608,9 @@ function Result.unwrapErr<T, E>(self: Result<T, E>): E | never
         return self._error
     end
 
-	return error(`panic: \`Result:unwrapErr()\` called on an \`Ok\` value: {self._value}`)
+    return error(
+        `panic: \`Result:unwrapErr()\` called on an \`Ok\` value: {self._value}`
+    )
 end
 
 -- TODO: How the fuck do I implement this?
@@ -752,7 +768,10 @@ end
 	@param op (x: E) -> Result<T, U>
 	@return Result<T, U>
 ]=]
-function Result.orElse<T, E, U>(self: Result<T, E>, op: (x: E) -> Result<T, U>): Result<T, U>
+function Result.orElse<T, E, U>(
+    self: Result<T, E>,
+    op: (x: E) -> Result<T, U>
+): Result<T, U>
     if self:isErr() then
         return op(self._error)
     end

lune.yml

@@ -0,0 +1,6 @@
+---
+base: luau
+globals:
+  warn:
+    args:
+      - type: ...

mod.luau

@@ -1,13 +1,15 @@
-local luau = require("@lune/luau")
 local fs = require("@lune/fs")
+local luau = require("@lune/luau")
 
-local SIGNAL_PATH = "Packages/_Index/ffrostflame_luausignal@0.2.4/luausignal/src/init.luau"
+local SIGNAL_PATH =
+    "Packages/_Index/ffrostflame_luausignal@0.2.4/luausignal/src/init.luau"
 local _signal = require(SIGNAL_PATH)
 export type Signal<T...> = _signal.luauSignal<T...>
 local signal: {
     new: <T...>() -> Signal<T...>,
-} =
-	luau.load('local task = require("@lune/task")\n' .. fs.readFile(SIGNAL_PATH))()
+} = luau.load(
+    'local task = require("@lune/task")\n' .. fs.readFile(SIGNAL_PATH)
+)()
 
 return {
     signal = signal,

selene.toml

@@ -1,2 +1,2 @@
-std = "luau"
+std = "lune"
 exclude = ["Packages/*"]

stylua.toml

@@ -0,0 +1,10 @@
+line_endings = "Unix"
+quote_style = "AutoPreferDouble"
+indent_type = "Spaces"
+call_parentheses = "NoSingleTable"
+
+indent_width = 4
+column_width = 80
+
+[sort_requires]
+enabled = true