@rbxts/rl 0.1.11 → 0.2.0

package/README.md

@@ -10,7 +10,7 @@
 ## Wally
 Add the following to your `wally.toml`, in the `[dependencies]` section:
 ```toml
-rl = "wiam/rl@<version>"
+rl = "wiam77/rl@<version>"
 ```
 
 Then run:
@@ -18,6 +18,11 @@ Then run:
 # wally install
 ```
 
+## npm
+```console
+# npm install @rbxts/rl
+```
+
 # API Reference
 You can read the API reference in `rl`'s [Pesde package page](https://pesde.dev/packages/wiam/rl/latest/any/docs/api_ref).
 

package/docs/api_ref.md

@@ -1,47 +1,74 @@
 # rl API Reference
 ## Types
-### state\<T>
-The [state](https://pesde.dev/packages/wiam/rl/latest/any/docs/concepts#state) type.
+### callback
+Function which gets called when its [effect](https://pesde.dev/packages/wiam/rl/latest/any/docs/intro#effect) is triggered.
+Takes the previous value of the state which triggered the effect, as well as its "index", determined by the order in which it appears within the function.
 
 ```luau
-type state<T> = (() -> T) & ((value : T, force : boolean?) -> T) & {
-	value : T
-}
+type callback<T = unknown> = ((old_value : T?, state_i : number?) -> unknown)
+													 | ((old_value : T?, state_i : number?) -> ())
 ```
 
-### callback
-Function which gets called when its [effect](https://pesde.dev/packages/wiam/rl/latest/any/docs/concepts#effect) is triggered.
-Takes the previous value of the state which triggered the effect, as well as its "index", determined by the order in which it appears within the function.
+### state\<T>
+The [state](https://pesde.dev/packages/wiam/rl/latest/any/docs/intro#state) type.
 
 ```luau
-type callback<T> = (old_value : T, state_i : number?) -> any
+type state<T = unknown> = {
+	value : T,
+	always_force : boolean,
+	read callbacks : {[callback<T>] : number}
+} & ( |	(() -> T)
+      |	((new_value : T?, force : boolean?) -> T))
 ```
 
 ## Functions
 ### state
-Creates a new [state](https://pesde.dev/packages/wiam/rl/latest/any/docs/concepts#state), with the given initial value, and whether to always [force](https://pesde.dev/packages/wiam/rl/latest/any/docs/concepts#forcing), and returns it.
+Returns a new [state](https://pesde.dev/packages/wiam/rl/latest/any/docs/intro#state), with the given initial value, and whether to always [force](https://pesde.dev/packages/wiam/rl/latest/any/docs/intro#forcing).
 
 ```luau
-function state<T>(value : T?, force : boolean?) : state<T>
+function state<T>(value : T?, always_force : boolean?) : state<T>
 
--- Example
 local health = state(100)
 local stamina = state(100, true)
 ```
 
+### effect
+Creates a new [effect](https://pesde.dev/packages/wiam/rl/latest/any/docs/intro#effect), with the given [callback](https://pesde.dev/packages/wiam/rl/latest/any/docs/api_ref#callback), and returns its disconnect function.
+
+```luau
+function effect<T>(callback : callback<T>) : () -> ()
+
+effect(function()
+	print(`new health: {health()}`)
+end)
+
+health(10) -- "new health: 10"
+health(10) -- doesn't print because the new value is the same as the current one
+health(10, true) -- "new health: 10"; this prints because we forced it
+
+local disconnect = effect(function()
+	print(`new stamina: {stamina()}`)
+end)
+
+stamina(90) -- "new stamina: 90"
+stamina(90) -- "new stamina: 90"; this prints because `stamina` is always forced.
+disconnect()
+
+stamina(40) -- doesn't print because we disconnected the effect.
+```
+
 ### derive
-Wraps an Effect around the given callback which sets a newly created State's value
-to be the return value of the callback.
-Returns the created State, the Effect's disconnect function and a flag which can be ignored.
+Wraps an Effect around the given Callback which sets a newly created State's value
+to be the return value of the Callback.
+Returns the created State and the Effect's disconnect function.
 
 This is useful for States which depend on the value of another State, since their value will
 be updated only when the State they depend on is also updated, and not every time it is read,
 as how would happen with a function which's return value depends on a State.
 
 ```luau
-function derive<T, U>(callback : () -> U) : (state<U>, () -> (), true)
+function derive<T>(callback : (() -> T) | (() -> ())) : (state<T>, () -> ())
 
--- Example
 -- without derive() (normal function)
 local half_health = function()
 	print("some computation")
@@ -64,39 +91,12 @@ print(derive_half_health()) -- 10
 print(derive_half_health()) -- 10
 ```
 
-### effect
-Creates a new [effect](https://pesde.dev/packages/wiam/rl/latest/any/docs/concepts#effect), with the given [callback](https://pesde.dev/packages/wiam/rl/latest/any/docs/api_ref#callback) function, and returns its disconnect function.
-
-```luau
-function effect<T>(callback : callback<T>) : () -> ()
-
--- Example
-effect(function()
-	print(`new health: {health()}`)
-end)
-
-health(10) -- "new health: 10"
-health(10) -- doesn't print because the new value is the same as the current one
-health(10, true) -- "new health: 10"; this prints because we forced it
-
-local disconnect = effect(function()
-	print(`new stamina: {stamina()}`)
-end)
-
-stamina(90) -- "new stamina: 90"
-stamina(90) -- "new stamina: 90"; this prints because `stamina` is always forced.
-disconnect()
-
-stamina(40) -- doesn't print because we disconnected the effect.
-```
-
 ### batch
 Batches any State write operation up until the function is done running.
 
 ```luau
-function batch(f : () -> any) : ()
+function batch(f : (() -> unknown) | () -> ()) : ()
 
--- Example
 batch(function()
 	health(420)
 	health(1337, true)
@@ -104,18 +104,15 @@ batch(function()
 end)
 
 -- "new health: 69"
-
 ```
 
 ### scope
-Returns a function which calls the given functions.
-Any non-function or function which precedes a "true" value by 2 indices is going to be skipped (the second happens because of derives).
-This is intended to be used for disconnecting Effects in bulk.
+Wraps the given callbacks into Effects.
+Returns a function which disconnects all the created Effects.
 
 ```luau
-function scope<T>(... : T) : () -> ()
+function scope(... : callback) : () -> ()
 
--- Example
 -- without scope
 local disconnect_health = effect(function()
 	print(`your health is : {health()}`)
@@ -132,12 +129,12 @@ disconnect_stamina()
 
 -- with scope
 local vitals_scope = scope(
-	effect(function()
+	function()
 		print(`your health is : {health()}`)
-	end),
-	effect(function()
+	end,
+	function()
 		print(`your stamina is : {stamina()}`)
-	end)
+	end
 )
 
 -- ...
@@ -146,14 +143,13 @@ vitals_scope()
 ```
 
 ### branch
-Alternative `if`-like function to be used within effects. Learn more about it in the [tracking section of the Concepts page](https://pesde.dev/packages/wiam/rl/latest/any/docs/concepts#tracking).
+`if`-like function to be used within effects. Learn more about it in the [tracking section of the intro page](https://pesde.dev/packages/wiam/rl/latest/any/docs/intro#tracking).
 Pass a condition to be checked, and after it a function to be run if it's successful.
 The last value, if a function, and if not after a condition, will be threated as the "else" branch.
 
 ```luau
-function branch(...) : ()
+function branch(... : any) : ()
 
--- Example
 -- A single effect for the same functionality as the examples above, thanks to the use of state_i and the branching function.
 effect(function(_, state_i)
 	branch(
@@ -168,35 +164,40 @@ end)
 ```
 
 ### mirror
-Takes a table and for every function or state, creates an effect which automatically updates the element to be either the function's return value, or, if a state, to its value.
-The created effects' disconnect functions are put at t\["disconnect"..k], where k is either the key, if it's a string, or the index at which it was iterated over.
-Returns the given table, as well as a function which disconnects all created effects.
+Iterates over the given table and creates an Effect for each key that is
+either a function or a State, updating the key's value to be the return value of the
+function, or the State's value.
+Returns table containing each key's Effect's disconnect function.
 
 ```luau
-function mirror<K, V>(t : {[K] : V}) : ({[K] : V}, () -> ())
+type function indexer(t : type) : type
+	return (t:indexer() :: any).index
+end
+
+type identifier<T> = keyof<T> | indexer<T>
+
+function mirror<T>(t : T) : (T, {[identifier<T>] : () -> ()})
 
--- Example
 local name = state("john")
-local data = mirror {
-	username = name,
+local data, data_disconnects = mirror {
+	username = name
 }
 
 print(data.username) -- "john"
 name("joe")
 print(data.username) -- "joe"
-data.disconnect_username()
+data_disconnects.username()
 
 name("doe")
-print({data.username}) -- "joe"; didn't update because we disconnected the effect
+print({data.username}) -- "joe"; didn't update because we disconnected the Effect.
 ```
 
 ### cleanup
-Disconnects all [effects](https://pesde.dev/packages/wiam/rl/latest/any/docs/concepts#effect).
+Disconnects all [effects](https://pesde.dev/packages/wiam/rl/latest/any/docs/intro#effect).
 
 ```luau
 function cleanup() : ()
 
--- Example
 cleanup()
 health(77) -- doesn't print because no effect is connected to this state (we just disconnected)
 ```

package/docs/{concepts.md → intro.md}

@@ -11,10 +11,10 @@ Instead, `rl` solves this by providing the `branch` function, which works like s
 
 ## State
 A State is a container for a value.\
-Internally, it is an userdata that has a metatable with the `__index` and `__newindex` metamethods, which permit reading and writing the value with special mechanisms.\
 Call it with no arguments for reading with tracking.\
 Call with arguments for writing, where the first argument is the new value, and the second one is whether to force for this specific call.\
-Access the `.value` field for reading without tracking. Note that this is read-only, and attempting to modify it will cause an error. `rawset` doesn't work either, since an userdata is not a table.
+Access the `.value` field for reading without tracking.
+Modify the `.value` field for writing without tracking.
 
 ## Forcing
 Forcing is when you write a new value to a State, and always trigger its Effects, even when the new value is the same as the old one.\

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rbxts/rl",
-  "version": "0.1.11",
-  "description": "simple reactive library",
+  "version": "0.2.0",
+  "description": "Simple reactive library. Docs: https://pesde.dev/packages/wiam/rl/latest/any/docs/intro",
   "publishConfig": {
     "access": "public"
   },
@@ -12,5 +12,11 @@
   "license": "GPL-3.0-or-later",
   "author": "wi_am",
   "main": "src/init.luau",
-  "typings": "src/index.d.ts"
+  "typings": "src/index.d.ts",
+  "files": [
+    "src/",
+    "docs/",
+    "COPYING",
+    "default.project.json"
+  ]
 }

package/src/index.d.ts

@@ -1,74 +1,87 @@
-export type state<T> = {
-  (new_value: T, force?: boolean): T
-  (): T
-  readonly value: T
-}
+declare namespace rl {
+  type callback<T = unknown> = (old_value?: T, state_i?: number) => unknown
 
-export type callback<T> = (old_value: T, state_i?: number) => any
+  export type state<T = unknown> = {
+    (new_value: T, force?: boolean): T
+    (): T
+    value: T
+    always_force: boolean
+    readonly callbacks: Map<callback<T>, number>
+  }
 
-/**
- * Disconnects all Effects.
- */
-export function cleanup(): void
+  /**
+   * Creates a State.
+   * @param initial_value? T -- The initial value for the State, can be nil.
+   * @param always_force? boolean -- Whether Effects connected to this State will always trigger, even when the value didn't change.
+   * @returns state<T> -- The created State. Call with no arguments for reading with tracking,
+   * call with arguments for writing (2nd argument is for forcing),
+   * read .value field for reading without tracking,
+   * write .value field for writing without triggering Effects.
+   */
+  function state<T>(initial_value: T, always_force?: boolean): state<T>
 
-/**
- * Creates a State.
- * 
- * @param value T -- Initial value.
- * @param force? boolean -- Whether Effects connected to this State will trigger, despite the fact that the value didn't change.
- * @returns state<T> -- State. Call with no arguments for reading with tracking, call with arguments for writing (2nd argument is for forcing), read .value field for reading without tracking.
- */
-export function state<T>(value: T, force?: boolean): state<T>
+  /**
+   * Creates an Effect, a binding of the given function to the event of States read (by calling) within it being updated.
+   * 
+   * @param callback callback<T> -- The function to be bound.
+   * @returns () => void -- Function which disconnects the Effect from the States.
+   */
+  function effect<T>(callback: callback<T>): () => void
 
-/**
- * Batches any State write operation up until the function is done running.
- * @param f () => any -- The function.
- */
-export function batch(f: () => any): void
+  /**
+   * Wraps an Effect around the given Callback which sets a newly created State's value
+   * to be the return value of the Callback.
+   * Returns the created State and the Effect's disconnect function.
+   *
+   * This is useful for States which depend on the value of another State, since their value will
+   * be updated only when the State they depend on is also updated, and not every time it is read,
+   * as how would happen with a function which's return value depends on a State.
+   *
+   * @param callback () => T -- The callback.
+   * @returns state<T> -- The State that was created.
+   * @returns () => void -- The created Effect's disconnect function.
+   */
+  function derive<T>(callback: () => T): [state<T>, () => void]
 
-/**
- * Creates an Effect, a binding of the given function to the event of States read (by calling) within it being updated.
- * 
- * @param callback callback<T> -- The function to be bound.
- * @returns () => void -- Function which disconnects the Effect from the States.
- */
-export function effect<T>(callback: callback<T>): () => void
+  /**
+   * Batches any State write operation up until the function is done running.
+   *
+   * @param f () => unknown -- The function.
+   */
+  function batch(f: () => unknown): void
 
-/**
- * Returns a function which calls the given functions.
- * Any non-function or function which precedes a "true" value by 2 indices is going to be skipped (the second happens because of derives).
- * This is intended to be used for disconnecting Effects in bulk.
- * @param ... () => () -- The functions.
- * @returns () => () -- The function caller.
- */
-export function scope<T>(...t : T[]): () => void
+  /**
+   * Wraps the given callbacks into Effects.
+   * Returns a function which disconnects all the created Effects.
+   *
+   * @param ...args { [K in keyof T]: callback<T[K]> } -- The callbacks.
+   * @returns () => void -- The disconnecter.
+   */
+  function scope<T extends any[]>(...args: { [K in keyof T]: callback<T[K]> }): () => void
 
-/**
- * Wraps an Effect around the given callback which sets a newly created State's value
- * to be the return value of the callback.
- * Returns the created State, the Effect's disconnect function and a flag which can be ignored.
- * This is useful for States which depend on the value of another State, since their value will
- * be updated only when the State they depend on is also updated, and not every time it is read,
- * as how would happen with a function which's return value depends on a State.
- * @param callback () => U -- the callback
- * @returns state<U> -- the State that was created
- * @returns () => void -- the created Effect's disconnect function
- * @returns true -- a flag used internally by rl.scope(); can be ignored.
- */
-export function derive<T, U>(callback: () => U) : [state<U>, () => void, true]
+  /**
+   * Branching function to be used within Effects.
+   * Pass a condition to be checked, and after it a function to be run if it's successful.
+   * The last value, if a function, and if not after a condition, will be threated as the "else" branch.
+   *
+   * @param ...a any -- The values and the branches.
+   */
+  function branch(...a: any): void
 
-/**
- * Branching function to be used within Effects.
- * Pass a condition to be checked, and after it a function to be run if it's successful.
- * The last value, if a function, and if not after a condition, will be threated as the "else" branch.
- */
-export function branch(...a : any) : void
+  /**
+   * Iterates over the given table and creates an Effect for each key that is
+   * either a function or a State, updating the key's value to be the return value of the
+   * function, or the State's value.
+   * Returns table containing each key's Effect's disconnect function.
+   *
+   * @param t T -- The table to iterate.
+   * @return T -- The given table.
+   * @return {[identifier<T>] : () -> ()} -- The table containing the disconnect functions.
+   */
+  function mirror<K, V>(t: Map<K, V>): [Map<K, V>, Map<K, () => void>]
 
-/**
- * Creates an effect for every function or State within the given table, which updates the key to either the return value of the function, or the value of the State.
- * Each Effect's disconnect function gets put in the table as t["disconnect_"..key], when key is a string, or as t["disconnect"_..i], where i is the numerical index at which the key was iterated over.
- * @param t {[K] : V} -- The table.
- * @return {[K] : V} -- The same table.
- * @returns () => void -- Function which disconnects and eliminates each disconnect function of the created Effects.
- */
-export function mirror<K, V>(t : Map<K, V>): [Map<K, V>, () => void]
+  /**
+   * Disconnects all Effects.
+   */
+  function cleanup(): void
+}

package/src/init.luau

@@ -1,25 +1,42 @@
 --!strict
+--[[
+TODO:
+	When creating a State, if its variable type is annotated,
+	and the type of the value passed to rl.state() doesn't match,
+	there should be a type error:
+	local health : rl.state<number> = rl.state("i'm not a number") -- doesn't error
 
-local rl = {}
-
-export type state<T> = (() -> T) & ((new_value : T, force : boolean?) -> T) & {
-	value : T
-}
-
-export type callback<T> = (old_value : T, state_i : number?) -> any
+	When modifying a State, if the value passed to state() doesn't match its type,
+	there should be a type error:
+	local health : rl.state<number> = rl.state(100)
+	health("i'm not a number")
 
-local batching = false
--- {[state] : {{[callback] = true}, old_value, state_i}}
-local batched : {[state<unknown>] : {any}} = {}
-
-local current_callback : callback<unknown>? = nil
-local effects : {[callback<unknown>] : number} = {}
+	- The 2 bugs above could be fixed by using the commented out state<T> type.
+]]--
 
-local function newindex_err()
-	error("Cannot mutate a State by editing it's .value!")
-end
+local rl = {}
 
-local function check<T>(v : T) : T
+export type callback<T = unknown> = ((old_value : T?, state_i : number?) -> unknown)
+				  | ((old_value : T?, state_i : number?) -> ())
+
+-- Currently broken, might get fixed in the future.
+-- export type state<T = unknown> = setmetatable<{
+-- 	value : T,
+-- 	read callbacks : {[callback<T>] : number},
+-- 	read always_force : boolean
+-- }, {
+-- 	__call : (() -> T)
+-- 	       & ((new_value : T?, force : boolean?) -> T)
+-- }>
+
+export type state<T = unknown> = {
+	value : T,
+	always_force : boolean,
+	read callbacks : {[callback<T>] : number}
+} & ( |	(() -> T)
+      |	((new_value : T?, force : boolean?) -> T))
+
+local function is_function<T>(v : T) : T
 	local vt = type(v)
 	assert(vt == "function", `Expected type 'function', got '{vt}'`)
 	return v
@@ -29,97 +46,76 @@ local warn = warn or function(msg : string) : ()
 	print(`\x1b[33m{msg}\x1b[0m`)
 end
 
---[=[
-	Disconnects all Effects.
-]=]
-function rl.cleanup() : ()
-	table.clear(effects)
-end
+local batching = false
+local batched : {[state] : {any}} = {} -- {[state] : {[1] : {[callback] = true}, [2] : old_value, [3] : state_i}}
 
---[=[
-	Creates a State.
-	
-	@param value T -- Initial value.
-	@param force boolean? -- Whether Effects connected to this State will trigger, despite the fact that the value didn't change.
-	@return state<T> -- State. Call with no arguments for reading with tracking, call with arguments for writing (2nd argument is for forcing), read .value field for reading without tracking.
-]=]
-function rl.state<T>(value : T?, force : boolean?) : state<T>
-	local callbacks : {[callback<unknown>] : number} = {}
-	local self = newproxy(true)
-	local mt = getmetatable(self)
-	mt.__newindex = newindex_err
-	mt.__index = function(_, k)
-		assert(k == "value", `Expected key 'value', got '{k}'!`)
-		return value
-	end
+local current_callback : callback? = nil
+local effects : {[callback] : number} = {}
+
+local function state__call<T>(self : state<T>, new_value : T?, force : boolean?) : T
+	local old_value = self.value
+	local callbacks = self.callbacks
 	
-	mt.__call = function(... : T) : T
-		local argv = {...}
-		local old_value = value
-		local new_value = argv[2]
-
-		if #argv == 1 then
-			if current_callback and not callbacks[current_callback] then
-				effects[current_callback] += 1
-				callbacks[current_callback] = effects[current_callback]
-			end
-		elseif value :: any ~= new_value or force == true or argv[3] == true then
-			value = new_value
+	if not (new_value or force) then
+		if current_callback and not callbacks[current_callback] then
+			effects[current_callback] += 1
+			callbacks[current_callback] = effects[current_callback]
+		end
+	elseif old_value ~= new_value or self.always_force or force then
+		self.value = new_value
 
-			for callback, state_i in callbacks do
-				if not effects[callback] then
-					callbacks[callback] = nil
-					continue
-				end
+		for callback, state_i in callbacks do
+			if not effects[callback] then
+				callbacks[callback] = nil
+				continue
+			end
 
-				if batching then
-					local state_batch = batched[self]
-					if state_batch then
-						local x = state_batch[1]
-						if not x[callback] then
-							x[callback] = true
-						end
-
-						state_batch[2] = old_value
-					else
-						batched[self] = {{[callback] = true}, old_value, state_i}
+			if batching then
+				local state_batch = batched[self]
+				if state_batch then
+					local x = state_batch[1]
+					if not x[callback] then
+						x[callback] = true
 					end
+
+					state_batch[2] = old_value
 				else
-					callback(old_value, state_i)
+					batched[self] = {{[callback] = true}, old_value, state_i}
 				end
+			else
+				callback(old_value, state_i)
 			end
 		end
-
-		return value
 	end
 
-	return self
+	return self.value
 end
 
 --[=[
-	Batches any State write operation up until the function is done running.
-
-	@param f () -> any -- The function.
+	Creates a State.
+	
+	@param initial_value T? -- The initial value for the State, can be nil.
+	@param always_force boolean? -- Whether Effects connected to this State will always trigger, even when the value didn't change.
+	@return state<T> -- The created State. Call with no arguments for reading with tracking,
+	call with arguments for writing (2nd argument is for forcing),
+	read .value field for reading without tracking,
+	write .value field for writing without triggering Effects.
 ]=]
-function rl.batch(f : () -> any) : ()
-	batching = true
-	f()
-
-	for _, result in batched do
-		for callback in result[1] do
-			callback(result[2], result[3])
-		end
-	end
-
-	batching = false
-	table.clear(batched :: {any})
+function rl.state<T>(initial_value : T?, always_force : boolean?) : state<T>
+	return setmetatable({
+		value = initial_value,
+		callbacks = {},
+		always_force = always_force or false
+	}, {
+		__call = state__call
+	}) :: any
 end
 
 --[=[
 	Creates an Effect, a binding of the given function to the event of States read (by calling) within it being updated.
 	
 	@param callback callback<T> -- The function to be bound.
-	@return disconnect () -> () -- Function which disconnects the Effect from the States.
+	@return () -> () -- Function which disconnects the Effect from the States.
 ]=]
 function rl.effect<T>(callback : callback<T>) : () -> ()
 	if current_callback then
@@ -142,106 +138,125 @@ function rl.effect<T>(callback : callback<T>) : () -> ()
 end
 
 --[=[
-	Returns a function which calls the given functions.
-	Any non-function or function which precedes a "true" value by 2 indices is going to be skipped (the second happens because of derives).
-	This is intended to be used for disconnecting Effects in bulk.
+	Wraps an Effect, around the given Callback, which sets a newly created State's value
+	to be the return value of the Callback.
+	Returns the created State and the Effect's disconnect function.
+
+	This is useful for States which depend on the value of another State, since their value will
+	be updated only when the State they depend on is also updated, and not every time it is read,
+	as how would happen with a function which's return value depends on a State.
+
+	@param callback () -> T -- The callback.
+	@return state<T> -- The State that was created.
+	@return () -> () -- The created Effect's disconnect function.
+]=]
+function rl.derive<T>(callback : (() -> T) | (() -> ())) : (state<T>, () -> ())
+	local state = rl.state()
+	return state, rl.effect(function()
+		state(callback())
+	end)
+end
+
+--[=[
+	Batches any State write operation up until the given function is done running.
 
-	@param ... () -> () -- The functions.
-	@return f () -> () -- The function caller.
+	@param f (() -> unknown) | () -> () -- The function.
 ]=]
-function rl.scope<T>(... : T) : () -> ()
-	local t = {...}
-	return function()
-		for i = 1, #t do
-			local v = t[i]
-			if type(v) ~= "function" or t[i + 2] == true then continue end
-			v()
+function rl.batch(f : (() -> unknown) | () -> ()) : ()
+	batching = true
+	f()
+
+	for _, result in batched do
+		for callback in result[1] :: {[callback] : true} do
+			callback(result[2], result[3] :: number)
 		end
 	end
+
+	batching = false
+	table.clear(batched)
 end
 
 --[=[
-	Wraps an Effect around the given callback which sets a newly created State's value
-	to be the return value of the callback.
-	Returns the created State, the Effect's disconnect function and a flag which can be ignored.
-
-	This is useful for States which depend on the value of another State, since their value will
-	be updated only when the State they depend on is also updated, and not every time it is read,
-	as how would happen with a function which's return value depends on a State.
+	Wraps the given Callbacks into Effects.
+	Returns a function which disconnects all the created Effects.
 
-	@param callback () -> U -- the callback
-	@return derived_state state<U> -- the State that was created
-	@return disconnect () -> -- the created Effect's disconnect function
-	@return flag true -- a flag used internally by rl.scope(); can be ignored.
+	@param ... () -> () -- The Callbacks.
+	@return () -> () -- The disconnecter.
 ]=]
-function rl.derive<T, U>(callback : () -> U) : (state<U>, () -> (), true)
-	local cache = rl.state()
-	return cache, rl.effect(function()
-		cache(callback())
-	end), true
+function rl.scope(... : callback) : () -> ()
+	local disconnects = {}
+	for _, callback in {...} do
+		table.insert(disconnects, rl.effect(callback))
+	end
+	
+	return function()
+		for _, disconnect in disconnects do
+			disconnect()
+		end
+	end
 end
 
 --[=[
 	Branching function to be used within Effects.
 	Pass a condition to be checked, and after it a function to be run if it's successful.
 	The last value, if a function, and if not after a condition, will be threated as the "else" branch.
+
+	@param ... any -- The values and the branches.
 ]=]
-function rl.branch(...) : ()
+function rl.branch(... : any) : ()
 	local args = table.pack(...)
 	local n = args.n
-	assert(n >= 2, "Expected 2 or more arguments!")
+	assert(n > 1, "Expected at least 2 arguments!")
 
 	local i = 1
 	while i + 1 <= n do
 		if args[i] or current_callback then
-			check(args[i + 1])()
+			is_function(args[i + 1])()
 		end
 
 		i += 2
 	end
 
 	if i <= n then
-		check(args[i])()
+		is_function(args[i])()
 	end
 end
 
---[=[
-	Creates an effect for every function or State within the given table, which updates the key to either the return value of the function, or the value of the State.
-	Each Effect's disconnect function gets put in the table as t["disconnect_"..key], when key is a string, or as t["disconnect"_..i], where i is the numerical index at which the key was iterated over.
+type function indexer(t : type) : type
+	return (t:indexer() :: any).index
+end
 
-	@param t {[K] : V} -- The table.
-	@return t {[K] : V} -- The same table.
-	@return disconnect_all () -> () -- Function which disconnects and eliminates each disconnect function of the created Effects.
+-- couldn't think of a better name
+type identifier<T> = keyof<T> | indexer<T>
+
+--[=[
+	Iterates over the given table and creates an Effect for each key that is
+	either a function or a State, updating the key's value to be the return value of the
+	function, or the State's value.
+	Returns table containing each key's Effect's disconnect function.
+
+	@param t T -- The table to iterate.
+	@return T -- The given table.
+	@return {[identifier<T>] : () -> ()} -- The table containing the disconnect functions.
 ]=]
-function rl.mirror<K, V>(t : {[K] : V}) : ({[K] : V}, () -> ())
-	local disconnects : {[number | string] : () -> ()} = {}
-
-	for k, v in t do
-		local v_type = type(v)
-		if v_type == "function" or (v_type == "table" and (v :: {[any] : any}).value) then
-			local disconnect = rl.effect(function()
-				t[k] = v()
-			end)
-
-			local k_type = type(k)
-			if k_type == "string" then
-				disconnects[k] = disconnect
-			else
-				table.insert(disconnects :: {any}, disconnect)
-			end
-		end
+function rl.mirror<T>(t : T) : (T, {[identifier<T>] : () -> ()})
+	local disconnects : {[identifier<T>] : () -> ()} = {}
+	for k, v in (t :: {[identifier<T>] : unknown}) do
+		local mt = getmetatable(v :: any)
+		if type(v) ~= "function" and not (mt and mt.__call == state__call) then continue end
+		disconnects[k] = rl.effect(function()
+			(t :: {[identifier<T>] : unknown})[k] = (v :: () -> ())()
+		end)
 	end
 
-	for name, disconnect in disconnects do
-		t["disconnect_"..name] = disconnect
-	end
+	return t, disconnects
+end
 
-	return t, function()
-		for name, disconnect in disconnects do
-			disconnect()
-			t["disconnect_"..name] = nil
-		end
-	end
+--[=[
+	Disconnects all Effects.
+]=]
+function rl.cleanup() : ()
+	table.clear(effects)
 end
 
 return rl

package/PESDE_README.md

@@ -1,39 +0,0 @@
-# rl
-`rl` is a simple reactive library for Luau, inspired by [Vide](https://centau.github.io/vide)'s sources and effects system.
-
-# API Reference
-You can read `rl`'s API reference [here](https://pesde.dev/packages/wiam/rl/latest/any/docs/api_ref).
-
-# Demo
-```luau
---!strict
-
-local rl = require("path/to/rl")
-local s = rl.state
-local e = rl.effect
-
-local name = s("john", true)
-local login_year = s(2020)
-
-local login_d = e(function(last_login : number)
-	print(`{name.value}, it's been {login_year() - (last_login or 0)} years!`)
-end)
-
-login_year(2025) -- "wiam, it's been 5 years!"
-login_year(2025) -- doesn't print because value didn't change
-login_year(2025, true) -- "wiam, it's been 0 years!" - this prints since it's forced
-
-name("doe") -- doesn't print because we are reading with name.value, and not name()
-
-e(function(old_name : string)
-	print(`hey {old_name}, your name has been changed to '{name()}'`)
-end)
-
-name("jane") -- "hey doe, your name has been changed to jane"
-name("jane") -- "hey jane, your name has been changed to jane" - this one is forced by default
-
-login_d()
-login_year(2026) -- doesn't print because the effect was disconnected
-
-rl.cleanup() -- disconnect all effects
-```

package/base_pesde.toml

@@ -1,10 +0,0 @@
-name = "wiam/rl"
-version = "0.1.11"
-description = "Simple reactive library for Luau."
-authors = ["wiam"]
-repository = "https://codeberg.org/wiam/rl"
-license = "GPL-3.0-or-later"
-includes = ["src/*", "pesde.toml", "COPYING", "README.md", "docs/*"]
-
-[indices]
-default = "https://github.com/pesde-pkg/index"

package/build.luau

@@ -1,30 +0,0 @@
---!strict
-
-local fs = require("@lune/fs")
-local serde = require("@lune/serde")
-
-local TARGETS = {"luau", "lune", "roblox"}
-local INCLUDES = {"src", "COPYING", "PESDE_README.md", "docs"}
-
-local base_manifest = fs.readFile("base_pesde.toml")
-
-if fs.isDir("build") then
-	fs.removeDir("build")
-end
-
-fs.writeDir("build")
-
-for _, target in TARGETS do
-	local out_dir = "build/"..target
-	fs.writeDir(out_dir)
-
-	for _, include in INCLUDES do
-		fs.copy(include, out_dir.."/"..if include == "PESDE_README.md" then "README.md" else include)
-	end
-
-	fs.writeFile(out_dir.."/pesde.toml", base_manifest.."\n"..serde.encode("toml", {target = {
-		environment = target,
-		lib = "src/init.luau",
-		build_files = target == "roblox" and {"src"}
-	}}, true))
-end

package/pesde.toml

@@ -1,14 +0,0 @@
-name = "wiam/rl_root"
-version = "1.0.0"
-license = "GPL-3.0-or-later"
-workspace_members = ["build/*"]
-private = true
-
-[target]
-environment = "lune"
-
-[scripts]
-build = "./build.luau"
-
-[indices]
-default = "https://github.com/pesde-pkg/index"

package/publish.sh

@@ -1,3 +0,0 @@
-#!/bin/sh
- 
-pesde run build && pesde update && pesde publish -y && wally publish

package/rokit.toml

@@ -1,4 +0,0 @@
-[tools]
-wally = "UpliftGames/wally@0.3.2"
-rojo = "rojo-rbx/rojo@7.6.1"
-lune = "lune-org/lune@0.10.4"

package/wally.toml

@@ -1,9 +0,0 @@
-[package]
-name = "wiam77/rl"
-description = "Simple reactive library for Luau. Docs: https://pesde.dev/packages/wiam/rl/latest/any/docs/concepts"
-version = "0.1.11"
-license = "GPL-3.0-or-later"
-registry = "https://github.com/UpliftGames/wally-index"
-realm = "shared"
-include = ["src", "src/*", "wally.toml", "COPYING", "README.md", "default.project.json"]
-exclude = ["**"]