ctx-core 4.4.0 → 4.6.0

package/all/be_memo_pair/index.d.ts

@@ -0,0 +1,25 @@
+import type { Be, be__val__new_T, be_config_T, Ctx } from '../be_/index.js'
+import type { memo_T, rmemo_def_T } from '../rmemo/index.js'
+export declare function be_memo_pair_<
+	val_T,
+	_memo_T extends memo_T<val_T> = memo_T<val_T>,
+	ctx_T extends Ctx = Ctx
+>(be: Be<_memo_T, ctx_T>):be_memo_pair_T<val_T, _memo_T, ctx_T>
+export declare function be_memo_pair_<
+	val_T,
+	_memo_T extends memo_T<val_T> = memo_T<val_T>,
+	ctx_T extends Ctx = Ctx
+>(
+	rmemo__new:be__val__new_T<val_T>,
+	...subscriber_a_THEN_config:
+		|[...rmemo_def_T<val_T>[]]
+		|[...rmemo_def_T<val_T>[], config:be_config_T]
+):be_memo_pair_T<val_T, _memo_T, ctx_T>
+export type be_memo_pair_T<
+	val_T,
+	_memo_T extends memo_T<val_T> = memo_T<val_T>,
+	ctx_T extends Ctx = Ctx
+> = [
+	Be<_memo_T, ctx_T>,
+	(ctx:ctx_T)=>val_T
+]

package/all/{be_r_rmemo_pair → be_memo_pair}/index.js

@@ -1,17 +1,17 @@
 import { be_ } from '../be_/index.js'
-import { r_rmemo_ } from '../rmemo/index.js'
+import { memo_ } from '../rmemo/index.js'
 /** @typedef {import('../be_/index.d.ts').Be} */
 /** @typedef {import('../be_/index.d.ts').be__val__new_T} */
 /** @typedef {import('../be_/index.d.ts').be_config_T} */
 /** @typedef {import('../rmemo/index.d.ts').rmemo_subscriber_T} */
-/** @typedef {import('./index.d.ts').be_r_rmemo_pair_T} */
+/** @typedef {import('./index.d.ts').be_memo_pair_T} */
 /**
  * @param {Be|be__val__new_T<unknown>}be_OR_val__new
  * @param {rmemo_subscriber_T[]|[...rmemo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
- * @returns {be_r_rmemo_pair_T}
+ * @returns {be_memo_pair_T}
  * @private
  */
-export function be_r_rmemo_pair_(
+export function be_memo_pair_(
 	be_OR_val__new,
 	...subscriber_a_THEN_config
 ) {
@@ -24,7 +24,7 @@ export function be_r_rmemo_pair_(
 		be_OR_val__new.is_be
 			? be_OR_val__new
 			: be_(ctx=>
-				r_rmemo_(()=>be_OR_val__new(ctx), ...subscriber_a_THEN_config),
+				memo_(()=>be_OR_val__new(ctx), ...subscriber_a_THEN_config),
 			config)
 	return [
 		be,

package/all/{be_r_rmemo_pair → be_memo_pair}/index.test.ts

@@ -1,21 +1,21 @@
 import { test } from 'uvu'
 import { equal } from 'uvu/assert'
 import { be_ } from '../be_/index.js'
-import { be_rw_rmemo_triple_ } from '../be_rw_rmemo_triple/index.js'
+import { be_sig_triple_ } from '../be_sig_triple/index.js'
 import { ctx__new } from '../ctx/index.js'
-import type { r_rmemo_T, rw_rmemo_T } from '../rmemo/index.js'
-import { r_rmemo_ } from '../rmemo/index.js'
-import { be_r_rmemo_pair_ } from './index.js'
-test('be_r_rmemo_pair_', ()=>{
+import type { memo_T, sig_T } from '../rmemo/index.js'
+import { memo_ } from '../rmemo/index.js'
+import { be_memo_pair_ } from './index.js'
+test('be_memo_pair_', ()=>{
 	const [
 		,
 		base_,
 		base__set,
-	] = be_rw_rmemo_triple_(()=>1)
+	] = be_sig_triple_(()=>1)
 	const [
 		foobar$_,
 		foobar_,
-	] = be_r_rmemo_pair_(ctx=>base_(ctx) + 1)
+	] = be_memo_pair_(ctx=>base_(ctx) + 1)
 	const ctx = ctx__new()
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
@@ -23,19 +23,19 @@ test('be_r_rmemo_pair_', ()=>{
 	equal(foobar$_(ctx)._, 3)
 	equal(foobar_(ctx), 3)
 })
-test('be_r_rmemo_pair_|+id|+is_source_|+oninit|+subscriber_a', ()=>{
+test('be_memo_pair_|+id|+is_source_|+oninit|+subscriber_a', ()=>{
 	const ctx = ctx__new()
 	let subscriber_count = 0
 	const [
 		,
 		base_,
 		base__set,
-	] = be_rw_rmemo_triple_(()=>1,
+	] = be_sig_triple_(()=>1,
 		{ is_source_: map_ctx=>map_ctx === ctx })
 	const [
 		foobar$_,
 		foobar_,
-	] = be_r_rmemo_pair_(ctx=>base_(ctx) + 1,
+	] = be_memo_pair_(ctx=>base_(ctx) + 1,
 		()=>subscriber_count++,
 		{
 			id: 'foobar',
@@ -46,34 +46,34 @@ test('be_r_rmemo_pair_|+id|+is_source_|+oninit|+subscriber_a', ()=>{
 	equal(foobar_([ctx__new(), ctx]), 2)
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
-	equal((ctx.get('foobar') as r_rmemo_T<number>)._, 2)
+	equal((ctx.get('foobar') as memo_T<number>)._, 2)
 	equal(subscriber_count, 1)
 	base__set(ctx, 2)
 	equal(foobar$_([ctx__new(), ctx])._, 3)
 	equal(foobar_([ctx__new(), ctx]), 3)
 	equal(foobar$_(ctx)._, 3)
 	equal(foobar_(ctx), 3)
-	equal((ctx.get('foobar') as r_rmemo_T<number>)._, 3)
+	equal((ctx.get('foobar') as memo_T<number>)._, 3)
 	equal(subscriber_count, 1)
 })
-test('be_r_rmemo_pair_|be', ()=>{
+test('be_memo_pair_|be', ()=>{
 	const ctx = ctx__new()
 	let subscriber_count = 0
 	const [
 		,
 		base_,
 		base__set,
-	] = be_rw_rmemo_triple_(()=>1,
+	] = be_sig_triple_(()=>1,
 		{ is_source_: map_ctx=>map_ctx === ctx })
 	const [
 		foobar$_,
 		foobar_,
-	] = be_r_rmemo_pair_<number, custom_r_rmemo_T>(
+	] = be_memo_pair_<number, custom_memo_T>(
 		be_(_ctx=>{
-			const foobar$ = r_rmemo_(
+			const foobar$ = memo_(
 				()=>base_(ctx) + 1,
 				()=>subscriber_count++
-			) as custom_r_rmemo_T
+			) as custom_memo_T
 			if (Array.isArray(_ctx)) equal(_ctx[1], ctx)
 			else equal(_ctx, ctx)
 			foobar$.custom = 'custom-val'
@@ -87,7 +87,7 @@ test('be_r_rmemo_pair_|be', ()=>{
 	equal(foobar_([ctx__new(), ctx]), 2)
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
-	equal((ctx.get('foobar') as r_rmemo_T<number>)._, 2)
+	equal((ctx.get('foobar') as memo_T<number>)._, 2)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	equal(subscriber_count, 1)
 	base__set(ctx, 2)
@@ -95,9 +95,9 @@ test('be_r_rmemo_pair_|be', ()=>{
 	equal(foobar_([ctx__new(), ctx]), 3)
 	equal(foobar$_(ctx)._, 3)
 	equal(foobar_(ctx), 3)
-	equal((ctx.get('foobar') as r_rmemo_T<number>)._, 3)
+	equal((ctx.get('foobar') as memo_T<number>)._, 3)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	equal(subscriber_count, 1)
 })
 test.run()
-type custom_r_rmemo_T = rw_rmemo_T<number>&{ custom:string }
+type custom_memo_T = sig_T<number>&{ custom:string }

package/all/be_sig_triple/index.d.ts

@@ -0,0 +1,26 @@
+import type { Be, be__val__new_T, be_config_T, Ctx } from '../be_/index.js'
+import type { sig_T, rmemo_def_T } from '../rmemo/index.js'
+export declare function be_sig_triple_<
+	val_T,
+	_sig_T extends sig_T<val_T> = sig_T<val_T>,
+	ctx_T extends Ctx = Ctx
+>(be: Be<_sig_T, ctx_T>):be_sig_triple_T<val_T, _sig_T, ctx_T>
+export declare function be_sig_triple_<
+	val_T,
+	_sig_T extends sig_T<val_T> = sig_T<val_T>,
+	ctx_T extends Ctx = Ctx
+>(
+	rmemo__new:be__val__new_T<val_T>,
+	...subscriber_a_THEN_config:
+		|[...rmemo_def_T<val_T>[]]
+		|[...rmemo_def_T<val_T>[], config:be_config_T]
+):be_sig_triple_T<val_T, _sig_T, ctx_T>
+export type be_sig_triple_T<
+	val_T,
+	_sig_T extends sig_T<val_T> = sig_T<val_T>,
+	ctx_T extends Ctx = Ctx
+> = [
+	Be<_sig_T>,
+	(ctx:ctx_T)=>val_T,
+	(ctx:ctx_T, val:val_T)=>void
+]

package/all/{be_rw_rmemo_triple → be_sig_triple}/index.js

@@ -1,18 +1,18 @@
 import { be_ } from '../be_/index.js'
-import { rw_rmemo_ } from '../rmemo/index.js'
+import { sig_ } from '../rmemo/index.js'
 /** @typedef {import('../be_/index.d.ts').Be} */
 /** @typedef {import('../be_/index.d.ts').be__val__new_T} */
 /** @typedef {import('../be_/index.d.ts').be_config_T} */
-/** @typedef {import('../rmemo/index.d.ts').rw_rmemo_T} */
+/** @typedef {import('../rmemo/index.d.ts').sig_T} */
 /** @typedef {import('../rmemo/index.d.ts').rmemo_subscriber_T} */
-/** @typedef {import('./index.d.ts').be_rw_rmemo_triple_T} */
+/** @typedef {import('./index.d.ts').be_sig_triple_T} */
 /**
- * @param {Be<rw_rmemo_T>|be__val__new_T<unknown>}be_OR_val__new
+ * @param {Be<sig_T>|be__val__new_T<unknown>}be_OR_val__new
  * @param {rmemo_subscriber_T[]|[...rmemo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
- * @returns {be_rw_rmemo_triple_T}
+ * @returns {be_sig_triple_T}
  * @private
  */
-export function be_rw_rmemo_triple_(
+export function be_sig_triple_(
 	be_OR_val__new,
 	...subscriber_a_THEN_config
 ) {
@@ -20,11 +20,11 @@ export function be_rw_rmemo_triple_(
 		typeof subscriber_a_THEN_config[subscriber_a_THEN_config.length - 1] === 'object'
 			? subscriber_a_THEN_config.pop()
 			: undefined
-	/** @type {Be<rw_rmemo_T>} */
+	/** @type {Be<sig_T>} */
 	let be =
 		be_OR_val__new.is_be
 			? be_OR_val__new
-			: be_(ctx=>rw_rmemo_(be_OR_val__new(ctx), ...subscriber_a_THEN_config),
+			: be_(ctx=>sig_(be_OR_val__new(ctx), ...subscriber_a_THEN_config),
 				config)
 	return [
 		be,

package/all/{be_rw_rmemo_triple → be_sig_triple}/index.test.ts

@@ -2,14 +2,14 @@ import { test } from 'uvu'
 import { equal } from 'uvu/assert'
 import { be_ } from '../be_/index.js'
 import { ctx__new } from '../ctx/index.js'
-import { type rw_rmemo_T, rw_rmemo_ } from '../rmemo/index.js'
-import { be_rw_rmemo_triple_ } from './index.js'
-test('be_rw_rmemo_triple_', ()=>{
+import { type sig_T, sig_ } from '../rmemo/index.js'
+import { be_sig_triple_ } from './index.js'
+test('be_sig_triple_', ()=>{
 	const [
 		foobar$_,
 		foobar_,
 		foobar__set,
-	] = be_rw_rmemo_triple_(()=>1)
+	] = be_sig_triple_(()=>1)
 	const ctx = ctx__new()
 	equal(foobar$_(ctx)._, 1)
 	equal(foobar_(ctx), 1)
@@ -17,14 +17,14 @@ test('be_rw_rmemo_triple_', ()=>{
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
 })
-test('be_rw_rmemo_triple_|+id|+is_source_', ()=>{
+test('be_sig_triple_|+id|+is_source_', ()=>{
 	const ctx = ctx__new()
 	let subscriber_count = 0
 	const [
 		foobar$_,
 		foobar_,
 		foobar__set,
-	] = be_rw_rmemo_triple_(
+	] = be_sig_triple_(
 		()=>1,
 		()=>subscriber_count++,
 		{ id: 'foobar', is_source_: map_ctx=>map_ctx === ctx },)
@@ -34,26 +34,26 @@ test('be_rw_rmemo_triple_|+id|+is_source_', ()=>{
 	equal(foobar$_(ctx)._, 1)
 	equal(foobar_(ctx), 1)
 	equal(subscriber_count, 1)
-	equal((ctx.get('foobar') as rw_rmemo_T<number>)._, 1)
+	equal((ctx.get('foobar') as sig_T<number>)._, 1)
 	foobar__set([ctx__new(), ctx], 2)
 	equal(foobar$_([ctx__new(), ctx])._, 2)
 	equal(foobar_([ctx__new(), ctx]), 2)
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
-	equal((ctx.get('foobar') as rw_rmemo_T<number>)._, 2)
+	equal((ctx.get('foobar') as sig_T<number>)._, 2)
 	equal(subscriber_count, 1)
 })
-test('be_rw_rmemo_triple_|+be', ()=>{
+test('be_sig_triple_|+be', ()=>{
 	const ctx = ctx__new()
 	let subscriber_count = 0
 	const [
 		foobar$_,
 		foobar_,
 		foobar__set,
-	] = be_rw_rmemo_triple_<number, custom_rw_rmemo_T>(
+	] = be_sig_triple_<number, custom_sig_T>(
 		be_(()=>{
 			const foobar$ =
-				rw_rmemo_(1, ()=>subscriber_count++) as custom_rw_rmemo_T
+				sig_(1, ()=>subscriber_count++) as custom_sig_T
 			foobar$.custom = 'custom-val'
 			return foobar$
 		}, { id: 'foobar', is_source_: map_ctx=>map_ctx === ctx }))
@@ -63,16 +63,16 @@ test('be_rw_rmemo_triple_|+be', ()=>{
 	equal(foobar$_(ctx)._, 1)
 	equal(foobar_(ctx), 1)
 	equal(subscriber_count, 1)
-	equal((ctx.get('foobar') as rw_rmemo_T<number>)._, 1)
+	equal((ctx.get('foobar') as sig_T<number>)._, 1)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	foobar__set([ctx__new(), ctx], 2)
 	equal(foobar$_([ctx__new(), ctx])._, 2)
 	equal(foobar_([ctx__new(), ctx]), 2)
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
-	equal((ctx.get('foobar') as rw_rmemo_T<number>)._, 2)
+	equal((ctx.get('foobar') as sig_T<number>)._, 2)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	equal(subscriber_count, 1)
 })
 test.run()
-type custom_rw_rmemo_T = rw_rmemo_T<number>&{ custom:string }
+type custom_sig_T = sig_T<number>&{ custom:string }

package/all/index.d.ts

@@ -44,8 +44,8 @@ export * from './base64__buffer/index.js'
 export * from './batch_queue/index.js'
 export * from './be/index.js'
 export * from './be_/index.js'
-export * from './be_r_rmemo_pair/index.js'
-export * from './be_rw_rmemo_triple/index.js'
+export * from './be_memo_pair/index.js'
+export * from './be_sig_triple/index.js'
 export * from './binary_sort_rank/index.js'
 export * from './bind_apply/index.js'
 export * from './bind_call/index.js'

package/all/index.js

@@ -44,8 +44,8 @@ export * from './base64__buffer/index.js'
 export * from './batch_queue/index.js'
 export * from './be/index.js'
 export * from './be_/index.js'
-export * from './be_r_rmemo_pair/index.js'
-export * from './be_rw_rmemo_triple/index.js'
+export * from './be_memo_pair/index.js'
+export * from './be_sig_triple/index.js'
 export * from './binary_sort_rank/index.js'
 export * from './bind_apply/index.js'
 export * from './bind_call/index.js'

package/all/rmemo/index.d.ts

@@ -1,33 +1,30 @@
-export declare function r_rmemo_<val_T, ret_T extends rmemo_T<val_T> = r_rmemo_T<val_T>>(
+export declare function memo_<val_T>(
 	def:rmemo_def_T<val_T>,
 	...subscriber_a:rmemo_subscriber_T<val_T>[]
-):ret_T
-export declare function rw_rmemo_<val_T>(
+):memo_T<val_T>
+export declare function sig_<val_T>(
 	init_val:val_T,
 	...subscriber_a:rmemo_subscriber_T<val_T>[]
-):rw_rmemo_T<val_T>
-export declare function rwr_rmemo_<val_T>(
+):sig_T<val_T>
+export declare function memosig_<val_T>(
 	def:rmemo_def_T<val_T>,
 	...subscriber_a:rmemo_subscriber_T<val_T>[]
-):rw_rmemo_T<val_T>
-export declare function rw_rmemo__set_<val_T>(rmemo:rw_rmemo_T<val_T>):val_T
-export type rmemo_T<val_T> = r_rmemo_T<val_T>|rw_rmemo_T<val_T>
-export type r_rmemo_T<val_T> = {
+):sig_T<val_T>
+export type rmemo_T<val_T> = memo_T<val_T>|sig_T<val_T>
+export type memo_T<val_T> = (()=>val_T)&{
 	readonly _:val_T
-	val:val_T
-	rmr:WeakRef<()=>val_T>
-	rmrs?:Set<WeakRef<()=>val_T>>
+	readonly val:val_T
+	r?:WeakRef<()=>val_T>
+	memor:WeakRef<()=>val_T>[]
 }
-export type rw_rmemo_T<val_T> = {
+export type sig_T<val_T> = (()=>val_T)&{
 	_:val_T
-	val:val_T
-	rmr:WeakRef<()=>val_T>
-	rmrs:Set<WeakRef<()=>val_T>>
+	readonly val:val_T
+	r?:WeakRef<()=>val_T>
+	memor:WeakRef<()=>val_T>[]
 }
-export type rmemo_val_T<rw_rmemo_T> = rw_rmemo_T extends {
-		_:infer val_T
-	}
+export type rmemo_val_T<sig_T> = sig_T extends { ():infer val_T }
 	? val_T
 	: unknown
-export type rmemo_def_T<val_T> = (rw_rmemo:rw_rmemo_T<val_T>)=>val_T
-export type rmemo_subscriber_T<val_T> = (rw_rmemo:rw_rmemo_T<val_T>)=>unknown
+export type rmemo_def_T<val_T> = (sig:sig_T<val_T>)=>val_T
+export type rmemo_subscriber_T<val_T> = (sig:sig_T<val_T>)=>unknown

package/all/rmemo/index.js

@@ -1,55 +1,58 @@
 /** @typedef {import('./index.d.ts').rmemo_def_T} */
-/** @typedef {import('./index.d.ts').r_rmemo_T} */
+/** @typedef {import('./index.d.ts').memo_T} */
 /** @typedef {import('./index.d.ts').rmemo_subscriber_T} */
-/** @type {WeakRef<r_rmemo_T>} */
-let cur_rmr
+/** @typedef {import('./index.d.ts').sig_T} */
+/** @type {WeakRef<memo_T>} */
+let cur_memo
 /** @type {Set<()=>unknown>} */
 let queue = new Set
 /**
  * @param {rmemo_def_T}rmemo_def
  * @param {rmemo_subscriber_T<unknown>[]}subscriber_a
- * @returns {r_rmemo_T}
+ * @returns {memo_T}
  * @private
  */
-export function r_rmemo_(rmemo_def, ...subscriber_a) {
-	let refresh
-	let rmrs
-	let r_rmemo = {
-		get _() {
-			if (!('val' in r_rmemo)) {
-				refresh()
-			}
-			if (cur_rmr) {
-				let cur_rmr_refresh = cur_rmr.deref()
-				cur_rmr_refresh.l =
-					cur_rmr_refresh.l < refresh.l + 1
-						? refresh.l + 1
-						: cur_rmr_refresh.l
-				rmrs.add(cur_rmr)
-				cur_rmr_refresh.s.add(r_rmemo) // conditional in rmr calls this r_memo
-				cur_rmr_refresh.S.add(r_rmemo) // prevent this rmemo from GC while cur_rmr is still active
-			}
-			return r_rmemo.val
-		},
-		set _(val) {
-			if (val !== r_rmemo.val) {
-				r_rmemo.val = val // val is available for other purposes
+export function memo_(rmemo_def, ...subscriber_a) {
+	let memor
+	let memo = ()=>{
+		if (!('val' in memo)) {
+			memo.f()
+		}
+		if (cur_memo) {
+			if (!~memor.indexOf(cur_memo.r ||= new WeakRef(cur_memo.f))) memor.push(cur_memo.r)
+			if (cur_memo.f.l < memo.f.l + 1) cur_memo.f.l = memo.f.l + 1
+			// conditional in r calls this r_memo
+			cur_memo.f.s.push(memo)
+			// prevent this rmemo from GC while cur_memo is still active
+			if (!~cur_memo.f.S.indexOf(memo)) cur_memo.f.S.push(memo)
+		}
+		return memo.val
+	}
+	Object.defineProperty(memo, '_', {
+		get: memo,
+		set: val=>{
+			let i = memo.val
+			memo.val = val
+			if (i !== val) {
+				// val is available for other purposes
 				let run_queue = !queue.size
-				for (let rmr of rmrs) {
-					val = rmr.deref() // val is no longer used...saving bytes
+				i = 0
+				for (let r of memor) {
+					val = r.deref() // val is no longer used...saving bytes
 					if (!val) {
-						rmrs.delete(rmr)
-					} else if (val.s.has(r_rmemo)) { // if conditional rmr refresh calls this r_memo, add to queue
+						memor.splice(i, 1)
+					} else if (~val.s.indexOf(memo)) { // if conditional r refresh calls this r_memo, add to queue
 						queue.add(val)
 					}
+					i++
 				}
 				// add reference to subscribers to prevent GC
-				r_rmemo._s ||=
+				memo.b ||=
 					subscriber_a.map(subscriber=>
-						r_rmemo_(subscriber$=>(
-							subscriber(r_rmemo),
+						memo_(subscriber$=>(
+							subscriber(memo),
 							subscriber$
-						))._)
+						))())
 				if (run_queue) {
 					cur_refresh_loop:for (let cur_refresh of queue) {
 						queue.delete(cur_refresh)
@@ -64,46 +67,35 @@ export function r_rmemo_(rmemo_def, ...subscriber_a) {
 				}
 			}
 		},
-	}
-	refresh = ()=>{
-		let prev_rmr = cur_rmr
-		cur_rmr = r_rmemo.rmr
-		refresh.s.clear()
+	})
+	memo.f = ()=>{
+		let prev_memo = cur_memo
+		cur_memo = memo
+		memo.f.s = []
 		try {
-			r_rmemo._ = rmemo_def(r_rmemo)
+			memo._ = rmemo_def(memo)
 		} catch (err) {
 			console.error(err)
 		}
-		cur_rmr = prev_rmr // finally is not necessary due since catch does not throw
+		cur_memo = prev_memo // finally is not necessary...catch does not throw
 	}
-	refresh.l = 0
-	// rmrs = new Set
-	// r_rmemo.rmrs is kept for GC testing/debugging purposes...small size increase
-	r_rmemo.rmrs = rmrs = new Set
-	r_rmemo.rmr = new WeakRef(refresh)
-	refresh.s = new Set
-	refresh.S = new Set
-	return r_rmemo
+	memo.f.l = 0
+	memo.f.s = []
+	memo.f.S = []
+	memo.memor = memor = []
+	return memo
 }
-export { r_rmemo_ as rwr_rmemo_ }
+export { memo_ as memosig_ }
 /**
  * @param {unknown}init_val
  * @param {rmemo_subscriber_T[]}subscriber_a
- * @returns {r_rmemo_T}
+ * @returns {sig_T}
  * @private
  */
-export function rw_rmemo_(init_val, ...subscriber_a) {
-	return r_rmemo_(rw_rmemo=>
-		'val' in rw_rmemo
-			? rw_rmemo.val
+export function sig_(init_val, ...subscriber_a) {
+	return memo_(sig=>
+		'val' in sig
+			? sig.val
 			: init_val,
 	...subscriber_a)
 }
-/**
- * @param {rw_rmemo_T}rw_rmemo
- * @returns {(val:unknown)=>unknown}
- * @private
- */
-export function rw_rmemo__set_(rw_rmemo) {
-	return val=>rw_rmemo._ = val
-}

package/all/rmemo/index.test.ts

@@ -4,185 +4,198 @@ import { deepStrictEqual } from 'node:assert'
 import { test } from 'uvu'
 import { equal } from 'uvu/assert'
 import { sleep } from '../sleep/index.js'
-import { r_rmemo_, type r_rmemo_T, rw_rmemo_, rwr_rmemo_ } from './index.js'
-test('r_rmemo_|static value', ()=>{
+import { memo_, type memo_T, memosig_, sig_ } from './index.js'
+test('memo_|static value', ()=>{
 	let count = 0
-	const r_rmemo = r_rmemo_(()=>{
+	const memo = memo_(()=>{
 		count++
 		return 'rmemo-value'
 	})
 	equal(count, 0)
-	equal(r_rmemo._, 'rmemo-value')
+	equal(memo(), 'rmemo-value')
 	equal(count, 1)
-	equal(r_rmemo._, 'rmemo-value')
+	equal(memo(), 'rmemo-value')
 	equal(count, 1)
 })
-test('r_rmemo_|def function|rmemo argument', ()=>{
-	const rw_rmemo = rw_rmemo_('val0')
-	const r_rmemo:r_rmemo_T<string>&{ custom?:string } = r_rmemo_<string>((_rmemo$:r_rmemo_T<string>&{ custom?:string })=>
-		`${_rmemo$.custom}-${rw_rmemo._}`)
-	r_rmemo.custom = 'custom_val0'
-	equal(r_rmemo._, 'custom_val0-val0')
-	r_rmemo.custom = 'custom_val1'
-	equal(r_rmemo._, 'custom_val0-val0')
-	rw_rmemo._ = 'val1'
-	equal(r_rmemo._, 'custom_val1-val1')
+test('memo_|def function|rmemo argument', ()=>{
+	const sig = sig_('val0')
+	const memo:memo_T<string>&{ custom?:string } = memo_<string>((_rmemo$:memo_T<string>&{ custom?:string })=>
+		`${_rmemo$.custom}-${sig()}`)
+	memo.custom = 'custom_val0'
+	equal(memo(), 'custom_val0-val0')
+	memo.custom = 'custom_val1'
+	equal(memo(), 'custom_val0-val0')
+	sig._ = 'val1'
+	equal(memo(), 'custom_val1-val1')
 })
-test('r_memo_|side effect', ()=>{
+test('memo_|side effect', ()=>{
 	const history:string[] = []
-	const s = rw_rmemo_('This')
-	r_rmemo_(()=>history.push(s._))._
+	const s = sig_('This')
+	memo_(()=>history.push(s()))()
 	s._ = 'is'
 	s._ = 'a'
 	s._ = 'test'
 	s._ = 'test'
 	equal(history, ['This', 'is', 'a', 'test'])
 })
-test('r_rmemo_|conditional', ()=>{
-	const cond$ = rw_rmemo_(true)
-	const a$ = rw_rmemo_(1)
-	const b$ = rw_rmemo_(2)
-	const c$ = rw_rmemo_(3)
-	const d$ = rw_rmemo_(4)
+test('memo_|undefined', ()=>{
+	let count = 0
+	const memo = memo_(()=>{
+		count++
+		return undefined
+	})
+	equal(count, 0)
+	equal(memo(), undefined)
+	equal(count, 1)
+	equal(memo(), undefined)
+	equal(count, 1)
+})
+test('memo_|conditional', ()=>{
+	const cond$ = sig_(true)
+	const a$ = sig_(1)
+	const b$ = sig_(2)
+	const c$ = sig_(3)
+	const d$ = sig_(4)
 	let trigger_count = 0
-	const sum$ = r_rmemo_(()=>(++trigger_count, cond$._ ? a$._ + b$._ : c$._ + d$._))
-	equal(sum$._, 3)
+	const sum$ = memo_(()=>(++trigger_count, cond$() ? a$() + b$() : c$() + d$()))
+	equal(sum$(), 3)
 	equal(trigger_count, 1)
 	a$._ = 11
-	equal(sum$._, 13)
+	equal(sum$(), 13)
 	equal(trigger_count, 2)
 	b$._ = 12
-	equal(sum$._, 23)
+	equal(sum$(), 23)
 	equal(trigger_count, 3)
 	// Changing c$ or d$ won't triggered the effect as they're not its current dependencies
 	c$._ = 13
-	equal(sum$._, 23)
+	equal(sum$(), 23)
 	equal(trigger_count, 3)
 	d$._ = 14
-	equal(sum$._, 23)
+	equal(sum$(), 23)
 	equal(trigger_count, 3)
 	cond$._ = false
-	equal(sum$._, 27)
+	equal(sum$(), 27)
 	equal(trigger_count, 4)
 	c$._ = 23
-	equal(sum$._, 37)
+	equal(sum$(), 37)
 	equal(trigger_count, 5)
 	d$._ = 24
-	equal(sum$._, 47)
+	equal(sum$(), 47)
 	equal(trigger_count, 6)
 	// Changing a$ or b$ won't triggered the effect as they're not its current dependencies
 	a$._ = 21
-	equal(sum$._, 47)
+	equal(sum$(), 47)
 	equal(trigger_count, 6)
 	b$._ = 22
-	equal(sum$._, 47)
+	equal(sum$(), 47)
 	equal(trigger_count, 6)
 })
-test('rwr_rmemo_', ()=>{
-	const num_items$ = rw_rmemo_(0)
-	const items$ = r_rmemo_(()=>[...Array(num_items$._).keys()].map(i=>`Item ${i + 1}`))
-	const selected_index$ = rwr_rmemo_(()=>(items$._, 0))
-	const selected_item$ = r_rmemo_(()=>items$._[selected_index$._])
+test('memosig_', ()=>{
+	const num_items$ = sig_(0)
+	const items$ = memo_(()=>[...Array(num_items$()).keys()].map(i=>`Item ${i + 1}`))
+	// TODO: Jetbrains or Typescript type inference is wrong without generic
+	const selected_index$ = memosig_<number>(()=>(items$(), 0))
+	const selected_item$ = memo_(()=>items$()[selected_index$()])
 	num_items$._ = 3
-	equal(num_items$._, 3)
-	equal(items$._.join(','), 'Item 1,Item 2,Item 3')
-	equal(selected_index$._, 0)
-	equal(selected_item$._, 'Item 1')
+	equal(num_items$(), 3)
+	equal(items$().join(','), 'Item 1,Item 2,Item 3')
+	equal(selected_index$(), 0)
+	equal(selected_item$(), 'Item 1')
 	selected_index$._ = 2
-	equal(selected_index$._, 2)
-	equal(selected_item$._, 'Item 3')
+	equal(selected_index$(), 2)
+	equal(selected_item$(), 'Item 3')
 	num_items$._ = 5
-	equal(num_items$._, 5)
-	equal(items$._.join(','), 'Item 1,Item 2,Item 3,Item 4,Item 5')
-	equal(selected_index$._, 0)
-	equal(selected_item$._, 'Item 1')
+	equal(num_items$(), 5)
+	equal(items$().join(','), 'Item 1,Item 2,Item 3,Item 4,Item 5')
+	equal(selected_index$(), 0)
+	equal(selected_item$(), 'Item 1')
 	selected_index$._ = 3
-	equal(selected_index$._, 3)
-	equal(selected_item$._, 'Item 4')
+	equal(selected_index$(), 3)
+	equal(selected_item$(), 'Item 4')
 })
-test('r_rmemo_|error|case 1', ()=>{
-	const r$ = r_rmemo_(()=>{
+test('memo_|error|case 1', ()=>{
+	const r$ = memo_(()=>{
 		throw new Error('error case')
 	})
-	equal(r$._, undefined)
+	equal(r$(), undefined)
 })
-test('r_rmemo_|error|case 2', ()=>{
-	const rw0 = rw_rmemo_(1)
-	const r1 = r_rmemo_(()=>rw0._ * 2)
-	const r2 = r_rmemo_(()=>{
-		if (rw0._ > 1) throw new Error()
-		return rw0._
+test('memo_|error|case 2', ()=>{
+	const rw0 = sig_(1)
+	const r1 = memo_(()=>rw0() * 2)
+	const r2 = memo_(()=>{
+		if (rw0() > 1) throw new Error()
+		return rw0()
 	})
-	const r3 = r_rmemo_(()=>rw0._ * rw0._)
-	equal(r1._, 2)
-	equal(r2._, 1)
-	equal(r3._, 1)
+	const r3 = memo_(()=>rw0() * rw0())
+	equal(r1(), 2)
+	equal(r2(), 1)
+	equal(r3(), 1)
 	rw0._ = 3
-	equal(r1._, 6)
-	// r2._ keeps it's old value of 1 due to error
-	equal(r2._, 1)
-	equal(r3._, 9)
+	equal(r1(), 6)
+	// r2() keeps it's old value of 1 due to error
+	equal(r2(), 1)
+	equal(r3(), 9)
 })
-test('rw_rmemo_', ()=>{
-	const rw_rmemo = rw_rmemo_('val0')
-	equal(rw_rmemo._, 'val0')
-	rw_rmemo._ = 'val1'
-	equal(rw_rmemo._, 'val1')
+test('sig_', ()=>{
+	const sig = sig_('val0')
+	equal(sig(), 'val0')
+	sig._ = 'val1'
+	equal(sig(), 'val1')
 })
-test('rw_rmemo_|undefined', ()=>{
-	const rw_rmemo = rw_rmemo_(undefined)
-	const r_rmemo = r_rmemo_(()=>rw_rmemo._)
-	equal(rw_rmemo._, undefined)
-	equal(r_rmemo._, undefined)
+test('sig_|undefined', ()=>{
+	const sig = sig_(undefined)
+	const memo = memo_(()=>sig())
+	equal(sig(), undefined)
+	equal(memo(), undefined)
 })
-test('rw_rmemo_|async subsubscriber|case 1', async ()=>{
+test('sig_|async subsubscriber|case 1', async ()=>{
 	let resolve:(user:{ id:string })=>void
 	const user0 = { id: 'id-0' }
 	const user1 = { id: 'id-1' }
-	const id$ = rw_rmemo_('id-0')
+	const id$ = sig_('id-0')
 	let count = 0
-	const user$ = rw_rmemo_<{ id:string }|null>(
+	const user$ = sig_<{ id:string }|null>(
 		null,
 		async (_user$)=>{
 			count++
-			id$._
+			id$()
 			const user:{ id:string } = await new Promise(_resolve=>resolve = _resolve)
-			_user$._ = (user)
+			_user$._ = user
 		})
 	equal(count, 0)
-	equal(user$._, null)
+	equal(user$(), null)
 	equal(count, 1)
 	resolve!(user0)
 	await sleep(0)
 	equal(count, 1)
-	equal(user$._, user0)
+	equal(user$(), user0)
 	equal(count, 1)
 	id$._ = 'id-1'
 	equal(count, 2)
-	equal(user$._, user0)
+	equal(user$(), user0)
 	resolve!(user1)
 	await sleep(0)
 	equal(count, 2)
 })
-test('rw_rmemo_|async subsubscriber|case 2', async ()=>{
-	const a$ = rw_rmemo_(1)
-	const b$ = rw_rmemo_(2)
+test('sig_|async subsubscriber|case 2', async ()=>{
+	const a$ = sig_(1)
+	const b$ = sig_(2)
 	const sleepCycles = 5
 	const taskArgumentsCalls:number[][] = []
-	const sum$ = rw_rmemo_<null|number>(null,
+	const sum$ = sig_<null|number>(null,
 		async sum$=>{
-			taskArgumentsCalls.push([a$._, b$._])
+			taskArgumentsCalls.push([a$(), b$()])
 			for (let i = 0; i < sleepCycles; i++) {
 				await Promise.resolve()
 			}
-			sum$._ = a$._ + b$._
+			sum$._ = a$() + b$()
 		})
-	equal(sum$._, null)
+	equal(sum$(), null)
 	deepStrictEqual(taskArgumentsCalls, [[1, 2]])
 	a$._ = 10
 	b$._ = 20
 	for (let i = 0; i < sleepCycles; i++) {
-		equal(sum$._, null)
+		equal(sum$(), null)
 		await Promise.resolve()
 		deepStrictEqual(taskArgumentsCalls, [
 			[1, 2],
@@ -190,100 +203,100 @@ test('rw_rmemo_|async subsubscriber|case 2', async ()=>{
 			[10, 20]
 		])
 	}
-	equal(sum$._, 30)
+	equal(sum$(), 30)
 	deepStrictEqual(taskArgumentsCalls, [
 		[1, 2],
 		[10, 2],
 		[10, 20]
 	])
 })
-test('r_rmemo_+rw_rmemo_|simple graph', ()=>{
-	const base$ = rw_rmemo_('base0')
-	const dep0$ = r_rmemo_(()=>base$._ + '-dep0')
-	const dep1$ = r_rmemo_(()=>dep0$._ + '-dep1')
-	const dep2$ = r_rmemo_(()=>dep1$._ + '-dep2')
-	const dep3$ = r_rmemo_(()=>dep2$._ + '-dep3')
-	const dep4$ = r_rmemo_(()=>dep3$._ + '-dep4')
-	equal(dep4$._, 'base0-dep0-dep1-dep2-dep3-dep4')
-	equal(dep3$._, 'base0-dep0-dep1-dep2-dep3')
-	equal(dep2$._, 'base0-dep0-dep1-dep2')
-	equal(dep1$._, 'base0-dep0-dep1')
-	equal(dep0$._, 'base0-dep0')
-	equal(base$._, 'base0')
+test('memo_+sig_|simple graph', ()=>{
+	const base$ = sig_('base0')
+	const dep0$ = memo_(()=>base$() + '-dep0')
+	const dep1$ = memo_(()=>dep0$() + '-dep1')
+	const dep2$ = memo_(()=>dep1$() + '-dep2')
+	const dep3$ = memo_(()=>dep2$() + '-dep3')
+	const dep4$ = memo_(()=>dep3$() + '-dep4')
+	equal(dep4$(), 'base0-dep0-dep1-dep2-dep3-dep4')
+	equal(dep3$(), 'base0-dep0-dep1-dep2-dep3')
+	equal(dep2$(), 'base0-dep0-dep1-dep2')
+	equal(dep1$(), 'base0-dep0-dep1')
+	equal(dep0$(), 'base0-dep0')
+	equal(base$(), 'base0')
 	base$._ = 'base1'
-	equal(base$._, 'base1')
-	equal(dep0$._, 'base1-dep0')
-	equal(dep1$._, 'base1-dep0-dep1')
-	equal(dep2$._, 'base1-dep0-dep1-dep2')
-	equal(dep3$._, 'base1-dep0-dep1-dep2-dep3')
-	equal(dep4$._, 'base1-dep0-dep1-dep2-dep3-dep4')
+	equal(base$(), 'base1')
+	equal(dep0$(), 'base1-dep0')
+	equal(dep1$(), 'base1-dep0-dep1')
+	equal(dep2$(), 'base1-dep0-dep1-dep2')
+	equal(dep3$(), 'base1-dep0-dep1-dep2-dep3')
+	equal(dep4$(), 'base1-dep0-dep1-dep2-dep3-dep4')
 })
 test('prevents diamond dependency problem 1', ()=>{
-	const store$ = rw_rmemo_(0)
+	const store$ = sig_(0)
 	const values:string[] = []
-	const a$ = r_rmemo_(()=>`a${store$._}`)
-	const b$ = r_rmemo_(()=>a$._.replace('a', 'b'))
-	const c$ = r_rmemo_(()=>a$._.replace('a', 'c'))
-	const d$ = r_rmemo_(()=>a$._.replace('a', 'd'))
-	r_rmemo_(()=>`${b$._}${c$._}${d$._}`,
+	const a$ = memo_(()=>`a${store$()}`)
+	const b$ = memo_(()=>a$().replace('a', 'b'))
+	const c$ = memo_(()=>a$().replace('a', 'c'))
+	const d$ = memo_(()=>a$().replace('a', 'd'))
+	memo_(()=>`${b$()}${c$()}${d$()}`,
 		combined$=>
-			values.push(combined$._)
-	)._
+			values.push(combined$())
+	)()
 	deepStrictEqual(values, ['b0c0d0'])
 	store$._ = 1
 	store$._ = 2
 	deepStrictEqual(values, ['b0c0d0', 'b1c1d1', 'b2c2d2'])
 })
 test('prevents diamond dependency problem 2', ()=>{
-	const store$ = rw_rmemo_(0)
+	const store$ = sig_(0)
 	const values:string[] = []
-	const a$ = r_rmemo_(()=>`a${store$._}`)
-	const b$ = r_rmemo_(()=>a$._.replace('a', 'b'))
-	const c$ = r_rmemo_(()=>b$._.replace('b', 'c'))
-	const d$ = r_rmemo_(()=>c$._.replace('c', 'd'))
-	const e$ = r_rmemo_(()=>d$._.replace('d', 'e'))
-	r_rmemo_<string>(
-		()=>[a$._, e$._].join(''),
-		$=>values.push($._)
-	)._
+	const a$ = memo_(()=>`a${store$()}`)
+	const b$ = memo_(()=>a$().replace('a', 'b'))
+	const c$ = memo_(()=>b$().replace('b', 'c'))
+	const d$ = memo_(()=>c$().replace('c', 'd'))
+	const e$ = memo_(()=>d$().replace('d', 'e'))
+	memo_<string>(
+		()=>[a$(), e$()].join(''),
+		$=>values.push($())
+	)()
 	deepStrictEqual(values, ['a0e0'])
 	store$._ = 1
 	deepStrictEqual(values, ['a0e0', 'a1e1'])
 })
 test('prevents diamond dependency problem 3', ()=>{
-	const store$ = rw_rmemo_(0)
+	const store$ = sig_(0)
 	const values:string[] = []
-	const a$ = r_rmemo_(()=>`a${store$._}`)
-	const b$ = r_rmemo_(()=>a$._.replace('a', 'b'))
-	const c$ = r_rmemo_(()=>b$._.replace('b', 'c'))
-	const d$ = r_rmemo_(()=>c$._.replace('c', 'd'))
-	r_rmemo_<string>(
-		()=>`${a$._}${b$._}${c$._}${d$._}`,
-		combined$=>values.push(combined$._)
-	)._
+	const a$ = memo_(()=>`a${store$()}`)
+	const b$ = memo_(()=>a$().replace('a', 'b'))
+	const c$ = memo_(()=>b$().replace('b', 'c'))
+	const d$ = memo_(()=>c$().replace('c', 'd'))
+	memo_<string>(
+		()=>`${a$()}${b$()}${c$()}${d$()}`,
+		combined$=>values.push(combined$())
+	)()
 	deepStrictEqual(values, ['a0b0c0d0'])
 	store$._ = 1
 	deepStrictEqual(values, ['a0b0c0d0', 'a1b1c1d1'])
 })
 test('autosubscribe: prevents diamond dependency problem 4 (complex)', ()=>{
-	const store1$ = rw_rmemo_(0)
-	const store2$ = rw_rmemo_(0)
+	const store1$ = sig_(0)
+	const store2$ = sig_(0)
 	const values:string[] = []
-	const a$ = r_rmemo_(()=>`a${store1$._}`)
-	const b$ = r_rmemo_(()=>`b${store2$._}`)
-	const c$ = r_rmemo_(()=>`c${a$._}${b$._}`)
-	const d$ = r_rmemo_(()=>`d${a$._}`)
-	const e$ = r_rmemo_(()=>`e${c$._}${d$._}`)
-	const f$ = r_rmemo_(()=>`f${e$._}`)
-	const g$ = r_rmemo_(()=>`g${f$._}`)
-	r_rmemo_(
-		()=>e$._,
-		combined1$=>values.push(combined1$._)
-	)._
-	r_rmemo_(
-		()=>[e$._, g$._].join(''),
-		combined2$=>values.push(combined2$._)
-	)._
+	const a$ = memo_(()=>`a${store1$()}`)
+	const b$ = memo_(()=>`b${store2$()}`)
+	const c$ = memo_(()=>`c${a$()}${b$()}`)
+	const d$ = memo_(()=>`d${a$()}`)
+	const e$ = memo_(()=>`e${c$()}${d$()}`)
+	const f$ = memo_(()=>`f${e$()}`)
+	const g$ = memo_(()=>`g${f$()}`)
+	memo_(
+		()=>e$(),
+		combined1$=>values.push(combined1$())
+	)()
+	memo_(
+		()=>[e$(), g$()].join(''),
+		combined2$=>values.push(combined2$())
+	)()
 	deepStrictEqual(values, ['eca0b0da0', 'eca0b0da0gfeca0b0da0'])
 	store1$._ = 1
 	store2$._ = 2
@@ -298,66 +311,64 @@ test('autosubscribe: prevents diamond dependency problem 4 (complex)', ()=>{
 })
 test('prevents diamond dependency problem 5', ()=>{
 	let events = ''
-	const firstName$ = rw_rmemo_('John')
-	const lastName$ = rw_rmemo_('Doe')
-	const fullName$ = r_rmemo_(()=>{
+	const firstName$ = sig_('John')
+	const lastName$ = sig_('Doe')
+	const fullName$ = memo_(()=>{
 		events += 'full '
-		return `${firstName$._} ${lastName$._}`
+		return `${firstName$()} ${lastName$()}`
 	})
-	const isFirstShort$ = r_rmemo_(()=>{
+	const isFirstShort$ = memo_(()=>{
 		events += 'short '
-		return firstName$._.length < 10
+		return firstName$().length < 10
+	})
+	const displayName$ = memo_(()=>{
+		events += 'display '
+		return isFirstShort$() ? fullName$() : firstName$()
 	})
-	const displayName$ = r_rmemo_(
-		()=>{
-			events += 'display '
-			return isFirstShort$._ ? fullName$._ : firstName$._
-		}
-	)
 	equal(events, '')
-	equal(displayName$._, 'John Doe')
+	equal(displayName$(), 'John Doe')
 	equal(events, 'display short full ')
 	firstName$._ = 'Benedict'
-	equal(displayName$._, 'Benedict Doe')
+	equal(displayName$(), 'Benedict Doe')
 	equal(events, 'display short full short full display ')
 	firstName$._ = 'Montgomery'
-	equal(displayName$._, 'Montgomery')
+	equal(displayName$(), 'Montgomery')
 	equal(events, 'display short full short full display short full display ')
 })
 test('prevents diamond dependency problem 6', ()=>{
-	const store1$ = rw_rmemo_(0)
-	const store2$ = rw_rmemo_(0)
+	const store1$ = sig_(0)
+	const store2$ = sig_(0)
 	const values:string[] = []
-	const a$ = r_rmemo_(()=>`a${store1$._}`)
-	const b$ = r_rmemo_(()=>`b${store2$._}`)
-	const c$ = r_rmemo_(()=>b$._.replace('b', 'c'))
-	r_rmemo_(
-		()=>`${a$._}${c$._}`,
-		combined$=>values.push(combined$._)
-	)._
+	const a$ = memo_(()=>`a${store1$()}`)
+	const b$ = memo_(()=>`b${store2$()}`)
+	const c$ = memo_(()=>b$().replace('b', 'c'))
+	memo_(
+		()=>`${a$()}${c$()}`,
+		combined$=>values.push(combined$())
+	)()
 	deepStrictEqual(values, ['a0c0'])
 	store1$._ = 1
 	deepStrictEqual(values, ['a0c0', 'a1c0'])
 })
 test('prevents dependency listeners from being out of order', ()=>{
-	const base$ = rw_rmemo_(0)
-	const a$ = r_rmemo_(()=>{
-		return `${base$._}a`
+	const base$ = sig_(0)
+	const a$ = memo_(()=>{
+		return `${base$()}a`
 	})
 	const values:string[] = []
-	const b$ = r_rmemo_(()=>{
-		return `${a$._}b`
-	}, b$=>values.push(b$._))
-	equal(b$._, '0ab')
+	const b$ = memo_(()=>{
+		return `${a$()}b`
+	}, b$=>values.push(b$()))
+	equal(b$(), '0ab')
 	deepStrictEqual(values, ['0ab'])
-	equal(a$._, '0a')
+	equal(a$(), '0a')
 	base$._ = 1
 	deepStrictEqual(values, ['0ab', '1ab'])
 })
 test('computes initial value when argument is undefined', ()=>{
-	const one$ = rw_rmemo_<string|undefined>(undefined)
-	const two$ = r_rmemo_(()=>!!one$._)
-	equal(one$._, undefined)
-	equal(two$._, false)
+	const one$ = sig_<string|undefined>(undefined)
+	const two$ = memo_(()=>!!one$())
+	equal(one$(), undefined)
+	equal(two$(), false)
 })
 test.run()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "4.4.0",
+  "version": "4.6.0",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -105,16 +105,16 @@
     "./package.json": "./package.json"
   },
   "devDependencies": {
-    "@arethetypeswrong/cli": "^0.13.1",
+    "@arethetypeswrong/cli": "^0.13.2",
     "@size-limit/preset-small-lib": "^11.0.0",
-    "@types/node": "^20.9.4",
+    "@types/node": "^20.10.0",
     "@types/sinon": "^17.0.2",
     "c8": "^8.0.1",
     "check-dts": "^0.7.2",
     "sinon": "^17.0.1",
     "size-limit": "^11.0.0",
     "ts-node": "^10.9.1",
-    "tsx": "^4.3.0",
+    "tsx": "^4.5.0",
     "typescript": "next",
     "uvu": "^0.5.6"
   },
@@ -146,32 +146,32 @@
       "limit": "187 B"
     },
     {
-      "name": "r_rmemo_",
+      "name": "memo_",
       "import": {
-        "./rmemo": "{ r_rmemo_ }"
+        "./rmemo": "{ memo_ }"
       },
-      "limit": "298 B"
+      "limit": "344 B"
     },
     {
-      "name": "r_rmemo_ rw_rmemo_",
+      "name": "memo_ sig_",
       "import": {
-        "./rmemo": "{ rw_rmemo_, r_rmemo_ }"
+        "./rmemo": "{ sig_, memo_ }"
       },
-      "limit": "318 B"
+      "limit": "359 B"
     },
     {
-      "name": "r_rmemo_ rw_rmemo_ be_ ctx_",
+      "name": "memo_ sig_ be_ ctx_",
       "import": {
-        "./rmemo": "{ rw_rmemo_, r_rmemo_, be_, ctx_ }"
+        "./rmemo": "{ sig_, memo_, be_, ctx_ }"
       },
-      "limit": "478 B"
+      "limit": "519 B"
     },
     {
-      "name": "r_rmemo_ rw_rmemo_ be_ ctx_ be_r_rmemo_pair_ be_rw_rmemo_triple_",
+      "name": "memo_ sig_ be_ ctx_ be_memo_pair_ be_sig_triple_",
       "import": {
-        "./rmemo": "{ rw_rmemo_, r_rmemo_, be_, ctx_, be_r_rmemo_pair_, be_rw_rmemo_triple_ }"
+        "./rmemo": "{ sig_, memo_, be_, ctx_, be_memo_pair_, be_sig_triple_ }"
       },
-      "limit": "571 B"
+      "limit": "602 B"
     }
   ],
   "scripts": {

package/rmemo/index.d.ts

@@ -1,6 +1,6 @@
-export { rw_rmemo__set_ as set_ } from '../all/rmemo/index.js'
+export { sig__set_ as set_ } from '../all/rmemo/index.js'
 export * from '../all/be_/index.js'
-export * from '../all/be_r_rmemo_pair/index.js'
-export * from '../all/be_rw_rmemo_triple/index.js'
+export * from '../all/be_memo_pair/index.js'
+export * from '../all/be_sig_triple/index.js'
 export * from '../all/ctx/index.js'
 export * from '../all/rmemo/index.js'

package/rmemo/index.js

@@ -1,5 +1,5 @@
 export * from '../all/be_/index.js'
-export * from '../all/be_r_rmemo_pair/index.js'
-export * from '../all/be_rw_rmemo_triple/index.js'
+export * from '../all/be_memo_pair/index.js'
+export * from '../all/be_sig_triple/index.js'
 export * from '../all/ctx/index.js'
 export * from '../all/rmemo/index.js'

package/all/be_r_rmemo_pair/index.d.ts

@@ -1,25 +0,0 @@
-import type { Be, be__val__new_T, be_config_T, Ctx } from '../be_/index.js'
-import type { r_rmemo_T, rmemo_def_T } from '../rmemo/index.js'
-export declare function be_r_rmemo_pair_<
-	val_T,
-	_r_rmemo_T extends r_rmemo_T<val_T> = r_rmemo_T<val_T>,
-	ctx_T extends Ctx = Ctx
->(be: Be<_r_rmemo_T, ctx_T>):be_r_rmemo_pair_T<val_T, _r_rmemo_T, ctx_T>
-export declare function be_r_rmemo_pair_<
-	val_T,
-	_r_rmemo_T extends r_rmemo_T<val_T> = r_rmemo_T<val_T>,
-	ctx_T extends Ctx = Ctx
->(
-	rmemo__new:be__val__new_T<val_T>,
-	...subscriber_a_THEN_config:
-		|[...rmemo_def_T<val_T>[]]
-		|[...rmemo_def_T<val_T>[], config:be_config_T]
-):be_r_rmemo_pair_T<val_T, _r_rmemo_T, ctx_T>
-export type be_r_rmemo_pair_T<
-	val_T,
-	_r_rmemo_T extends r_rmemo_T<val_T> = r_rmemo_T<val_T>,
-	ctx_T extends Ctx = Ctx
-> = [
-	Be<_r_rmemo_T, ctx_T>,
-	(ctx:ctx_T)=>val_T
-]

package/all/be_rw_rmemo_triple/index.d.ts

@@ -1,26 +0,0 @@
-import type { Be, be__val__new_T, be_config_T, Ctx } from '../be_/index.js'
-import type { rw_rmemo_T, rmemo_def_T } from '../rmemo/index.js'
-export declare function be_rw_rmemo_triple_<
-	val_T,
-	_rw_rmemo_T extends rw_rmemo_T<val_T> = rw_rmemo_T<val_T>,
-	ctx_T extends Ctx = Ctx
->(be: Be<_rw_rmemo_T, ctx_T>):be_rw_rmemo_triple_T<val_T, _rw_rmemo_T, ctx_T>
-export declare function be_rw_rmemo_triple_<
-	val_T,
-	_rw_rmemo_T extends rw_rmemo_T<val_T> = rw_rmemo_T<val_T>,
-	ctx_T extends Ctx = Ctx
->(
-	rmemo__new:be__val__new_T<val_T>,
-	...subscriber_a_THEN_config:
-		|[...rmemo_def_T<val_T>[]]
-		|[...rmemo_def_T<val_T>[], config:be_config_T]
-):be_rw_rmemo_triple_T<val_T, _rw_rmemo_T, ctx_T>
-export type be_rw_rmemo_triple_T<
-	val_T,
-	_rw_rmemo_T extends rw_rmemo_T<val_T> = rw_rmemo_T<val_T>,
-	ctx_T extends Ctx = Ctx
-> = [
-	Be<_rw_rmemo_T>,
-	(ctx:ctx_T)=>val_T,
-	(ctx:ctx_T, val:val_T)=>void
-]