Tests

packages/effect-fc/src/Lens.ts

@@ -1,4 +1,4 @@
-import { Array, Effect, Pipeable, Predicate, Readable, Stream, Subscribable, SubscriptionRef } from "effect"
+import { Array, Chunk, Effect, flow, Option, Pipeable, Predicate, Readable, Stream, Subscribable, SubscriptionRef } from "effect"
 
 
 export const LensTypeId: unique symbol = Symbol.for("@effect-fc/Lens/Lens")
@@ -73,50 +73,46 @@ export const fromSubscriptionRef = <A>(
 
 export const map = <A, ER, RR, EW, RW, B>(
     self: Lens<A, ER, RR, EW, RW>,
-    options: {
+    get: (a: NoInfer<A>) => B,
-        readonly get: (a: A) => B,
+    set: {
-        readonly set: {
+        (b: B): (parent: NoInfer<A>) => NoInfer<A>
-            (b: B): (parent: A) => A
+        (parent: NoInfer<A>, b: B): NoInfer<A>
-            (parent: A, b: B): A
-        },
     },
 ): Lens<B, ER, RR, EW, RW> => make({
-    get get() { return Effect.map(self.get, options.get) },
+    get get() { return Effect.map(self.get, get) },
-    get changes() { return Stream.map(self.changes, options.get) },
+    get changes() { return Stream.map(self.changes, get) },
     modify: <C, E1 = never, R1 = never>(
         f: (b: B) => Effect.Effect<readonly [C, B], E1, R1>
     ) => self.modify(a =>
-        Effect.flatMap(f(options.get(a)), ([c, next]) => Effect.succeed([
+        Effect.flatMap(f(get(a)), ([c, next]) => Effect.succeed([
             c,
-            options.set.length >= 2
+            set.length >= 2
-                ? (options.set as (parent: A, b: B) => A)(a, next)
+                ? (set as (parent: A, b: B) => A)(a, next)
-                : (options.set as (b: B) => (parent: A) => A)(next)(a),
+                : (set as (b: B) => (parent: A) => A)(next)(a),
         ]))
     ),
 })
 
 export const mapEffect = <A, ER, RR, EW, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
     self: Lens<A, ER, RR, EW, RW>,
-    options: {
+    get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
-        readonly get: (a: A) => Effect.Effect<B, EGet, RGet>,
+    set: {
-        readonly set: {
+        (b: B): (parent: NoInfer<A>) => Effect.Effect<NoInfer<A>, ESet, RSet>
-            (b: B): (parent: A) => Effect.Effect<A, ESet, RSet>
+        (parent: NoInfer<A>, b: B): Effect.Effect<NoInfer<A>, ESet, RSet>
-            (parent: A, b: B): Effect.Effect<A, ESet, RSet>
-        },
     },
 ): Lens<B, ER | EGet, RR | RGet, EW | ESet, RW | RSet> => make({
-    get get() { return Effect.flatMap(self.get, options.get) },
+    get get() { return Effect.flatMap(self.get, get) },
-    get changes() { return Stream.mapEffect(self.changes, options.get) },
+    get changes() { return Stream.mapEffect(self.changes, get) },
     modify: <C, E1 = never, R1 = never>(
         f: (b: B) => Effect.Effect<readonly [C, B], E1, R1>
     ) => self.modify(a => Effect.flatMap(
-        options.get(a),
+        get(a),
         b => Effect.flatMap(
             f(b),
             ([c, bNext]) => Effect.flatMap(
-                options.set.length >= 2
+                set.length >= 2
-                    ? (options.set as (parent: A, b: B) => Effect.Effect<A, ESet, RSet>)(a, bNext)
+                    ? (set as (parent: A, b: B) => Effect.Effect<A, ESet, RSet>)(a, bNext)
-                    : (options.set as (b: B) => (parent: A) => Effect.Effect<A, ESet, RSet>)(bNext)(a),
+                    : (set as (b: B) => (parent: A) => Effect.Effect<A, ESet, RSet>)(bNext)(a),
                 nextA => Effect.succeed([c, nextA] as const),
             ),
         )
@@ -137,7 +133,11 @@ export const unwrap = <A, ER, RR, EW, RW, E1, R1>(
 Effect.gen(function*() {
     const myArrayRef = yield* SubscriptionRef.make([12, 38, 69])
     const myArrayLens = fromSubscriptionRef(myArrayRef)
-    const valueLens = mapEffect(myArrayLens, { get: Array.get(1), set: (a, b) => Array.replace(a, 1, b) })
+    const arrayValueLens = map(myArrayLens, flow(Array.get(1), Option.getOrThrow), (a, b) => Array.replace(a, 1, b))
+
+    const myChunkRef = yield* SubscriptionRef.make(Chunk.make([12, 38, 69]))
+    const myChunkLens = fromSubscriptionRef(myChunkRef)
+    const chunkValueLens = mapEffect(myChunkLens, Chunk.get(1), (a, b) => Effect.succeed(Chunk.replace(a, 1, b)))
 }).pipe(
     Effect.runSync
 )