@fncts/observable 0.0.17 → 0.0.19

package/_src/ObservableRef/api.ts

@@ -1,7 +1,6 @@
 import type { Lens } from "@fncts/base/optics/Lens";
-import type { URIO } from "@fncts/io/IO";
+import type { UIO } from "@fncts/io/IO";
 import type { Observable } from "@fncts/observable/Observable";
-import type { Store } from "@fncts/observable/ObservableRef/atomic";
 
 import { Atomic } from "@fncts/observable/ObservableRef/atomic";
 import { ObservableRef, ObservableRefDescriptor } from "@fncts/observable/ObservableRef/definition";
@@ -10,25 +9,22 @@ import { ObservableRef, ObservableRefDescriptor } from "@fncts/observable/Observ
  * @tsplus static fncts.observable.ObservableRefOps make
  * @tsplus static fncts.observable.ObservableRefOps __call
  */
-export function make<A>(initial: A, /** @fncts id */ id?: string): ObservableRef<Store, A, A> {
-  if (id === undefined) {
-    throw new Error("ObservableRef.make: the `id` argument must be provided if not using typescript transformers");
-  }
-  return new Atomic(new ObservableRefDescriptor(Symbol.for(id!), initial));
+export function make<A>(initial: A): ObservableRef<A, A> {
+  return new Atomic(new ObservableRefDescriptor(initial));
 }
 
 /**
  * @tsplus pipeable fncts.observable.ObservableRef update
  */
-export function update<R, A>(f: (a: A) => A) {
-  return (self: ObservableRef<R, A, A>): URIO<R, void> => self.modify((a) => [undefined, f(a)]);
+export function update<A>(f: (a: A) => A) {
+  return (self: ObservableRef<A, A>): UIO<void> => self.modify((a) => [undefined, f(a)]);
 }
 
 /**
  * @tsplus pipeable fncts.observable.ObservableRef getAndUpdate
  */
-export function getAndUpdate<R, A>(f: (a: A) => A) {
-  return (self: ObservableRef<R, A, A>): URIO<R, A> => {
+export function getAndUpdate<A>(f: (a: A) => A) {
+  return (self: ObservableRef<A, A>): UIO<A> => {
     return self.modify((a) => {
       const value = f(a);
       return [a, value];
@@ -39,8 +35,8 @@ export function getAndUpdate<R, A>(f: (a: A) => A) {
 /**
  * @tsplus pipeable fncts.observable.ObservableRef updateAndGet
  */
-export function updateAndGet<R, A>(f: (a: A) => A) {
-  return (self: ObservableRef<R, A, A>): URIO<R, A> => {
+export function updateAndGet<A>(f: (a: A) => A) {
+  return (self: ObservableRef<A, A>): UIO<A> => {
     return self.modify((a) => {
       const value = f(a);
       return [value, value];
@@ -51,8 +47,8 @@ export function updateAndGet<R, A>(f: (a: A) => A) {
 /**
  * @tsplus pipeable fncts.observable.ObservableRef modify
  */
-export function modify<R, A, B>(f: (a: A) => readonly [B, A]) {
-  return (self: ObservableRef<R, A, A>): URIO<R, B> => {
+export function modify<A, B>(f: (a: A) => readonly [B, A]) {
+  return (self: ObservableRef<A, A>): UIO<B> => {
     return self.get.flatMap((value) => {
       const [b, a] = f(value);
       return self.set(a) > IO.succeedNow(b);
@@ -60,110 +56,146 @@ export function modify<R, A, B>(f: (a: A) => readonly [B, A]) {
   };
 }
 
-class Map<R, A, B, C> extends ObservableRef<R, A, C> {
-  constructor(readonly source: ObservableRef<R, A, B>, readonly f: (b: B) => C) {
+class Map<A, B, C> extends ObservableRef<A, C> {
+  constructor(readonly source: ObservableRef<A, B>, readonly f: (b: B) => C) {
     super(source.descriptor);
   }
 
-  get: URIO<R, C> = this.source.get.map(this.f);
+  unsafeGet(): C {
+    return this.f(this.source.unsafeGet());
+  }
+
+  get: UIO<C> = this.source.get.map(this.f);
+
+  unsafeSet(a: A): void {
+    this.source.unsafeSet(a);
+  }
 
-  set(a: A): URIO<R, void> {
+  set(a: A): UIO<void> {
     return this.source.set(a);
   }
 
-  has: URIO<R, boolean> = this.source.has;
+  unsafeClear(): void {
+    this.source.unsafeClear();
+  }
 
-  delete: URIO<R, boolean> = this.source.delete;
+  clear: UIO<void> = this.source.clear;
 
-  observable: Observable<R, never, C> = this.source.observable.map(this.f);
+  observable: Observable<never, never, C> = this.source.observable.map(this.f);
 }
 
 /**
  * @tsplus pipeable fncts.observable.ObservableRef map
  */
-export function map<R, A, B, C>(f: (a: B) => C) {
-  return (self: ObservableRef<R, A, B>): ObservableRef<R, A, C> => {
+export function map<A, B, C>(f: (a: B) => C) {
+  return (self: ObservableRef<A, B>): ObservableRef<A, C> => {
     return new Map(self, f);
   };
 }
 
-class ContramapIn<R, A, B, C> extends ObservableRef<R, C, B> {
-  constructor(readonly source: ObservableRef<R, A, B>, readonly f: (c: C) => A) {
+class ContramapIn<A, B, C> extends ObservableRef<C, B> {
+  constructor(readonly source: ObservableRef<A, B>, readonly f: (c: C) => A) {
     super(source.descriptor);
   }
 
-  get: URIO<R, B> = this.source.get;
+  unsafeGet(): B {
+    return this.source.unsafeGet();
+  }
+
+  get: UIO<B> = this.source.get;
+
+  unsafeSet(c: C): void {
+    this.source.unsafeSet(this.f(c));
+  }
 
-  set(c: C): URIO<R, void> {
+  set(c: C): UIO<void> {
     return this.source.set(this.f(c));
   }
 
-  has: URIO<R, boolean> = this.source.has;
+  unsafeClear(): void {
+    this.source.unsafeClear();
+  }
 
-  delete: URIO<R, boolean> = this.source.delete;
+  clear: UIO<void> = this.source.clear;
 
-  observable: Observable<R, never, B> = this.source.observable;
+  observable: Observable<never, never, B> = this.source.observable;
 }
 
 /**
  * @tsplus pipeable fncts.observable.ObservableRef contramapIn
  */
-export function contramapIn<R, A, B, C>(f: (inp: C) => A) {
-  return (self: ObservableRef<R, A, B>): ObservableRef<R, C, B> => {
+export function contramapIn<A, B, C>(f: (inp: C) => A) {
+  return (self: ObservableRef<A, B>): ObservableRef<C, B> => {
     return new ContramapIn(self, f);
   };
 }
 
-class Focus<R, A, B> extends ObservableRef<R, B, B> {
-  constructor(readonly source: ObservableRef<R, A, A>, readonly lens: Lens<A, B>) {
+class Focus<A, B> extends ObservableRef<B, B> {
+  constructor(readonly source: ObservableRef<A, A>, readonly lens: Lens<A, B>) {
     super(source.descriptor);
   }
 
-  get: URIO<R, B> = this.source.get.map(this.lens.get);
+  unsafeGet(): B {
+    return this.lens.get(this.source.unsafeGet());
+  }
+
+  get: UIO<B> = this.source.get.map(this.lens.get);
+
+  unsafeSet(b: B): void {
+    this.source.unsafeSet(this.lens.set(b)(this.source.unsafeGet()));
+  }
 
-  set(b: B): URIO<R, void> {
+  set(b: B): UIO<void> {
     return this.source.get.flatMap((a) => this.source.set(this.lens.set(b)(a)));
   }
 
-  has: URIO<R, boolean> = this.source.has;
+  unsafeClear(): void {
+    this.source.unsafeClear();
+  }
 
-  delete: URIO<R, boolean> = this.source.delete;
+  clear: UIO<void> = this.source.clear;
 
-  observable: Observable<R, never, B> = this.source.observable.map(this.lens.get);
+  observable: Observable<never, never, B> = this.source.observable.map(this.lens.get);
 }
 
 /**
  * @tsplus pipeable fncts.observable.ObservableRef focus
  */
-export function focus<R, A, B>(lens: Lens<A, B>) {
-  return (self: ObservableRef<R, A, A>): ObservableRef<R, B, B> => {
+export function focus<A, B>(lens: Lens<A, B>) {
+  return (self: ObservableRef<A, A>): ObservableRef<B, B> => {
     return new Focus(self, lens);
   };
 }
 
-export class ZipWith<R, A, R1, B, C> implements ObservableRef.Readable<R | R1, C> {
-  declare _R: (_: never) => R | R1;
+export class ZipWith<A, B, C> implements ObservableRef.Readable<C> {
   declare _Out: (_: never) => C;
   constructor(
-    readonly sourceA: ObservableRef.Readable<R, A>,
-    readonly sourceB: ObservableRef.Readable<R1, B>,
+    readonly sourceA: ObservableRef.Readable<A>,
+    readonly sourceB: ObservableRef.Readable<B>,
     readonly f: (a: A, b: B) => C,
   ) {}
 
-  get: URIO<R | R1, C> = this.sourceA.get.zipWith(this.sourceB.get, this.f);
+  unsafeGet(): C {
+    return this.f(this.sourceA.unsafeGet(), this.sourceB.unsafeGet());
+  }
+
+  get: UIO<C> = this.sourceA.get.zipWith(this.sourceB.get, this.f);
 
-  has: URIO<R | R1, boolean> = this.sourceA.has.zipWith(this.sourceB.has, (a, b) => a && b);
+  unsafeClear() {
+    this.sourceA.unsafeClear();
+    this.sourceB.unsafeClear();
+  }
 
-  delete: URIO<R | R1, void> = this.sourceA.delete > this.sourceB.delete;
+  clear: UIO<void> = this.sourceA.clear > this.sourceB.clear;
 
-  observable: Observable<R | R1, never, C> = this.sourceA.observable.zipWithLatest(this.sourceB.observable, this.f);
+  observable: Observable<never, never, C> = this.sourceA.observable.zipWithLatest(this.sourceB.observable, this.f);
 }
 
 /**
  * @tsplus pipeable fncts.observable.ObservableRef.Readable zipWith
  */
-export function zipWith<R, A, R1, B, C>(that: ObservableRef.Readable<R1, B>, f: (a: A, b: B) => C) {
-  return (self: ObservableRef.Readable<R, A>): ObservableRef.Readable<R | R1, C> => {
+export function zipWith<A, B, C>(that: ObservableRef.Readable<B>, f: (a: A, b: B) => C) {
+  return (self: ObservableRef.Readable<A>): ObservableRef.Readable<C> => {
     return new ZipWith(self, that, f);
   };
 }

package/_src/ObservableRef/atomic.ts

@@ -1,85 +1,21 @@
-import type { ObservableRefDescriptor } from "@fncts/observable/ObservableRef/definition";
-
 import { BehaviorSubject } from "@fncts/observable/BehaviorSubject";
 
-export class Atomic<A> extends ObservableRef<Store, A, A> {
-  get: URIO<Store, A> = IO.serviceWithIO((reactor) => reactor.get(this.descriptor), Store.Tag);
+export class Atomic<A> extends ObservableRef<A, A> {
+  subject = new BehaviorSubject<A>(this.descriptor.initial);
 
-  set(a: A): URIO<Store, void> {
-    return IO.serviceWithIO((reactor) => reactor.set(this.descriptor, a), Store.Tag);
+  unsafeGet() {
+    return this.subject.value;
   }
 
-  has: URIO<Store, boolean> = IO.serviceWithIO((reactor) => reactor.has(this.descriptor), Store.Tag);
-
-  delete: URIO<Store, boolean> = IO.serviceWithIO((reactor) => reactor.delete(this.descriptor), Store.Tag);
-
-  observable: Observable<Store, never, A> = Observable.serviceWithObservable(
-    (reactor) =>
-      new Observable((subscriber) => {
-        return reactor.unsafeSubscribe(this.descriptor, subscriber);
-      }),
-    Store.Tag,
-  );
-}
-
-/**
- * @tsplus type fncts.observable.Store
- * @tsplus companion fncts.observable.StoreOps
- */
-export class Store {
-  subjectMap = new Map<symbol, BehaviorSubject<any>>();
-  get<A>(ref: ObservableRefDescriptor<A>): UIO<A> {
-    return IO(() => {
-      if (this.subjectMap.has(ref.id)) {
-        return this.subjectMap.get(ref.id)!.value;
-      } else {
-        this.subjectMap.set(ref.id, new BehaviorSubject(ref.initial));
-        return ref.initial;
-      }
-    });
+  unsafeSet(a: A): void {
+    this.subject.next(a);
   }
 
-  set<A>(ref: ObservableRefDescriptor<A>, value: A): UIO<A> {
-    return IO(() => {
-      if (this.subjectMap.has(ref.id)) {
-        this.subjectMap.get(ref.id)!.next(value);
-      } else {
-        this.subjectMap.set(ref.id, new BehaviorSubject(value));
-      }
-      return value;
-    });
+  unsafeClear(): void {
+    this.subject.next(this.descriptor.initial);
   }
 
-  has<A>(ref: ObservableRefDescriptor<A>): UIO<boolean> {
-    return IO(() => this.subjectMap.has(ref.id));
-  }
-
-  delete<A>(ref: ObservableRefDescriptor<A>): UIO<boolean> {
-    return IO(() => {
-      if (this.subjectMap.has(ref.id)) {
-        this.subjectMap.delete(ref.id);
-        return true;
-      }
-      return false;
-    });
-  }
-
-  unsafeSubscribe<A>(ref: ObservableRefDescriptor<A>, subscriber: Subscriber<never, A>): Subscription {
-    if (this.subjectMap.has(ref.id)) {
-      const subject      = this.subjectMap.get(ref.id)!;
-      const subscription = subject.subscribe(subscriber);
-      return subscription;
-    } else {
-      const subject      = new BehaviorSubject<A>(ref.initial);
-      const subscription = subject.subscribe(subscriber);
-      this.subjectMap.set(ref.id, subject);
-      return subscription;
-    }
-  }
+  observable: Observable<never, never, A> = new Observable((subscriber) => {
+    return this.subject.subscribe(subscriber);
+  });
 }
-
-/**
- * @tsplus static fncts.observable.StoreOps Tag
- * @tsplus implicit
- */
-export const StoreTag = Tag<Store>("fncts.observable.ObservableRef.StoreTag");

package/_src/ObservableRef/definition.ts

@@ -1,57 +1,58 @@
-import type { URIO } from "@fncts/io/IO";
 import type { Observable } from "@fncts/observable/Observable";
 
-type Readable_<R, A> = Readable<R, A>;
-type Writable_<R, A> = Writable<R, A>;
+type Readable_<A> = Readable<A>;
+type Writable_<A> = Writable<A>;
 
 export declare namespace ObservableRef {
-  type Readable<R, A> = Readable_<R, A>;
-  type Writable<R, A> = Writable_<R, A>;
+  type Readable<A> = Readable_<A>;
+  type Writable<A> = Writable_<A>;
 }
 
 export class ObservableRefDescriptor<A> {
-  constructor(readonly id: symbol, readonly initial: A) {}
+  constructor(readonly initial: A) {}
 }
 
-export interface CommonObservableRef<out R> {
-  readonly _R: (_: never) => R;
-  readonly has: URIO<R, boolean>;
-  readonly delete: URIO<R, void>;
+export interface CommonObservableRef {
+  readonly unsafeClear: () => void;
+  readonly clear: UIO<void>;
 }
 
 /**
  * @tsplus type fncts.observable.ObservableRef.Readable
  */
-export interface Readable<out R, out A> extends CommonObservableRef<R> {
-  readonly _R: (_: never) => R;
+export interface Readable<out A> extends CommonObservableRef {
   readonly _Out: (_: never) => A;
-  readonly get: URIO<R, A>;
-  readonly observable: Observable<R, never, A>;
+  readonly get: UIO<A>;
+  readonly unsafeGet: () => A;
+  readonly observable: Observable<never, never, A>;
 }
 
 /**
  * @tsplus type fncts.observable.ObservableRef.Writable
  */
-export interface Writable<out R, in A> extends CommonObservableRef<R> {
-  readonly _R: (_: never) => R;
+export interface Writable<in A> extends CommonObservableRef {
   readonly _In: (_: A) => void;
-  set(a: A): URIO<R, void>;
+  set(a: A): UIO<void>;
+  unsafeSet: (a: A) => void;
 }
 
 /**
  * @tsplus type fncts.observable.ObservableRef
  * @tsplus companion fncts.observable.ObservableRefOps
  */
-export abstract class ObservableRef<out R, in A, out B> implements Readable<R, B>, Writable<R, A> {
-  declare _R: (_: never) => R;
+export abstract class ObservableRef<in A, out B> implements Readable<B>, Writable<A> {
   declare _In: (_: A) => void;
   declare _Out: (_: never) => B;
 
   constructor(readonly descriptor: ObservableRefDescriptor<any>) {}
 
-  abstract readonly get: URIO<R, B>;
-  abstract set(a: A): URIO<R, void>;
-  abstract readonly delete: URIO<R, boolean>;
-  abstract readonly has: URIO<R, boolean>;
-  abstract readonly observable: Observable<R, never, B>;
+  abstract unsafeGet(): B;
+  readonly get: UIO<B> = IO(this.unsafeGet());
+  abstract unsafeSet(a: A): void;
+  set(a: A): UIO<void> {
+    return IO(this.unsafeSet(a));
+  }
+  abstract unsafeClear(): void;
+  readonly clear = IO(this.unsafeClear());
+  abstract readonly observable: Observable<never, never, B>;
 }

package/_src/ObservableRef.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: barrel, include: ./ObservableRef/*.ts }
+export * from "./ObservableRef/api.js";
+export * from "./ObservableRef/atomic.js";
+export * from "./ObservableRef/definition.js";
+// codegen:end

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@fncts/observable",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "dependencies": {
-    "@fncts/base": "0.0.28"
+    "@fncts/base": "0.0.30"
   },
   "exports": {
     "./*": {