lib/conversion.luau

@@ -98,11 +98,9 @@ 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))
@@ -189,10 +187,7 @@ 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,14 +110,12 @@ 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
 
 --[=[
@@ -130,18 +128,13 @@ 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

@@ -1,122 +0,0 @@
---[=[
-	@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,10 +74,7 @@ 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
@@ -168,9 +165,7 @@ 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
 
 --[=[
@@ -376,11 +371,7 @@ 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
@@ -501,10 +492,7 @@ 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
@@ -799,7 +787,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()
@@ -841,11 +829,7 @@ 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)
 
@@ -878,11 +862,7 @@ 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,12 +133,10 @@ 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
@@ -192,10 +190,7 @@ 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
 
@@ -240,10 +235,7 @@ 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
@@ -347,11 +339,7 @@ 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
@@ -549,9 +537,7 @@ 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
@@ -608,9 +594,7 @@ 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?
@@ -768,10 +752,7 @@ 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

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

mod.luau

@@ -1,15 +1,13 @@
-local fs = require("@lune/fs")
 local luau = require("@lune/luau")
+local fs = require("@lune/fs")
 
-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 = "lune"
+std = "luau"
 exclude = ["Packages/*"]

stylua.toml

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