0.2.1 + 2.0.0-beta.0 #6
@@ -324,13 +324,13 @@ extends LensImpl<A, ER, EW, RR, RW> {
|
||||
* Derives a new `Lens` by linking a step to an existing parent lens.
|
||||
*/
|
||||
export const derive: {
|
||||
<A, B, ER, EW, RR, RW, ER2, EW2, RR2, RW2>(
|
||||
source: DerivedLensImpl.Source<A, B, ER2, ER, EW2, EW, RR2, RR, RW2, RW>,
|
||||
): (self: Lens<B, ER, EW, RR, RW>) => Lens<A, ER2, EW2, RR2, RW2>
|
||||
<A, B, ER, EW, RR, RW, ER2, EW2, RR2, RW2>(
|
||||
self: Lens<B, ER, EW, RR, RW>,
|
||||
source: DerivedLensImpl.Source<A, B, ER2, ER, EW2, EW, RR2, RR, RW2, RW>,
|
||||
): Lens<A, ER2, EW2, RR2, RW2>
|
||||
<A, B, ER, EW, RR, RW, ER2, EW2, RR2, RW2>(
|
||||
source: DerivedLensImpl.Source<A, B, ER2, ER, EW2, EW, RR2, RR, RW2, RW>,
|
||||
): (self: Lens<B, ER, EW, RR, RW>) => Lens<A, ER2, EW2, RR2, RW2>
|
||||
} = Function.dual(2, <A, B, ER, EW, RR, RW, ER2, EW2, RR2, RW2>(
|
||||
self: Lens<B, ER, EW, RR, RW>,
|
||||
source: DerivedLensImpl.Source<A, B, ER2, ER, EW2, EW, RR2, RR, RW2, RW>,
|
||||
@@ -341,15 +341,15 @@ export const derive: {
|
||||
* Derives a new `Lens` by applying synchronous getters and setters over the focused value.
|
||||
*/
|
||||
export const map: {
|
||||
<A, ER, EW, RR, RW, B>(
|
||||
get: (a: NoInfer<A>) => B,
|
||||
set: (a: NoInfer<A>, b: B) => NoInfer<A>,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<B, ER, EW, RR, RW>
|
||||
<A, ER, EW, RR, RW, B>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
get: (a: NoInfer<A>) => B,
|
||||
set: (a: NoInfer<A>, b: B) => NoInfer<A>,
|
||||
): Lens<B, ER, EW, RR, RW>
|
||||
<A, ER, EW, RR, RW, B>(
|
||||
get: (a: NoInfer<A>) => B,
|
||||
set: (a: NoInfer<A>, b: B) => NoInfer<A>,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<B, ER, EW, RR, RW>
|
||||
} = Function.dual(3, <A, ER, EW, RR, RW, B>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
get: (a: NoInfer<A>) => B,
|
||||
@@ -370,15 +370,15 @@ export const map: {
|
||||
* Derives a new `Lens` by applying effectful getters and setters over the focused value.
|
||||
*/
|
||||
export const mapEffect: {
|
||||
<A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
|
||||
get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
|
||||
set: (a: NoInfer<A>, b: B) => Effect.Effect<NoInfer<A>, ESet, RSet>,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<B, ER | EGet, EW | ESet, RR | RGet, RW | RSet>
|
||||
<A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
|
||||
set: (a: NoInfer<A>, b: B) => Effect.Effect<NoInfer<A>, ESet, RSet>,
|
||||
): Lens<B, ER | EGet, EW | ESet, RR | RGet, RW | RSet>
|
||||
<A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
|
||||
get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
|
||||
set: (a: NoInfer<A>, b: B) => Effect.Effect<NoInfer<A>, ESet, RSet>,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<B, ER | EGet, EW | ESet, RR | RGet, RW | RSet>
|
||||
} = Function.dual(3, <A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
|
||||
@@ -406,15 +406,15 @@ export const mapEffect: {
|
||||
* - If the `Option` is `None`, it remains `None`
|
||||
*/
|
||||
export const mapOption: {
|
||||
<A, ER, EW, RR, RW, B>(
|
||||
get: (a: NoInfer<A>) => B,
|
||||
set: (a: NoInfer<A>, b: B) => NoInfer<A>,
|
||||
): (self: Lens<Option.Option<A>, ER, EW, RR, RW>) => Lens<Option.Option<B>, ER, EW, RR, RW>
|
||||
<A, ER, EW, RR, RW, B>(
|
||||
self: Lens<Option.Option<A>, ER, EW, RR, RW>,
|
||||
get: (a: NoInfer<A>) => B,
|
||||
set: (a: NoInfer<A>, b: B) => NoInfer<A>,
|
||||
): Lens<Option.Option<B>, ER, EW, RR, RW>
|
||||
<A, ER, EW, RR, RW, B>(
|
||||
get: (a: NoInfer<A>) => B,
|
||||
set: (a: NoInfer<A>, b: B) => NoInfer<A>,
|
||||
): (self: Lens<Option.Option<A>, ER, EW, RR, RW>) => Lens<Option.Option<B>, ER, EW, RR, RW>
|
||||
} = Function.dual(3, <A, ER, EW, RR, RW, B>(
|
||||
self: Lens<Option.Option<A>, ER, EW, RR, RW>,
|
||||
get: (a: NoInfer<A>) => B,
|
||||
@@ -436,15 +436,15 @@ export const mapOption: {
|
||||
* - If the `Option` is `None`, it remains `None`
|
||||
*/
|
||||
export const mapOptionEffect: {
|
||||
<A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
|
||||
get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
|
||||
set: (a: NoInfer<A>, b: B) => Effect.Effect<NoInfer<A>, ESet, RSet>,
|
||||
): (self: Lens<Option.Option<A>, ER, EW, RR, RW>) => Lens<Option.Option<B>, ER | EGet, EW | ESet, RR | RGet, RW | RSet>
|
||||
<A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
|
||||
self: Lens<Option.Option<A>, ER, EW, RR, RW>,
|
||||
get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
|
||||
set: (a: NoInfer<A>, b: B) => Effect.Effect<NoInfer<A>, ESet, RSet>,
|
||||
): Lens<Option.Option<B>, ER | EGet, EW | ESet, RR | RGet, RW | RSet>
|
||||
<A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
|
||||
get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
|
||||
set: (a: NoInfer<A>, b: B) => Effect.Effect<NoInfer<A>, ESet, RSet>,
|
||||
): (self: Lens<Option.Option<A>, ER, EW, RR, RW>) => Lens<Option.Option<B>, ER | EGet, EW | ESet, RR | RGet, RW | RSet>
|
||||
} = Function.dual(3, <A, ER, EW, RR, RW, B, EGet = never, RGet = never, ESet = never, RSet = never>(
|
||||
self: Lens<Option.Option<A>, ER, EW, RR, RW>,
|
||||
get: (a: NoInfer<A>) => Effect.Effect<B, EGet, RGet>,
|
||||
@@ -468,13 +468,13 @@ export const mapOptionEffect: {
|
||||
* Allows transforming only the `changes` stream of a `Lens` while keeping the focus type intact.
|
||||
*/
|
||||
export const mapStream: {
|
||||
<A, ER, EW, RR, RW>(
|
||||
f: (changes: Stream.Stream<NoInfer<A>, NoInfer<ER>, NoInfer<RR>>) => Stream.Stream<NoInfer<A>, NoInfer<ER>, NoInfer<RR>>,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW, RR, RW>
|
||||
<A, ER, EW, RR, RW>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
f: (changes: Stream.Stream<NoInfer<A>, NoInfer<ER>, NoInfer<RR>>) => Stream.Stream<NoInfer<A>, NoInfer<ER>, NoInfer<RR>>,
|
||||
): Lens<A, ER, EW, RR, RW>
|
||||
<A, ER, EW, RR, RW>(
|
||||
f: (changes: Stream.Stream<NoInfer<A>, NoInfer<ER>, NoInfer<RR>>) => Stream.Stream<NoInfer<A>, NoInfer<ER>, NoInfer<RR>>,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW, RR, RW>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
f: (changes: Stream.Stream<NoInfer<A>, NoInfer<ER>, NoInfer<RR>>) => Stream.Stream<NoInfer<A>, NoInfer<ER>, NoInfer<RR>>,
|
||||
@@ -491,13 +491,13 @@ export const mapStream: {
|
||||
* Applies to `get` and `changes` while leaving `modify` unchanged.
|
||||
*/
|
||||
export const mapErrorRead: {
|
||||
<A, ER, EW, RR, RW, E2>(
|
||||
f: (error: NoInfer<ER>) => E2,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, E2, EW, RR, RW>
|
||||
<A, ER, EW, RR, RW, E2>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
f: (error: NoInfer<ER>) => E2,
|
||||
): Lens<A, E2, EW, RR, RW>
|
||||
<A, ER, EW, RR, RW, E2>(
|
||||
f: (error: NoInfer<ER>) => E2,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, E2, EW, RR, RW>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW, E2>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
f: (error: NoInfer<ER>) => E2,
|
||||
@@ -514,13 +514,13 @@ export const mapErrorRead: {
|
||||
* user-supplied callback unchanged.
|
||||
*/
|
||||
export const mapErrorWrite: {
|
||||
<A, ER, EW, RR, RW, E2>(
|
||||
f: (error: NoInfer<EW>) => E2,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, E2, RR, RW>
|
||||
<A, ER, EW, RR, RW, E2>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
f: (error: NoInfer<EW>) => E2,
|
||||
): Lens<A, ER, E2, RR, RW>
|
||||
<A, ER, EW, RR, RW, E2>(
|
||||
f: (error: NoInfer<EW>) => E2,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, E2, RR, RW>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW, E2>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
f: (error: NoInfer<EW>) => E2,
|
||||
@@ -543,13 +543,13 @@ export const mapErrorWrite: {
|
||||
* failures from the user-supplied callback unchanged.
|
||||
*/
|
||||
export const mapError: {
|
||||
<A, ER, EW, RR, RW, E2>(
|
||||
f: (error: NoInfer<ER | EW>) => E2,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, E2, E2, RR, RW>
|
||||
<A, ER, EW, RR, RW, E2>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
f: (error: NoInfer<ER | EW>) => E2,
|
||||
): Lens<A, E2, E2, RR, RW>
|
||||
<A, ER, EW, RR, RW, E2>(
|
||||
f: (error: NoInfer<ER | EW>) => E2,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, E2, E2, RR, RW>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW, E2>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
f: (error: NoInfer<ER | EW>) => E2,
|
||||
@@ -574,13 +574,13 @@ export const mapError: {
|
||||
* Applies to `get` and `changes` while leaving `modify` unchanged.
|
||||
*/
|
||||
export const tapErrorRead: {
|
||||
<A, ER, EW, RR, RW, E2, R2>(
|
||||
f: (error: NoInfer<ER>) => Effect.Effect<unknown, E2, R2>,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER | E2, EW, RR | R2, RW>
|
||||
<A, ER, EW, RR, RW, E2, R2>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
f: (error: NoInfer<ER>) => Effect.Effect<unknown, E2, R2>,
|
||||
): Lens<A, ER | E2, EW, RR | R2, RW>
|
||||
<A, ER, EW, RR, RW, E2, R2>(
|
||||
f: (error: NoInfer<ER>) => Effect.Effect<unknown, E2, R2>,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER | E2, EW, RR | R2, RW>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW, E2, R2>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
f: (error: NoInfer<ER>) => Effect.Effect<unknown, E2, R2>,
|
||||
@@ -597,13 +597,13 @@ export const tapErrorRead: {
|
||||
* user-supplied callback unchanged.
|
||||
*/
|
||||
export const tapErrorWrite: {
|
||||
<A, ER, EW, RR, RW, E2, R2>(
|
||||
f: (error: NoInfer<EW>) => Effect.Effect<unknown, E2, R2>,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW | E2, RR, RW | R2>
|
||||
<A, ER, EW, RR, RW, E2, R2>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
f: (error: NoInfer<EW>) => Effect.Effect<unknown, E2, R2>,
|
||||
): Lens<A, ER, EW | E2, RR, RW | R2>
|
||||
<A, ER, EW, RR, RW, E2, R2>(
|
||||
f: (error: NoInfer<EW>) => Effect.Effect<unknown, E2, R2>,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW | E2, RR, RW | R2>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW, E2, R2>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
f: (error: NoInfer<EW>) => Effect.Effect<unknown, E2, R2>,
|
||||
@@ -626,13 +626,13 @@ export const tapErrorWrite: {
|
||||
* failures from the user-supplied callback unchanged.
|
||||
*/
|
||||
export const tapError: {
|
||||
<A, ER, EW, RR, RW, E2, R2>(
|
||||
f: (error: NoInfer<ER | EW>) => Effect.Effect<unknown, E2, R2>,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER | E2, EW | E2, RR | R2, RW | R2>
|
||||
<A, ER, EW, RR, RW, E2, R2>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
f: (error: NoInfer<ER | EW>) => Effect.Effect<unknown, E2, R2>,
|
||||
): Lens<A, ER | E2, EW | E2, RR | R2, RW | R2>
|
||||
<A, ER, EW, RR, RW, E2, R2>(
|
||||
f: (error: NoInfer<ER | EW>) => Effect.Effect<unknown, E2, R2>,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER | E2, EW | E2, RR | R2, RW | R2>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW, E2, R2>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
f: (error: NoInfer<ER | EW>) => Effect.Effect<unknown, E2, R2>,
|
||||
@@ -656,13 +656,13 @@ export const tapError: {
|
||||
* Provides a `Context` to a `Lens`, removing it from both the read and write environments.
|
||||
*/
|
||||
export const provideContext: {
|
||||
<R2>(
|
||||
context: Context.Context<R2>,
|
||||
): <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW, Exclude<RR, R2>, Exclude<RW, R2>>
|
||||
<A, ER, EW, RR, RW, R2>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
context: Context.Context<R2>,
|
||||
): Lens<A, ER, EW, Exclude<RR, R2>, Exclude<RW, R2>>
|
||||
<R2>(
|
||||
context: Context.Context<R2>,
|
||||
): <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW, Exclude<RR, R2>, Exclude<RW, R2>>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW, R2>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
context: Context.Context<R2>,
|
||||
@@ -685,15 +685,15 @@ export const provideContext: {
|
||||
* `Context.Tag` and you already have the concrete service value.
|
||||
*/
|
||||
export const provideService: {
|
||||
<I, S>(
|
||||
tag: Context.Tag<I, S>,
|
||||
service: NoInfer<S>,
|
||||
): <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW, Exclude<RR, I>, Exclude<RW, I>>
|
||||
<A, ER, EW, RR, RW, I, S>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
tag: Context.Tag<I, S>,
|
||||
service: NoInfer<S>,
|
||||
): Lens<A, ER, EW, Exclude<RR, I>, Exclude<RW, I>>
|
||||
<I, S>(
|
||||
tag: Context.Tag<I, S>,
|
||||
service: NoInfer<S>,
|
||||
): <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Lens<A, ER, EW, Exclude<RR, I>, Exclude<RW, I>>
|
||||
} = Function.dual(3, <A, ER, EW, RR, RW, I, S>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
tag: Context.Tag<I, S>,
|
||||
@@ -715,13 +715,13 @@ export const provideService: {
|
||||
* Narrows the focus to a field of an object. Replaces the object in an immutable fashion when written to.
|
||||
*/
|
||||
export const focusObjectOn: {
|
||||
<A extends object, ER, EW, RR, RW, K extends keyof A>(
|
||||
key: K,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A[K], ER, EW, RR, RW>
|
||||
<A extends object, ER, EW, RR, RW, K extends keyof A>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
key: K,
|
||||
): Lens<A[K], ER, EW, RR, RW>
|
||||
<A extends object, ER, EW, RR, RW, K extends keyof A>(
|
||||
key: K,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A[K], ER, EW, RR, RW>
|
||||
} = Function.dual(2, <A extends object, ER, EW, RR, RW, K extends keyof A>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
key: K,
|
||||
@@ -748,13 +748,13 @@ export declare namespace focusObjectOnWritable {
|
||||
* Narrows the focus to a writable field of an object. Mutates the object in place when written to.
|
||||
*/
|
||||
export const focusObjectOnWritable: {
|
||||
<A extends object, ER, EW, RR, RW, K extends focusObjectOnWritable.WritableKeys<A>>(
|
||||
key: K,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A[K], ER, EW, RR, RW>
|
||||
<A extends object, ER, EW, RR, RW, K extends focusObjectOnWritable.WritableKeys<A>>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
key: K,
|
||||
): Lens<A[K], ER, EW, RR, RW>
|
||||
<A extends object, ER, EW, RR, RW, K extends focusObjectOnWritable.WritableKeys<A>>(
|
||||
key: K,
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A[K], ER, EW, RR, RW>
|
||||
} = Function.dual(2, <A extends object, ER, EW, RR, RW, K extends focusObjectOnWritable.WritableKeys<A>>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
key: K,
|
||||
@@ -764,13 +764,13 @@ export const focusObjectOnWritable: {
|
||||
* Narrows the focus to an indexed element of an array. Replaces the array in an immutable fashion when written to.
|
||||
*/
|
||||
export const focusArrayAt: {
|
||||
<A extends readonly any[], ER, EW, RR, RW>(
|
||||
index: number
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A[number], ER | NoSuchElementException, EW | NoSuchElementException, RR, RW>
|
||||
<A extends readonly any[], ER, EW, RR, RW>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
index: number,
|
||||
): Lens<A[number], ER | NoSuchElementException, EW | NoSuchElementException, RR, RW>
|
||||
<A extends readonly any[], ER, EW, RR, RW>(
|
||||
index: number
|
||||
): (self: Lens<A, ER, EW, RR, RW>) => Lens<A[number], ER | NoSuchElementException, EW | NoSuchElementException, RR, RW>
|
||||
} = Function.dual(2, <A extends readonly any[], ER, EW, RR, RW>(
|
||||
self: Lens<A, ER, EW, RR, RW>,
|
||||
index: number,
|
||||
@@ -784,13 +784,13 @@ export const focusArrayAt: {
|
||||
* Narrows the focus to an indexed element of a mutable array. Mutates the array in place when written to.
|
||||
*/
|
||||
export const focusMutableArrayAt: {
|
||||
<A, ER, EW, RR, RW>(
|
||||
index: number
|
||||
): (self: Lens<A[], ER, EW, RR, RW>) => Lens<A, ER | NoSuchElementException, EW | NoSuchElementException, RR, RW>
|
||||
<A, ER, EW, RR, RW>(
|
||||
self: Lens<A[], ER, EW, RR, RW>,
|
||||
index: number,
|
||||
): Lens<A, ER | NoSuchElementException, EW | NoSuchElementException, RR, RW>
|
||||
<A, ER, EW, RR, RW>(
|
||||
index: number
|
||||
): (self: Lens<A[], ER, EW, RR, RW>) => Lens<A, ER | NoSuchElementException, EW | NoSuchElementException, RR, RW>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW>(
|
||||
self: Lens<A[], ER, EW, RR, RW>,
|
||||
index: number,
|
||||
@@ -807,13 +807,13 @@ export const focusMutableArrayAt: {
|
||||
* Narrows the focus to an indexed element of a readonly tuple. Replaces the tuple in an immutable fashion when written to.
|
||||
*/
|
||||
export const focusTupleAt: {
|
||||
<T extends readonly [any, ...any[]], ER, EW, RR, RW, I extends number>(
|
||||
index: I
|
||||
): (self: Lens<T, ER, EW, RR, RW>) => Lens<T[I], ER, EW, RR, RW>
|
||||
<T extends readonly [any, ...any[]], ER, EW, RR, RW, I extends number>(
|
||||
self: Lens<T, ER, EW, RR, RW>,
|
||||
index: I,
|
||||
): Lens<T[I], ER, EW, RR, RW>
|
||||
<T extends readonly [any, ...any[]], ER, EW, RR, RW, I extends number>(
|
||||
index: I
|
||||
): (self: Lens<T, ER, EW, RR, RW>) => Lens<T[I], ER, EW, RR, RW>
|
||||
} = Function.dual(2, <T extends readonly [any, ...any[]], ER, EW, RR, RW, I extends number>(
|
||||
self: Lens<T, ER, EW, RR, RW>,
|
||||
index: I,
|
||||
@@ -827,13 +827,13 @@ export const focusTupleAt: {
|
||||
* Narrows the focus to an indexed element of a mutable tuple. Mutates the tuple in place when written to.
|
||||
*/
|
||||
export const focusMutableTupleAt: {
|
||||
<T extends [any, ...any[]], ER, EW, RR, RW, I extends number>(
|
||||
index: I
|
||||
): (self: Lens<T, ER, EW, RR, RW>) => Lens<T[I], ER, EW, RR, RW>
|
||||
<T extends [any, ...any[]], ER, EW, RR, RW, I extends number>(
|
||||
self: Lens<T, ER, EW, RR, RW>,
|
||||
index: I,
|
||||
): Lens<T[I], ER, EW, RR, RW>
|
||||
<T extends [any, ...any[]], ER, EW, RR, RW, I extends number>(
|
||||
index: I
|
||||
): (self: Lens<T, ER, EW, RR, RW>) => Lens<T[I], ER, EW, RR, RW>
|
||||
} = Function.dual(2, <T extends [any, ...any[]], ER, EW, RR, RW, I extends number>(
|
||||
self: Lens<T, ER, EW, RR, RW>,
|
||||
index: I,
|
||||
@@ -847,13 +847,13 @@ export const focusMutableTupleAt: {
|
||||
* Narrows the focus to an indexed element of `Chunk`. Replaces the `Chunk` in an immutable fashion when written to.
|
||||
*/
|
||||
export const focusChunkAt: {
|
||||
<A, ER, EW, RR, RW>(
|
||||
index: number
|
||||
): (self: Lens<Chunk.Chunk<A>, ER, EW, RR, RW>) => Lens<A, ER | NoSuchElementException, EW, RR, RW>
|
||||
<A, ER, EW, RR, RW>(
|
||||
self: Lens<Chunk.Chunk<A>, ER, EW, RR, RW>,
|
||||
index: number,
|
||||
): Lens<A, ER | NoSuchElementException, EW, RR, RW>
|
||||
<A, ER, EW, RR, RW>(
|
||||
index: number
|
||||
): (self: Lens<Chunk.Chunk<A>, ER, EW, RR, RW>) => Lens<A, ER | NoSuchElementException, EW, RR, RW>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW>(
|
||||
self: Lens<Chunk.Chunk<A>, ER, EW, RR, RW>,
|
||||
index: number,
|
||||
@@ -887,6 +887,46 @@ export const focusOption: {
|
||||
*/
|
||||
export const get = <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>): Effect.Effect<A, ER, RR> => self.get
|
||||
|
||||
/**
|
||||
* Atomically modifies the value of a `Lens` and returns a computed result.
|
||||
*/
|
||||
export const modify: {
|
||||
<A, B>(f: (a: A) => readonly [B, A]): <ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<B, ER | EW, RR | RW>
|
||||
<A, ER, EW, RR, RW, B>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => readonly [B, A]): Effect.Effect<B, ER | EW, RR | RW>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW, B>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => readonly [B, A]) =>
|
||||
self.modifyEffect<B, never, never>(a => Effect.succeed(f(a))),
|
||||
)
|
||||
|
||||
/**
|
||||
* Atomically modifies the value of a `Lens` with an effect and returns a computed result.
|
||||
*/
|
||||
export const modifyEffect: {
|
||||
<A, B, E, R>(f: (a: A) => Effect.Effect<readonly [B, A], E, R>): <ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<B, ER | EW | E, RR | RW | R>
|
||||
<A, ER, EW, RR, RW, B, E, R>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => Effect.Effect<readonly [B, A], E, R>): Effect.Effect<B, ER | EW | E, RR | RW | R>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW, B, E, R>(self: Lens<A, ER, EW, RR, RW>, f: (a: A) => Effect.Effect<readonly [B, A], E, R>) =>
|
||||
self.modifyEffect(f),
|
||||
)
|
||||
|
||||
/**
|
||||
* Conditionally modifies the value of a `Lens`, returning `fallback` when the function returns `None`.
|
||||
*/
|
||||
export const modifySome: {
|
||||
<B, A>(fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): <ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<B, ER | EW, RR | RW>
|
||||
<A, ER, EW, RR, RW, B>(self: Lens<A, ER, EW, RR, RW>, fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): Effect.Effect<B, ER | EW, RR | RW>
|
||||
} = Function.dual(3, <A, ER, EW, RR, RW, B>(self: Lens<A, ER, EW, RR, RW>, fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>) =>
|
||||
self.modifyEffect<B, never, never>(a => Effect.succeed(Option.getOrElse(pf(a), () => [fallback, a] as const))),
|
||||
)
|
||||
|
||||
/**
|
||||
* Conditionally modifies the value of a `Lens` with an effect, returning `fallback` when the function returns `None`.
|
||||
*/
|
||||
export const modifySomeEffect: {
|
||||
<B, A, E, R>(fallback: B, pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>): <ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<B, ER | EW | E, RR | RW | R>
|
||||
<A, ER, EW, RR, RW, B, E, R>(self: Lens<A, ER, EW, RR, RW>, fallback: B, pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>): Effect.Effect<B, ER | EW | E, RR | RW | R>
|
||||
} = Function.dual(3, <A, ER, EW, RR, RW, B, E, R>(self: Lens<A, ER, EW, RR, RW>, fallback: B, pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>) =>
|
||||
self.modifyEffect<B, E, R>(a => Option.getOrElse(pf(a), () => Effect.succeed([fallback, a] as const))),
|
||||
)
|
||||
|
||||
/**
|
||||
* Sets the value of a `Lens`.
|
||||
*/
|
||||
@@ -953,6 +993,29 @@ export const getAndUpdateEffect: {
|
||||
)),
|
||||
)
|
||||
|
||||
/**
|
||||
* Conditionally updates a `Lens` and returns the previous value.
|
||||
*/
|
||||
export const getAndUpdateSome: {
|
||||
<A>(pf: (a: A) => Option.Option<A>): <ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<A, ER | EW, RR | RW>
|
||||
<A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<A>): Effect.Effect<A, ER | EW, RR | RW>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<A>) =>
|
||||
self.modifyEffect<A, never, never>(a => Effect.succeed([a, Option.getOrElse(pf(a), () => a)] as const)),
|
||||
)
|
||||
|
||||
/**
|
||||
* Conditionally updates a `Lens` with an effect and returns the previous value.
|
||||
*/
|
||||
export const getAndUpdateSomeEffect: {
|
||||
<A, E, R>(pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): <ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<A, ER | EW | E, RR | RW | R>
|
||||
<A, ER, EW, RR, RW, E, R>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): Effect.Effect<A, ER | EW | E, RR | RW | R>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW, E, R>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>) =>
|
||||
self.modifyEffect<A, E, R>(a => Effect.map(
|
||||
Option.getOrElse(pf(a), () => Effect.succeed(a)),
|
||||
next => [a, next] as const,
|
||||
)),
|
||||
)
|
||||
|
||||
/**
|
||||
* Sets the value of a `Lens` and returns the new value.
|
||||
*/
|
||||
@@ -988,3 +1051,52 @@ export const updateAndGetEffect: {
|
||||
next => Effect.succeed([next, next] as const),
|
||||
)),
|
||||
)
|
||||
|
||||
/**
|
||||
* Conditionally updates the value of a `Lens`.
|
||||
*/
|
||||
export const updateSome: {
|
||||
<A>(pf: (a: A) => Option.Option<A>): <ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<void, ER | EW, RR | RW>
|
||||
<A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<A>): Effect.Effect<void, ER | EW, RR | RW>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<A>) =>
|
||||
self.modifyEffect<void, never, never>(a => Effect.succeed([void 0, Option.getOrElse(pf(a), () => a)] as const)),
|
||||
)
|
||||
|
||||
/**
|
||||
* Conditionally updates the value of a `Lens` with an effect.
|
||||
*/
|
||||
export const updateSomeEffect: {
|
||||
<A, E, R>(pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): <ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<void, ER | EW | E, RR | RW | R>
|
||||
<A, ER, EW, RR, RW, E, R>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): Effect.Effect<void, ER | EW | E, RR | RW | R>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW, E, R>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>) =>
|
||||
self.modifyEffect<void, E, R>(a => Effect.map(
|
||||
Option.getOrElse(pf(a), () => Effect.succeed(a)),
|
||||
next => [void 0, next] as const,
|
||||
)),
|
||||
)
|
||||
|
||||
/**
|
||||
* Conditionally updates a `Lens` and returns the resulting value.
|
||||
*/
|
||||
export const updateSomeAndGet: {
|
||||
<A>(pf: (a: A) => Option.Option<A>): <ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<A, ER | EW, RR | RW>
|
||||
<A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<A>): Effect.Effect<A, ER | EW, RR | RW>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<A>) =>
|
||||
self.modifyEffect<A, never, never>(a => {
|
||||
const next = Option.getOrElse(pf(a), () => a)
|
||||
return Effect.succeed([next, next] as const)
|
||||
}),
|
||||
)
|
||||
|
||||
/**
|
||||
* Conditionally updates a `Lens` with an effect and returns the resulting value.
|
||||
*/
|
||||
export const updateSomeAndGetEffect: {
|
||||
<A, E, R>(pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): <ER, EW, RR, RW>(self: Lens<A, ER, EW, RR, RW>) => Effect.Effect<A, ER | EW | E, RR | RW | R>
|
||||
<A, ER, EW, RR, RW, E, R>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): Effect.Effect<A, ER | EW | E, RR | RW | R>
|
||||
} = Function.dual(2, <A, ER, EW, RR, RW, E, R>(self: Lens<A, ER, EW, RR, RW>, pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>) =>
|
||||
self.modifyEffect<A, E, R>(a => Effect.map(
|
||||
Option.getOrElse(pf(a), () => Effect.succeed(a)),
|
||||
next => [next, next] as const,
|
||||
)),
|
||||
)
|
||||
|
||||
@@ -8,13 +8,13 @@ export * from "effect/Subscribable"
|
||||
* Maps over an `Option` value in the `Subscribable`.
|
||||
*/
|
||||
export const mapOption: {
|
||||
<A, B>(
|
||||
f: (a: A) => B,
|
||||
): <E, R>(self: Subscribable.Subscribable<Option.Option<A>, E, R>) => Subscribable.Subscribable<Option.Option<B>, E, R>
|
||||
<A, B, E, R>(
|
||||
self: Subscribable.Subscribable<Option.Option<A>, E, R>,
|
||||
f: (a: A) => B,
|
||||
): Subscribable.Subscribable<Option.Option<B>, E, R>
|
||||
<A, B>(
|
||||
f: (a: A) => B,
|
||||
): <E, R>(self: Subscribable.Subscribable<Option.Option<A>, E, R>) => Subscribable.Subscribable<Option.Option<B>, E, R>
|
||||
} = Function.dual(2, <A, B, E, R>(
|
||||
self: Subscribable.Subscribable<Option.Option<A>, E, R>,
|
||||
f: (a: A) => B,
|
||||
@@ -24,13 +24,13 @@ export const mapOption: {
|
||||
* Maps over an `Option` value in the `Subscribable` with an Effect.
|
||||
*/
|
||||
export const mapOptionEffect: {
|
||||
<A, B, E2>(
|
||||
f: (a: A) => Effect.Effect<B, E2>,
|
||||
): <E, R>(self: Subscribable.Subscribable<Option.Option<A>, E, R>) => Subscribable.Subscribable<Option.Option<B>, E | E2, R>
|
||||
<A, B, E, E2, R>(
|
||||
self: Subscribable.Subscribable<Option.Option<A>, E, R>,
|
||||
f: (a: A) => Effect.Effect<B, E2, R>,
|
||||
): Subscribable.Subscribable<Option.Option<B>, E | E2, R>
|
||||
<A, B, E2>(
|
||||
f: (a: A) => Effect.Effect<B, E2>,
|
||||
): <E, R>(self: Subscribable.Subscribable<Option.Option<A>, E, R>) => Subscribable.Subscribable<Option.Option<B>, E | E2, R>
|
||||
} = Function.dual(2, <A, B, E, E2, R>(
|
||||
self: Subscribable.Subscribable<Option.Option<A>, E, R>,
|
||||
f: (a: A) => Effect.Effect<B, E2, R>,
|
||||
@@ -43,13 +43,13 @@ export const mapOptionEffect: {
|
||||
* Narrows the focus to a field of an object.
|
||||
*/
|
||||
export const focusObjectOn: {
|
||||
<A extends object, K extends keyof A, E, R>(
|
||||
key: K,
|
||||
): (self: Subscribable.Subscribable<A, E, R>) => Subscribable.Subscribable<A[K], E, R>
|
||||
<A extends object, K extends keyof A, E, R>(
|
||||
self: Subscribable.Subscribable<A, E, R>,
|
||||
key: K,
|
||||
): Subscribable.Subscribable<A[K], E, R>
|
||||
<A extends object, K extends keyof A, E, R>(
|
||||
key: K,
|
||||
): (self: Subscribable.Subscribable<A, E, R>) => Subscribable.Subscribable<A[K], E, R>
|
||||
} = Function.dual(2, <A extends object, K extends keyof A, E, R>(
|
||||
self: Subscribable.Subscribable<A, E, R>,
|
||||
key: K,
|
||||
@@ -59,13 +59,13 @@ export const focusObjectOn: {
|
||||
* Narrows the focus to an indexed element of an array.
|
||||
*/
|
||||
export const focusArrayAt: {
|
||||
<A extends readonly any[], E, R>(
|
||||
index: number
|
||||
): (self: Subscribable.Subscribable<A, E, R>) => Subscribable.Subscribable<A[number], E | NoSuchElementException, R>
|
||||
<A extends readonly any[], E, R>(
|
||||
self: Subscribable.Subscribable<A, E, R>,
|
||||
index: number,
|
||||
): Subscribable.Subscribable<A[number], E, R>
|
||||
<A extends readonly any[], E, R>(
|
||||
index: number
|
||||
): (self: Subscribable.Subscribable<A, E, R>) => Subscribable.Subscribable<A[number], E | NoSuchElementException, R>
|
||||
} = Function.dual(2, <A extends readonly any[], E, R>(
|
||||
self: Subscribable.Subscribable<A, E, R>,
|
||||
index: number,
|
||||
@@ -82,13 +82,13 @@ export const focusArrayLength = <A extends readonly any[], E, R>(
|
||||
* Narrows the focus to an indexed element of a readonly tuple.
|
||||
*/
|
||||
export const focusTupleAt: {
|
||||
<T extends readonly [any, ...any[]], I extends number, E, R>(
|
||||
index: I
|
||||
): (self: Subscribable.Subscribable<T, E, R>) => Subscribable.Subscribable<T[I], E, R>
|
||||
<T extends readonly [any, ...any[]], I extends number, E, R>(
|
||||
self: Subscribable.Subscribable<T, E, R>,
|
||||
index: I,
|
||||
): Subscribable.Subscribable<T[I], E, R>
|
||||
<T extends readonly [any, ...any[]], I extends number, E, R>(
|
||||
index: I
|
||||
): (self: Subscribable.Subscribable<T, E, R>) => Subscribable.Subscribable<T[I], E, R>
|
||||
} = Function.dual(2, <T extends readonly [any, ...any[]], I extends number, E, R>(
|
||||
self: Subscribable.Subscribable<T, E, R>,
|
||||
index: I,
|
||||
@@ -98,13 +98,13 @@ export const focusTupleAt: {
|
||||
* Narrows the focus to an indexed element of `Chunk`.
|
||||
*/
|
||||
export const focusChunkAt: {
|
||||
<A, E, R>(
|
||||
index: number
|
||||
): (self: Subscribable.Subscribable<Chunk.Chunk<A>, E, R>) => Subscribable.Subscribable<A, E | NoSuchElementException, R>
|
||||
<A, E, R>(
|
||||
self: Subscribable.Subscribable<Chunk.Chunk<A>, E, R>,
|
||||
index: number,
|
||||
): Subscribable.Subscribable<A, E | NoSuchElementException, R>
|
||||
<A, E, R>(
|
||||
index: number
|
||||
): (self: Subscribable.Subscribable<Chunk.Chunk<A>, E, R>) => Subscribable.Subscribable<A, E | NoSuchElementException, R>
|
||||
} = Function.dual(2, <A, E, R>(
|
||||
self: Subscribable.Subscribable<Chunk.Chunk<A>, E, R>,
|
||||
index: number,
|
||||
|
||||
Reference in New Issue
Block a user