DevComp/rusty-luau
1
0
Fork 0
mirror of https://github.com/CompeyDev/rusty-luau.git synced 2025-04-05 18:30:54 +01:00
Code Issues Projects Releases Packages Wiki Activity

Compare commits

base: DevComp:main
Branches Tags
DevComp:main
DevComp:roblox-support
DevComp:v0.2.0
DevComp:v0.1.0
..
compare: DevComp:v0.2.0
Branches Tags
DevComp:main
DevComp:roblox-support
DevComp:v0.2.0
DevComp:v0.1.0

No commits in common. "main" and "v0.2.0" have entirely different histories.
main ... v0.2.0

11 changed files with 436 additions and 627 deletions
Show stats Expand all files Collapse all files

12
examples/russianRoullete.luau
View file

@ -4,17 +4,17 @@ local Ok = result.Ok
local Err = result.Err local Err = result.Err
local function canError(): Result<number, string> local function canError(): Result<number, string>
if math.round(math.random()) == 1 then if math.round(math.random()) == 1 then
return Err("you DIED") return Err("you DIED")
end end
return Ok(69) return Ok(69)
end end
function main() function main()
local val = canError():unwrap() local val = canError():unwrap()
print("got value: ", val) print("got value: ", val)
end end
return main() return main()

95
lib/conversion.luau
View file

@ -38,15 +38,15 @@ local Err = result.Err
@return Option<T> @return Option<T>
]=] ]=]
function Result.ok<T, E>(self: Result<T, E>): Option<T> function Result.ok<T, E>(self: Result<T, E>): Option<T>
if self:isOk() then if self:isOk() then
if self._value == nil then if self._value == nil then
return None() return None()
end end
return Some(self._value) return Some(self._value)
end end
return None() return None()
end end
--[=[ --[=[
@ -68,11 +68,11 @@ end
@return Option<E> @return Option<E>
]=] ]=]
function Result.err<T, E>(self: Result<T, E>): Option<E> function Result.err<T, E>(self: Result<T, E>): Option<E>
if self:isErr() then if self:isErr() then
return Option.new(self._error) :: Option<E> return Option.new(self._error) :: Option<E>
end end
return None() return None()
end end
--[=[ --[=[
@ -96,19 +96,17 @@ end
@return Option<Result<T, E>> @return Option<Result<T, E>>
]=] ]=]
function Result.transpose<T, E>(self: Result<Option<T>, E>): Option<Result<T, E>> function Result.transpose<T, E>(self: Result<Option<T>, E>): Option<Result<T, E>>
if self._value == None() then if self._value == None() then
return None() return None()
elseif elseif self:isOkAnd(function(val): boolean
self:isOkAnd(function(val): boolean return val._optValue == nil
return val._optValue == nil end) then
end) return Some(Ok(self._value._optValue))
then elseif self:isErr() then
return Some(Ok(self._value._optValue)) return Some(Err(self._error))
elseif self:isErr() then end
return Some(Err(self._error))
end
error("`Result` is not transposable") error("`Result` is not transposable")
end end
--[=[ --[=[
@ -133,11 +131,11 @@ end
@return Result<T, E> @return Result<T, E>
]=] ]=]
function Option.okOr<T, E>(self: Option<T>, err: E): Result<T, E> function Option.okOr<T, E>(self: Option<T>, err: E): Result<T, E>
if self:isSome() then if self:isSome() then
return Ok(self._optValue) return Ok(self._optValue)
end end
return Err(err) return Err(err)
end end
--[=[ --[=[
@ -159,11 +157,11 @@ end
@return Result<T, E> @return Result<T, E>
]=] ]=]
function Option.okOrElse<T, E>(self: Option<T>, err: () -> E): Result<T, E> function Option.okOrElse<T, E>(self: Option<T>, err: () -> E): Result<T, E>
if self:isSome() then if self:isSome() then
return Ok(self._optValue :: T) return Ok(self._optValue :: T)
end end
return Err(err()) return Err(err())
end end
--[=[ --[=[
@ -187,29 +185,26 @@ end
@return Result<Option<T>, E> @return Result<Option<T>, E>
]=] ]=]
function Option.transpose<T, E>(self: Option<Result<T, E>>): Result<Option<T>, E> function Option.transpose<T, E>(self: Option<Result<T, E>>): Result<Option<T>, E>
if self:isSome() then if self:isSome() then
local inner = self._optValue local inner = self._optValue
assert( assert(self.typeId == "Option" and inner.typeId == "Result", "Only an `Option` of a `Result` can be transposed")
self.typeId == "Option" and inner.typeId == "Result",
"Only an `Option` of a `Result` can be transposed"
)
if inner:isOk() then if inner:isOk() then
return Some(Ok(inner._value)) return Some(Ok(inner._value))
elseif inner:isErr() then elseif inner:isErr() then
return Some(Err(inner._error)) return Some(Err(inner._error))
end end
end end
return Ok(None()) return Ok(None())
end end
return { return {
Ok = Ok, Ok = Ok,
Err = Err, Err = Err,
Result = Result, Result = Result,
Some = Some, Some = Some,
None = None, None = None,
Option = Option, Option = Option,
} }

121
lib/future.luau
View file

@ -73,26 +73,26 @@ export type Status = "initialized" | "pending" | "cancelled" | "ready"
]=] ]=]
export type Future<T> = typeof(Future) & { export type Future<T> = typeof(Future) & {
_ret: T, _ret: T,
_thread: thread, _thread: thread,
_spawnEvt: Signal<()>, _spawnEvt: Signal<()>,
_retEvt: Signal<T | Result<T, string>, Status>, _retEvt: Signal<T | Result<T, string>, Status>,
_status: Status, _status: Status,
} }
local function _constructor<T>(fn: (Signal<()>, Signal<T, Status>) -> ()) local function _constructor<T>(fn: (Signal<()>, Signal<T, Status>) -> ())
return setmetatable( return setmetatable(
{ {
_thread = coroutine.create(fn), _thread = coroutine.create(fn),
_spawnEvt = Signal.new(), _spawnEvt = Signal.new(),
_retEvt = Signal.new(), _retEvt = Signal.new(),
_status = "initialized", _status = "initialized",
} :: Future<T>, } :: Future<T>,
{ {
__index = Future, __index = Future,
} }
) )
end end
--[=[ --[=[
@ -110,14 +110,12 @@ end
@return Future<T> -- The constructed future @return Future<T> -- The constructed future
]=] ]=]
function Future.new<T>(fn: (...any) -> T, args: { any }) function Future.new<T>(fn: (...any) -> T, args: { any })
return _constructor( return _constructor(function(spawnEvt: Signal<()>, retEvt: Signal<T, Status>)
function(spawnEvt: Signal<()>, retEvt: Signal<T, Status>) spawnEvt:Fire()
spawnEvt:Fire()
local ret = fn(table.unpack(args)) local ret = fn(table.unpack(args))
retEvt:Fire(ret, "ready") retEvt:Fire(ret, "ready")
end end)
)
end end
--[=[ --[=[
@ -130,18 +128,13 @@ end
@return Future<Result<T>> -- The constructed future @return Future<Result<T>> -- The constructed future
]=] ]=]
function Future.try<T>(fn: (...any) -> T, args: { any }) function Future.try<T>(fn: (...any) -> T, args: { any })
return _constructor( return _constructor(function(spawnEvt: Signal<()>, retEvt: Signal<Result<T, string>, Status>)
function( spawnEvt:Fire()
spawnEvt: Signal<()>,
retEvt: Signal<Result<T, string>, Status>
)
spawnEvt:Fire()
local ok, ret = pcall(fn, table.unpack(args)) local ok, ret = pcall(fn, table.unpack(args))
local res: Result<T, string> = if ok then Ok(ret) else Err(ret) local res: Result<T, string> = if ok then Ok(ret) else Err(ret)
retEvt:Fire(res, "ready") retEvt:Fire(res, "ready")
end end)
)
end end
--[=[ --[=[
@ -153,33 +146,33 @@ end
@return (Status, Option<T>) -- Returns the [Status] and an optional return if completed @return (Status, Option<T>) -- Returns the [Status] and an optional return if completed
]=] ]=]
function Future.poll<T>(self: Future<T>): (Status, Option<T>) function Future.poll<T>(self: Future<T>): (Status, Option<T>)
if self._status == "initialized" then if self._status == "initialized" then
self._retEvt:Connect(function(firedRet, status: Status) self._retEvt:Connect(function(firedRet, status: Status)
self._status = status self._status = status
self._ret = firedRet self._ret = firedRet
-- Cleanup -- Cleanup
coroutine.yield(self._thread) coroutine.yield(self._thread)
coroutine.close(self._thread) coroutine.close(self._thread)
self._spawnEvt:DisconnectAll() self._spawnEvt:DisconnectAll()
self._retEvt:DisconnectAll() self._retEvt:DisconnectAll()
end) end)
self._spawnEvt:Connect(function() self._spawnEvt:Connect(function()
self._status = "pending" self._status = "pending"
end) end)
coroutine.resume(self._thread, self._spawnEvt, self._retEvt) coroutine.resume(self._thread, self._spawnEvt, self._retEvt)
end end
if self._status == "pending" then if self._status == "pending" then
-- Just wait a bit more for the signal to fire -- Just wait a bit more for the signal to fire
task.wait(0.01) task.wait(0.01)
end end
local retOpt = if self._ret == nil then None() else Some(self._ret) local retOpt = if self._ret == nil then None() else Some(self._ret)
return self._status, retOpt return self._status, retOpt
end end
--[=[ --[=[
@ -190,8 +183,8 @@ end
@param self Future<T> @param self Future<T>
]=] ]=]
function Future.cancel<T>(self: Future<T>) function Future.cancel<T>(self: Future<T>)
self._retEvt:Fire(nil :: any, "cancelled") self._retEvt:Fire(nil :: any, "cancelled")
self._status = "cancelled" self._status = "cancelled"
end end
--[=[ --[=[
@ -204,14 +197,14 @@ end
@return T -- The value returned by the function on completion @return T -- The value returned by the function on completion
]=] ]=]
function Future.await<T>(self: Future<T>): T function Future.await<T>(self: Future<T>): T
while true do while true do
local status: Status, ret: Option<T> = self:poll() local status: Status, ret: Option<T> = self:poll()
if status == "ready" then if status == "ready" then
-- Safe to unwrap, we know it must not be nil -- Safe to unwrap, we know it must not be nil
return ret:unwrap() return ret:unwrap()
end end
end end
end end
return Future return Future

122
lib/match.luau
View file

@ -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

338
lib/option.luau
View file

@ -27,8 +27,8 @@ local tableEq = require("util").tableEq
local Option = {} local Option = {}
export type Option<T> = typeof(Option) & { export type Option<T> = typeof(Option) & {
_optValue: T?, _optValue: T?,
typeId: "Option", typeId: "Option",
} }
--[=[ --[=[
@ -37,7 +37,7 @@ export type Option<T> = typeof(Option) & {
No value. No value.
]=] ]=]
function None<T>(): Option<T> function None<T>(): Option<T>
return Option.new(nil) :: Option<T> return Option.new(nil) :: Option<T>
end end
--[=[ --[=[
@ -46,7 +46,7 @@ end
Some value of type `T`. Some value of type `T`.
]=] ]=]
function Some<T>(val: T): Option<T> function Some<T>(val: T): Option<T>
return Option.new(val) :: Option<T> return Option.new(val) :: Option<T>
end end
--[=[ --[=[
@ -58,49 +58,46 @@ end
@return Option<T> @return Option<T>
]=] ]=]
function Option.new<T>(val: T?) function Option.new<T>(val: T?)
return setmetatable( return setmetatable(
{ {
_optValue = val, _optValue = val,
typeId = "Option", typeId = "Option",
} :: Option<T>, } :: Option<T>,
{ {
__index = Option, __index = Option,
__tostring = function<T>(self: Option<T>) __tostring = function<T>(self: Option<T>)
if self._optValue == nil then if self._optValue == nil then
return `{self.typeId}::None` return `{self.typeId}::None`
else else
return `{self.typeId}::Some({self._optValue})` return `{self.typeId}::Some({self._optValue})`
end end
end, end,
__eq = function<T>(self: Option<T>, other: Option<T>): boolean __eq = function<T>(self: Option<T>, other: Option<T>): boolean
if if typeof(self._optValue) == "table" and typeof(other._optValue) == "table" then
typeof(self._optValue) == "table" return tableEq(self._optValue, other._optValue)
and typeof(other._optValue) == "table" else
then return self._optValue == other._optValue
return tableEq(self._optValue, other._optValue) end
else end,
return self._optValue == other._optValue __lt = function<T>(self: Option<T>, other: Option<T>): boolean
end if self:isSome() and other:isSome() then
end, return (self._optValue :: any) < (other._optValue :: any)
__lt = function<T>(self: Option<T>, other: Option<T>): boolean end
if self:isSome() and other:isSome() then
return (self._optValue :: any) < (other._optValue :: any)
end
return false return false
end, end,
__le = function<T>(self: Option<T>, other: Option<T>): boolean __le = function<T>(self: Option<T>, other: Option<T>): boolean
if self:isSome() and other:isSome() then if self:isSome() and other:isSome() then
return (self._optValue :: any) <= (other._optValue :: any) return (self._optValue :: any) <= (other._optValue :: any)
end end
return false return false
end, end,
} }
-- TODO: Implement __iter, once iterators traits exist -- TODO: Implement __iter, once iterators traits exist
) )
end end
--[=[ --[=[
@ -112,7 +109,7 @@ end
@return boolean @return boolean
]=] ]=]
function Option.isSome<T>(self: Option<T>): boolean function Option.isSome<T>(self: Option<T>): boolean
return self._optValue ~= nil return self._optValue ~= nil
end end
--[=[ --[=[
@ -126,8 +123,8 @@ end
@return boolean @return boolean
]=] ]=]
function Option.isSomeAnd<T>(self: Option<T>, op: (val: T) -> boolean): boolean function Option.isSomeAnd<T>(self: Option<T>, op: (val: T) -> boolean): boolean
-- We know that it's not None, so this is fine -- We know that it's not None, so this is fine
return self:isSome() and op(self._optValue :: T) return self:isSome() and op(self._optValue :: T)
end end
--[=[ --[=[
@ -139,7 +136,7 @@ end
@return boolean @return boolean
]=] ]=]
function Option.isNone<T>(self: Option<T>): boolean function Option.isNone<T>(self: Option<T>): boolean
return not self:isSome() return not self:isSome()
end end
--[=[ --[=[
@ -164,13 +161,11 @@ end
@return boolean @return boolean
]=] ]=]
function Option.expect<T>(self: Option<T>, msg: string): T | never function Option.expect<T>(self: Option<T>, msg: string): T | never
if self:isSome() then if self:isSome() then
return self._optValue :: T return self._optValue :: T
end end
return error( return error(`panic: {msg}; expected Option to be type Option::Some(T), got Option::None`)
`panic: {msg}; expected Option to be type Option::Some(T), got Option::None`
)
end end
--[=[ --[=[
@ -186,11 +181,11 @@ end
@return T | never @return T | never
]=] ]=]
function Option.unwrap<T>(self: Option<T>): T | never function Option.unwrap<T>(self: Option<T>): T | never
if self:isSome() then if self:isSome() then
return self._optValue :: T return self._optValue :: T
end end
return error("called `Option:unwrap()` on a `None` value") return error("called `Option:unwrap()` on a `None` value")
end end
--[=[ --[=[
@ -212,11 +207,11 @@ end
@return T @return T
]=] ]=]
function Option.unwrapOr<T>(self: Option<T>, default: T): T function Option.unwrapOr<T>(self: Option<T>, default: T): T
if self:isSome() then if self:isSome() then
return self._optValue :: T return self._optValue :: T
end end
return default return default
end end
--[=[ --[=[
@ -239,11 +234,11 @@ end
@return T @return T
]=] ]=]
function Option.unwrapOrElse<T>(self: Option<T>, default: () -> T): T function Option.unwrapOrElse<T>(self: Option<T>, default: () -> T): T
if self:isSome() then if self:isSome() then
return self._optValue :: T return self._optValue :: T
end end
return default() return default()
end end
--[=[ --[=[
@ -271,17 +266,17 @@ end
@return Option<U> @return Option<U>
]=] ]=]
function Option.map<T, U>(self: Option<T>, op: (x: T) -> U?): Option<U> function Option.map<T, U>(self: Option<T>, op: (x: T) -> U?): Option<U>
if self:isSome() then if self:isSome() then
local val = op(self._optValue :: T) local val = op(self._optValue :: T)
if val == nil then if val == nil then
return None() return None()
end end
return Some(val) return Some(val)
end end
return None() return None()
end end
--[=[ --[=[
@ -308,11 +303,11 @@ end
@return Option<T> @return Option<T>
]=] ]=]
function Option.inspect<T>(self: Option<T>, op: (x: T) -> ()): Option<T> function Option.inspect<T>(self: Option<T>, op: (x: T) -> ()): Option<T>
if self:isSome() then if self:isSome() then
op(self._optValue :: T) op(self._optValue :: T)
end end
return self return self
end end
--[=[ --[=[
@ -338,11 +333,11 @@ end
@return Option<T> @return Option<T>
]=] ]=]
function Option.mapOr<T, U>(self: Option<T>, default: U, op: (val: T) -> U) function Option.mapOr<T, U>(self: Option<T>, default: U, op: (val: T) -> U)
if self:isSome() then if self:isSome() then
return op(self._optValue :: T) return op(self._optValue :: T)
end end
return default return default
end end
--[=[ --[=[
@ -376,21 +371,17 @@ end
@param op (val: T) -> U -- The function to apply @param op (val: T) -> U -- The function to apply
@return Option<T> @return Option<T>
]=] ]=]
function Option.mapOrElse<T, U>( function Option.mapOrElse<T, U>(self: Option<T>, default: () -> U, op: (val: T) -> U): U
self: Option<T>, if self:isSome() then
default: () -> U, return op(self._optValue :: T)
op: (val: T) -> U end
): U
if self:isSome() then
return op(self._optValue :: T)
end
return default() return default()
end end
-- TODO: Iterator traits -- TODO: Iterator traits
function Option.iter(): never function Option.iter(): never
return error("Unimplemented: `Option:iter()`") return error("Unimplemented: `Option:iter()`")
end end
--[=[ --[=[
@ -424,11 +415,11 @@ end
@return Option<U> @return Option<U>
]=] ]=]
function Option.and_<T, U>(self: Option<T>, optb: Option<U>): Option<U> function Option.and_<T, U>(self: Option<T>, optb: Option<U>): Option<U>
if self:isSome() then if self:isSome() then
return optb return optb
end end
return None() return None()
end end
--[=[ --[=[
@ -471,11 +462,11 @@ end
@return Option<U> @return Option<U>
]=] ]=]
function Option.andThen<T, U>(self: Option<T>, op: (val: T) -> Option<U>): Option<U> function Option.andThen<T, U>(self: Option<T>, op: (val: T) -> Option<U>): Option<U>
if self:isSome() then if self:isSome() then
return op(self._optValue :: T) return op(self._optValue :: T)
end end
return None() return None()
end end
--[=[ --[=[
@ -501,17 +492,14 @@ end
@param predicate (val: T) -> boolean -- The predicate function which must match an element @param predicate (val: T) -> boolean -- The predicate function which must match an element
@return Option<T> @return Option<T>
]=] ]=]
function Option.filter<T>( function Option.filter<T>(self: Option<T>, predicate: (val: T) -> boolean): Option<T>
self: Option<T>, if self:isSome() then
predicate: (val: T) -> boolean if predicate(self._optValue :: T) then
): Option<T> return self
if self:isSome() then end
if predicate(self._optValue :: T) then end
return self
end
end
return None() return None()
end end
--[=[ --[=[
@ -546,11 +534,11 @@ end
@return Option<T> @return Option<T>
]=] ]=]
function Option.or_<T>(self: Option<T>, optb: Option<T>): Option<T> function Option.or_<T>(self: Option<T>, optb: Option<T>): Option<T>
if self:isSome() then if self:isSome() then
return self return self
end end
return optb return optb
end end
--[=[ --[=[
@ -576,11 +564,11 @@ end
@return Option<T> @return Option<T>
]=] ]=]
function Option.orElse<T>(self: Option<T>, op: () -> Option<T>): Option<T> function Option.orElse<T>(self: Option<T>, op: () -> Option<T>): Option<T>
if self:isSome() then if self:isSome() then
return self return self
end end
return op() return op()
end end
--[=[ --[=[
@ -612,17 +600,17 @@ end
@return Option<T> @return Option<T>
]=] ]=]
function Option.xor<T>(self: Option<T>, optb: Option<T>): Option<T> function Option.xor<T>(self: Option<T>, optb: Option<T>): Option<T>
if self:isSome() and optb:isSome() then if self:isSome() and optb:isSome() then
return None() return None()
end end
if self:isSome() then if self:isSome() then
return self return self
elseif optb:isSome() then elseif optb:isSome() then
return optb return optb
end end
return None() return None()
end end
--[=[ --[=[
@ -650,8 +638,8 @@ end
@return T @return T
]=] ]=]
function Option.insert<T>(self: Option<T>, val: T): T function Option.insert<T>(self: Option<T>, val: T): T
self._optValue = val self._optValue = val
return self._optValue :: T return self._optValue :: T
end end
--[=[ --[=[
@ -679,11 +667,11 @@ end
@return T @return T
]=] ]=]
function Option.getOrInsert<T>(self: Option<T>, val: T): T function Option.getOrInsert<T>(self: Option<T>, val: T): T
if self:isNone() then if self:isNone() then
self._optValue = val self._optValue = val
end end
return self._optValue :: T return self._optValue :: T
end end
--[=[ --[=[
@ -707,13 +695,13 @@ end
@return Option<T> @return Option<T>
]=] ]=]
function Option.take<T>(self: Option<T>): Option<T> function Option.take<T>(self: Option<T>): Option<T>
if self:isSome() then if self:isSome() then
local val = self._optValue :: T local val = self._optValue :: T
self._optValue = nil self._optValue = nil
return Some(val) return Some(val)
end end
return None() return None()
end end
--[=[ --[=[
@ -740,14 +728,14 @@ end
@return Option<T> @return Option<T>
]=] ]=]
function Option.replace<T>(self: Option<T>, val: T): Option<T> function Option.replace<T>(self: Option<T>, val: T): Option<T>
local current: Option<T> = self local current: Option<T> = self
self._optValue = val self._optValue = val
if current:isNone() then if current:isNone() then
return current return current
end end
return Some(current._optValue :: T) return Some(current._optValue :: T)
end end
--[=[ --[=[
@ -769,11 +757,11 @@ end
@return boolean @return boolean
]=] ]=]
function Option.contains<T>(self: Option<T>, val: T): boolean function Option.contains<T>(self: Option<T>, val: T): boolean
if self:isSome() then if self:isSome() then
return self._optValue == val return self._optValue == val
end end
return false return false
end end
--[=[ --[=[
@ -798,11 +786,11 @@ end
@return Option<{T | U}> @return Option<{T | U}>
]=] ]=]
function Option.zip<T, U>(self: Option<T>, other: Option<U>): Option<{ T | U }> function Option.zip<T, U>(self: Option<T>, other: Option<U>): Option<{ T | U }>
if self:isSome() and other:isSome() then if self:isSome() and other:isSome() then
return Some { self._optValue, other._optValue } return Some({ self._optValue, other._optValue })
end end
return None() return None()
end end
--[=[ --[=[
@ -841,20 +829,16 @@ end
@param op (x: T, y: U) -> R? @param op (x: T, y: U) -> R?
@return Option<R> @return Option<R>
]=] ]=]
function Option.zipWith<T, U, R>( function Option.zipWith<T, U, R>(self: Option<T>, other: Option<U>, op: (x: T, y: U) -> R?): Option<R>
self: Option<T>, if self:isSome() and other:isSome() then
other: Option<U>, local computed = op(self._optValue :: T, other._optValue :: 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)
if computed ~= nil then if computed ~= nil then
return Some(computed :: R) return Some(computed :: R)
end end
end end
return None() return None()
end end
--[=[ --[=[
@ -877,17 +861,13 @@ end
@return (Option<A>, Option<B>) @return (Option<A>, Option<B>)
]=] ]=]
function Option.unzip<T, A, B>(self: Option<T>): (Option<A>, Option<B>) function Option.unzip<T, A, B>(self: Option<T>): (Option<A>, Option<B>)
if self:isSome() then if self:isSome() then
if if self:isSome() and typeof(self._optValue) == "table" and #self._optValue == 2 then
self:isSome() return Some(self._optValue[1] :: A), Some(self._optValue[2] :: B)
and typeof(self._optValue) == "table" end
and #self._optValue == 2 end
then
return Some(self._optValue[1] :: A), Some(self._optValue[2] :: B)
end
end
return None(), None() return None(), None()
end end
--[=[ --[=[
@ -907,7 +887,7 @@ end
@return T? @return T?
]=] ]=]
function Option.unwrapUnchecked<T>(self: Option<T>): T? function Option.unwrapUnchecked<T>(self: Option<T>): T?
return self._optValue return self._optValue
end end
--[=[ --[=[
@ -928,11 +908,11 @@ end
@return string @return string
]=] ]=]
function Option.display<T>(self: Option<T>): string function Option.display<T>(self: Option<T>): string
return tostring(self) return tostring(self)
end end
return { return {
Option = Option, Option = Option,
Some = Some, Some = Some,
None = None, None = None,
} }

287
lib/result.luau
View file

@ -66,9 +66,9 @@ local tableEq = require("util").tableEq
local Result = {} local Result = {}
export type Result<T, E> = typeof(Result) & { export type Result<T, E> = typeof(Result) & {
_value: T, _value: T,
_error: E, _error: E,
typeId: "Result", typeId: "Result",
} }
--[=[ --[=[
@ -80,7 +80,7 @@ export type Result<T, E> = typeof(Result) & {
@return Result<T, E> @return Result<T, E>
]=] ]=]
function Ok<T, E>(val: T): Result<T, E> function Ok<T, E>(val: T): Result<T, E>
return Result.new(val, (nil :: unknown) :: E) return Result.new(val, (nil :: unknown) :: E)
end end
--[=[ --[=[
@ -92,7 +92,7 @@ end
@return Result<T, E> @return Result<T, E>
]=] ]=]
function Err<T, E>(err: E): Result<T, E> function Err<T, E>(err: E): Result<T, E>
return Result.new((nil :: unknown) :: T, err) return Result.new((nil :: unknown) :: T, err)
end end
--[=[ --[=[
@ -107,44 +107,42 @@ end
@return Result<T, E> @return Result<T, E>
]=] ]=]
function Result.new<T, E>(val: T, err: E) function Result.new<T, E>(val: T, err: E)
return setmetatable( return setmetatable(
{ {
_value = val, _value = val,
_error = err, _error = err,
typeId = "Result", typeId = "Result",
} :: Result<T, E>, } :: Result<T, E>,
{ {
__index = Result, __index = Result,
__tostring = function<T, E>(self: Result<T, E>) __tostring = function<T, E>(self: Result<T, E>)
if self:isOk() then if self:isOk() then
return `{self.typeId}::Ok({self._value})` return `{self.typeId}::Ok({self._value})`
end end
if self:isErr() then if self:isErr() then
return `{self.typeId}::Err({self._error})` return `{self.typeId}::Err({self._error})`
end end
return `{self.typeId}<T, E>` return `{self.typeId}<T, E>`
end, end,
__eq = function<T, E>(self: Result<T, E>, other: Result<T, E>) __eq = function<T, E>(self: Result<T, E>, other: Result<T, E>)
if if
typeof(self._value) ~= "table" typeof(self._value) ~= "table"
and typeof(self._error) ~= "table" and typeof(self._error) ~= "table"
and typeof(other._value) ~= "table" and typeof(other._value) ~= "table"
and typeof(other._error) ~= "table" and typeof(other._error) ~= "table"
then then
return self._value == other._value return self._value == other._value and self._error == other._error
and self._error == other._error end
end
return tableEq(self._value, other._value) return tableEq(self._value, other._value) and tableEq(self._error, other._error)
and tableEq(self._error, other._error) end,
end,
-- TODO: Implement equality and arithmetic metamethods -- TODO: Implement equality and arithmetic metamethods
-- TODO: Implement __iter, once iterators traits exist -- TODO: Implement __iter, once iterators traits exist
} }
) )
end end
--[=[ --[=[
@ -164,11 +162,11 @@ end
@return boolean @return boolean
]=] ]=]
function Result.isOk<T, E>(self: Result<T, E>): boolean function Result.isOk<T, E>(self: Result<T, E>): boolean
if self._value == nil then if self._value == nil then
return false return false
end end
return true return true
end end
--[=[ --[=[
@ -192,11 +190,8 @@ end
@param predicate (val: T?) -> boolean @param predicate (val: T?) -> boolean
@return boolean @return boolean
]=] ]=]
function Result.isOkAnd<T, E>( function Result.isOkAnd<T, E>(self: Result<T, E>, predicate: (val: T?) -> boolean): boolean
self: Result<T, E>, return self:isOk() and predicate(self._value)
predicate: (val: T?) -> boolean
): boolean
return self:isOk() and predicate(self._value)
end end
--[=[ --[=[
@ -216,7 +211,7 @@ end
@return boolean @return boolean
]=] ]=]
function Result.isErr<T, E>(self: Result<T, E>) function Result.isErr<T, E>(self: Result<T, E>)
return not self:isOk() return not self:isOk()
end end
--[=[ --[=[
@ -240,15 +235,12 @@ end
@param predicate (val: T?) -> boolean @param predicate (val: T?) -> boolean
@return boolean @return boolean
]=] ]=]
function Result.isErrAnd<T, E>( function Result.isErrAnd<T, E>(self: Result<T, E>, predicate: (val: E) -> boolean): boolean
self: Result<T, E>, if self:isErr() then
predicate: (val: E) -> boolean return predicate(self._error)
): boolean end
if self:isErr() then
return predicate(self._error)
end
return false return false
end end
--[=[ --[=[
@ -288,11 +280,11 @@ end
@return Result<U, E> @return Result<U, E>
]=] ]=]
function Result.map<T, E, U>(self: Result<T, E>, op: (val: T) -> U): Result<U, E> function Result.map<T, E, U>(self: Result<T, E>, op: (val: T) -> U): Result<U, E>
if self:isOk() then if self:isOk() then
return Result.new(op(self._value), self._error) :: Result<U, E> return Result.new(op(self._value), self._error) :: Result<U, E>
end end
return Err(self._error) return Err(self._error)
end end
--[=[ --[=[
@ -319,11 +311,11 @@ end
@return U @return U
]=] ]=]
function Result.mapOr<T, E, U>(self: Result<T, E>, default: U, op: (val: T) -> U): U function Result.mapOr<T, E, U>(self: Result<T, E>, default: U, op: (val: T) -> U): U
if self:isOk() then if self:isOk() then
return op(self._value) return op(self._value)
end end
return default return default
end end
--[=[ --[=[
@ -347,16 +339,12 @@ end
@param op (val: T) -> U @param op (val: T) -> U
@return U @return U
]=] ]=]
function Result.mapOrElse<T, E, U>( function Result.mapOrElse<T, E, U>(self: Result<T, E>, default: (val: E) -> U, op: (val: T) -> U): U
self: Result<T, E>, if self:isOk() then
default: (val: E) -> U, return op(self._value)
op: (val: T) -> U end
): U
if self:isOk() then
return op(self._value)
end
return default(self._error) return default(self._error)
end end
--[=[ --[=[
@ -385,11 +373,11 @@ end
@return Result<T, F> @return Result<T, F>
]=] ]=]
function Result.mapErr<T, E, F>(self: Result<T, E>, op: (val: E) -> F): Result<T, F> function Result.mapErr<T, E, F>(self: Result<T, E>, op: (val: E) -> F): Result<T, F>
if self:isErr() then if self:isErr() then
return Result.new(self._value, op(self._error)) return Result.new(self._value, op(self._error))
end end
return Ok(self._value) return Ok(self._value)
end end
--[=[ --[=[
@ -421,11 +409,11 @@ end
@return Result<T, E> @return Result<T, E>
]=] ]=]
function Result.inspect<T, E>(self: Result<T, E>, op: (val: T) -> ()): Result<T, E> function Result.inspect<T, E>(self: Result<T, E>, op: (val: T) -> ()): Result<T, E>
if self:isOk() then if self:isOk() then
op(self._value) op(self._value)
end end
return self return self
end end
--[=[ --[=[
@ -457,17 +445,17 @@ end
@return Result<T, E> @return Result<T, E>
]=] ]=]
function Result.inspectErr<T, E>(self: Result<T, E>, op: (val: E) -> ()): Result<T, E> function Result.inspectErr<T, E>(self: Result<T, E>, op: (val: E) -> ()): Result<T, E>
if self:isErr() then if self:isErr() then
op(self._error) op(self._error)
end end
return self return self
end end
-- TODO: Iterator traits -- TODO: Iterator traits
-- selene: allow(unused_variable) -- selene: allow(unused_variable)
function Result.iter<T, E>(self: Result<T, E>): never function Result.iter<T, E>(self: Result<T, E>): never
return error("Unimplemented: `Result:iter()`") return error("Unimplemented: `Result:iter()`")
end end
--[=[ --[=[
@ -517,11 +505,11 @@ end
@return T | never @return T | never
]=] ]=]
function Result.expect<T, E>(self: Result<T, E>, msg: string): T | never function Result.expect<T, E>(self: Result<T, E>, msg: string): T | never
if self:isOk() then if self:isOk() then
return self._value return self._value
end end
return error(`panic: {msg}; {self._error}`) return error(`panic: {msg}; {self._error}`)
end end
--[=[ --[=[
@ -545,19 +533,17 @@ end
@param self Result<T, E> @param self Result<T, E>
]=] ]=]
function Result.unwrap<T, E>(self: Result<T, E>): T | never function Result.unwrap<T, E>(self: Result<T, E>): T | never
if self:isOk() then if self:isOk() then
return self._value return self._value
end end
return error( return error(`panic: \`Result:unwrap()\` called on an \`Err\` value: {self._error}`)
`panic: \`Result:unwrap()\` called on an \`Err\` value: {self._error}`
)
end end
-- TODO: default values for types -- TODO: default values for types
-- selene: allow(unused_variable) -- selene: allow(unused_variable)
function Result.unwrapOrDefault<T, E>(self: Result<T, E>): never function Result.unwrapOrDefault<T, E>(self: Result<T, E>): never
return error("Unimplemented: `Result:unwrapOrDefault()`") return error("Unimplemented: `Result:unwrapOrDefault()`")
end end
--[=[ --[=[
@ -577,11 +563,11 @@ end
@return E | never @return E | never
]=] ]=]
function Result.expectErr<T, E>(self: Result<T, E>, msg: string): E | never function Result.expectErr<T, E>(self: Result<T, E>, msg: string): E | never
if self:isErr() then if self:isErr() then
return self._error return self._error
end end
return error(`panic: {msg}; {self._error}`) return error(`panic: {msg}; {self._error}`)
end end
--[=[ --[=[
@ -604,23 +590,21 @@ end
@return E | never @return E | never
]=] ]=]
function Result.unwrapErr<T, E>(self: Result<T, E>): E | never function Result.unwrapErr<T, E>(self: Result<T, E>): E | never
if self:isErr() then if self:isErr() then
return self._error return self._error
end end
return error( return error(`panic: \`Result:unwrapErr()\` called on an \`Ok\` value: {self._value}`)
`panic: \`Result:unwrapErr()\` called on an \`Ok\` value: {self._value}`
)
end end
-- TODO: How the fuck do I implement this? -- TODO: How the fuck do I implement this?
-- selene: allow(unused_variable) -- selene: allow(unused_variable)
function Result.intoOk<T, E>(self: Result<T, E>): never function Result.intoOk<T, E>(self: Result<T, E>): never
return error("Unimplemented: `Result:intoOk()`") return error("Unimplemented: `Result:intoOk()`")
end end
-- selene: allow(unused_variable) -- selene: allow(unused_variable)
function Result.intoErr<T, E>(self: Result<T, E>): never function Result.intoErr<T, E>(self: Result<T, E>): never
return error("Unimplemented: `Result:intoErr()`") return error("Unimplemented: `Result:intoErr()`")
end end
--[=[ --[=[
@ -652,11 +636,11 @@ end
@return Result<U, E> @return Result<U, E>
]=] ]=]
function Result.and_<T, E, U>(self: Result<T, E>, res: Result<U, E>): Result<U, E> function Result.and_<T, E, U>(self: Result<T, E>, res: Result<U, E>): Result<U, E>
if self:isOk() then if self:isOk() then
return res return res
end end
return Err(self._error) return Err(self._error)
end end
--[=[ --[=[
@ -690,11 +674,11 @@ end
@return Result<U, E> @return Result<U, E>
]=] ]=]
function Result.andThen<T, E, U>(self: Result<T, E>, op: (...any) -> any): Result<U, E> function Result.andThen<T, E, U>(self: Result<T, E>, op: (...any) -> any): Result<U, E>
if self:isOk() then if self:isOk() then
return op(self._value) return op(self._value)
end end
return Err(self._error) :: Result<U, E> return Err(self._error) :: Result<U, E>
end end
--[=[ --[=[
@ -729,15 +713,15 @@ end
@return Result<T, F> | never @return Result<T, F> | never
]=] ]=]
function Result.or_<T, E, F>(self: Result<T, E>, res: Result<T, F>): Result<T, F> | never function Result.or_<T, E, F>(self: Result<T, E>, res: Result<T, F>): Result<T, F> | never
if self:isErr() then if self:isErr() then
return res return res
end end
if self:isOk() then if self:isOk() then
return Ok(self._value) :: Result<T, F> return Ok(self._value) :: Result<T, F>
end end
return error("called `Result:or()` with an invalid value") return error("called `Result:or()` with an invalid value")
end end
--[=[ --[=[
@ -768,15 +752,12 @@ end
@param op (x: E) -> Result<T, U> @param op (x: E) -> Result<T, U>
@return Result<T, U> @return Result<T, U>
]=] ]=]
function Result.orElse<T, E, U>( function Result.orElse<T, E, U>(self: Result<T, E>, op: (x: E) -> Result<T, U>): Result<T, U>
self: Result<T, E>, if self:isErr() then
op: (x: E) -> Result<T, U> return op(self._error)
): Result<T, U> end
if self:isErr() then
return op(self._error)
end
return Ok(self._value) return Ok(self._value)
end end
--[=[ --[=[
@ -802,11 +783,11 @@ end
@return T @return T
]=] ]=]
function Result.unwrapOr<T, E>(self: Result<T, E>, default: T): T function Result.unwrapOr<T, E>(self: Result<T, E>, default: T): T
if self:isOk() then if self:isOk() then
return self._value return self._value
end end
return default return default
end end
--[=[ --[=[
@ -828,11 +809,11 @@ end
@return T @return T
]=] ]=]
function Result.unwrapOrElse<T, E>(self: Result<T, E>, op: (x: E) -> T): T function Result.unwrapOrElse<T, E>(self: Result<T, E>, op: (x: E) -> T): T
if self:isOk() then if self:isOk() then
return self._value return self._value
end end
return op(self._error) return op(self._error)
end end
--[=[ --[=[
@ -856,11 +837,11 @@ end
@return boolean @return boolean
]=] ]=]
function Result.contains<T, E>(self: Result<T, E>, val: T): boolean function Result.contains<T, E>(self: Result<T, E>, val: T): boolean
if self:isOk() then if self:isOk() then
return self._value == val return self._value == val
end end
return false return false
end end
--[=[ --[=[
@ -884,11 +865,11 @@ end
@return boolean @return boolean
]=] ]=]
function Result.containsErr<T, E>(self: Result<T, E>, err: E): boolean function Result.containsErr<T, E>(self: Result<T, E>, err: E): boolean
if self:isErr() then if self:isErr() then
return self._error == err return self._error == err
end end
return false return false
end end
--[=[ --[=[
@ -909,11 +890,11 @@ end
@return string @return string
]=] ]=]
function Result.display<T, E>(self: Result<T, E>): string function Result.display<T, E>(self: Result<T, E>): string
return tostring(self) return tostring(self)
end end
return { return {
Ok = Ok, Ok = Ok,
Err = Err, Err = Err,
Result = Result, Result = Result,
} }

56
lib/util.luau
View file

@ -1,38 +1,38 @@
-- From https://gist.github.com/sapphyrus/fd9aeb871e3ce966cc4b0b969f62f539 -- From https://gist.github.com/sapphyrus/fd9aeb871e3ce966cc4b0b969f62f539
local function tableEq(tbl1, tbl2) local function tableEq(tbl1, tbl2)
if tbl1 == tbl2 then if tbl1 == tbl2 then
return true return true
elseif type(tbl1) == "table" and type(tbl2) == "table" then elseif type(tbl1) == "table" and type(tbl2) == "table" then
for key1, value1 in pairs(tbl1) do for key1, value1 in pairs(tbl1) do
local value2 = tbl2[key1] local value2 = tbl2[key1]
if value2 == nil then if value2 == nil then
-- avoid the type call for missing keys in tbl2 by directly comparing with nil -- avoid the type call for missing keys in tbl2 by directly comparing with nil
return false return false
elseif value1 ~= value2 then elseif value1 ~= value2 then
if type(value1) == "table" and type(value2) == "table" then if type(value1) == "table" and type(value2) == "table" then
if not tableEq(value1, value2) then if not tableEq(value1, value2) then
return false return false
end end
else else
return false return false
end end
end end
end end
-- check for missing keys in tbl1 -- check for missing keys in tbl1
for key2, _ in pairs(tbl2) do for key2, _ in pairs(tbl2) do
if tbl1[key2] == nil then if tbl1[key2] == nil then
return false return false
end end
end end
return true return true
end end
return false return false
end end
return { return {
tableEq = tableEq, tableEq = tableEq,
} }

6
lune.yml
View file

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

14
mod.luau
View file

@ -1,16 +1,14 @@
local fs = require("@lune/fs")
local luau = require("@lune/luau") local luau = require("@lune/luau")
local fs = require("@lune/fs")
local SIGNAL_PATH = local SIGNAL_PATH = "Packages/_Index/ffrostflame_luausignal@0.2.4/luausignal/src/init.luau"
"Packages/_Index/ffrostflame_luausignal@0.2.4/luausignal/src/init.luau"
local _signal = require(SIGNAL_PATH) local _signal = require(SIGNAL_PATH)
export type Signal<T...> = _signal.luauSignal<T...> export type Signal<T...> = _signal.luauSignal<T...>
local signal: { local signal: {
new: <T...>() -> Signal<T...>, 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 { return {
signal = signal, signal = signal,
} }

2
selene.toml
View file

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

10
stylua.toml
View file

@ -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