Socket
Socket
Sign inDemoInstall

@effect/query

Package Overview
Dependencies
Maintainers
3
Versions
12
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@effect/query - npm Package Compare versions

Comparing version 0.1.2 to 0.1.3

8

Cache.d.ts

@@ -83,4 +83,4 @@ /**

export declare const get: {
<E, A>(request: Request.Request<E, A>): (self: Cache) => Effect.Effect<never, void, Ref.Ref<Option.Option<Either.Either<E, A>>>>;
<E, A>(self: Cache, request: Request.Request<E, A>): Effect.Effect<never, void, Ref.Ref<Option.Option<Either.Either<E, A>>>>;
<E, A>(request: Request.Request<E, A>): (self: Cache) => Effect.Effect<never, void, Ref.Ref<Option.Option<Either.Either<E, A>>>>;
};

@@ -98,4 +98,4 @@ /**

export declare const lookup: {
<E, A>(request: Request.Request<E, A>): (self: Cache) => Effect.Effect<never, never, Either.Either<Ref.Ref<Option.Option<Either.Either<E, A>>>, Ref.Ref<Option.Option<Either.Either<E, A>>>>>;
<E, A>(self: Cache, request: Request.Request<E, A>): Effect.Effect<never, never, Either.Either<Ref.Ref<Option.Option<Either.Either<E, A>>>, Ref.Ref<Option.Option<Either.Either<E, A>>>>>;
<E, A>(request: Request.Request<E, A>): (self: Cache) => Effect.Effect<never, never, Either.Either<Ref.Ref<Option.Option<Either.Either<E, A>>>, Ref.Ref<Option.Option<Either.Either<E, A>>>>>;
};

@@ -110,4 +110,4 @@ /**

export declare const set: {
<E, A>(request: Request.Request<E, A>, result: Ref.Ref<Option.Option<Either.Either<E, A>>>): (self: Cache) => Effect.Effect<never, never, void>;
<E, A>(self: Cache, request: Request.Request<E, A>, result: Ref.Ref<Option.Option<Either.Either<E, A>>>): Effect.Effect<never, never, void>;
<E, A>(request: Request.Request<E, A>, result: Ref.Ref<Option.Option<Either.Either<E, A>>>): (self: Cache) => Effect.Effect<never, never, void>;
};

@@ -121,5 +121,5 @@ /**

export declare const remove: {
<E, A>(request: Request.Request<E, A>): (self: Cache) => Effect.Effect<never, never, void>;
<E, A>(self: Cache, request: Request.Request<E, A>): Effect.Effect<never, never, void>;
<E, A>(request: Request.Request<E, A>): (self: Cache) => Effect.Effect<never, never, void>;
};
//# sourceMappingURL=Cache.d.ts.map

17

CompletedRequestMap.d.ts

@@ -0,6 +1,9 @@

/**
* @since 1.0.0
*/
import type * as Context from "@effect/data/Context";
import type * as HashSet from "@effect/data/HashSet";
import type * as Request from "@effect/query/Request";
import type * as Either from "@fp-ts/core/Either";
import type * as Option from "@fp-ts/core/Option";
import type * as Context from "@effect/data/Context";
import type * as HashSet from "@effect/data/HashSet";
/**

@@ -71,4 +74,4 @@ * @since 1.0.0

export declare const combine: {
(that: CompletedRequestMap): (self: CompletedRequestMap) => CompletedRequestMap;
(self: CompletedRequestMap, that: CompletedRequestMap): CompletedRequestMap;
(that: CompletedRequestMap): (self: CompletedRequestMap) => CompletedRequestMap;
};

@@ -82,4 +85,4 @@ /**

export declare const get: {
<A extends Request.Request<any, any>>(request: A): (self: CompletedRequestMap) => Option.Option<Request.Request.Result<A>>;
<A extends Request.Request<any, any>>(self: CompletedRequestMap, request: A): Option.Option<Request.Request.Result<A>>;
<A extends Request.Request<any, any>>(request: A): (self: CompletedRequestMap) => Option.Option<Request.Request.Result<A>>;
};

@@ -93,4 +96,4 @@ /**

export declare const has: {
<A extends Request.Request<any, any>>(request: A): (self: CompletedRequestMap) => boolean;
<A extends Request.Request<any, any>>(self: CompletedRequestMap, request: A): boolean;
<A extends Request.Request<any, any>>(request: A): (self: CompletedRequestMap) => boolean;
};

@@ -111,4 +114,4 @@ /**

export declare const set: {
<A extends Request.Request<any, any>>(request: A, result: Request.Request.Result<A>): (self: CompletedRequestMap) => void;
<A extends Request.Request<any, any>>(self: CompletedRequestMap, request: A, result: Request.Request.Result<A>): void;
<A extends Request.Request<any, any>>(request: A, result: Request.Request.Result<A>): (self: CompletedRequestMap) => void;
};

@@ -122,5 +125,5 @@ /**

export declare const setOption: {
<A extends Request.Request<any, any>>(request: A, result: Request.Request.OptionalResult<A>): (self: CompletedRequestMap) => void;
<A extends Request.Request<any, any>>(self: CompletedRequestMap, request: A, result: Request.Request.OptionalResult<A>): void;
<A extends Request.Request<any, any>>(request: A, result: Request.Request.OptionalResult<A>): (self: CompletedRequestMap) => void;
};
//# sourceMappingURL=CompletedRequestMap.d.ts.map

4

CompletedRequestMap.js

@@ -12,6 +12,2 @@ "use strict";

* @since 1.0.0
*/
/**
* @since 1.0.0
* @category symbols

@@ -18,0 +14,0 @@ */

26

DataSource.d.ts
/**
* @since 1.0.0
*/
import type * as Chunk from "@effect/data/Chunk";
import type * as Context from "@effect/data/Context";
import type * as Equal from "@effect/data/Equal";
import type * as Effect from "@effect/io/Effect";

@@ -10,5 +13,2 @@ import type * as CompletedRequestMap from "@effect/query/CompletedRequestMap";

import type * as Option from "@fp-ts/core/Option";
import type * as Chunk from "@effect/data/Chunk";
import type * as Context from "@effect/data/Context";
import type * as Equal from "@effect/data/Equal";
/**

@@ -106,4 +106,4 @@ * @since 1.0.0

export declare const around: {
<R, A extends Request.Request<any, any>, R2, A2, R3, _>(self: DataSource<R, A>, before: Described.Described<Effect.Effect<R2, never, A2>>, after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>): DataSource<R | R2 | R3, A>;
<R2, A2, R3, _>(before: Described.Described<Effect.Effect<R2, never, A2>>, after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>): <R, A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<R2 | R3 | R, A>;
<R2, A2, R3, _>(before: Described.Described<Effect.Effect<R2, never, A2>>, after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>): <R, A>(self: DataSource<R, A>) => DataSource<R2 | R3 | R, A>;
<R, A, R2, A2, R3, _>(self: DataSource<R, A>, before: Described.Described<Effect.Effect<R2, never, A2>>, after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>): DataSource<R | R2 | R3, A>;
};

@@ -117,4 +117,4 @@ /**

export declare const batchN: {
<R, A extends Request.Request<any, any>>(self: DataSource<R, A>, n: number): DataSource<R, A>;
(n: number): <R, A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<R, A>;
(n: number): <R, A>(self: DataSource<R, A>) => DataSource<R, A>;
<R, A>(self: DataSource<R, A>, n: number): DataSource<R, A>;
};

@@ -130,4 +130,4 @@ /**

export declare const contramap: {
<A extends Request.Request<any, any>, B extends Request.Request<any, any>>(f: Described.Described<(_: B) => A>): <R>(self: DataSource<R, A>) => DataSource<R, B>;
<R, A extends Request.Request<any, any>, B extends Request.Request<any, any>>(self: DataSource<R, A>, f: Described.Described<(_: B) => A>): DataSource<R, B>;
<A extends Request.Request<any, any>, B extends Request.Request<any, any>>(f: Described.Described<(_: B) => A>): <R>(self: DataSource<R, A>) => DataSource<R, B>;
};

@@ -141,4 +141,4 @@ /**

export declare const contramapContext: {
<R0, R>(f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>): <A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<R0, A>;
<R, A extends Request.Request<any, any>, R0>(self: DataSource<R, A>, f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>): DataSource<R0, A>;
<R0, R>(f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>): <A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<R0, A>;
};

@@ -154,4 +154,4 @@ /**

export declare const contramapEffect: {
<A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>>(f: Described.Described<(_: B) => Effect.Effect<R2, never, A>>): <R>(self: DataSource<R, A>) => DataSource<R2 | R, B>;
<R, A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>>(self: DataSource<R, A>, f: Described.Described<(_: B) => Effect.Effect<R2, never, A>>): DataSource<R | R2, B>;
<A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>>(f: Described.Described<(_: B) => Effect.Effect<R2, never, A>>): <R>(self: DataSource<R, A>) => DataSource<R2 | R, B>;
};

@@ -167,4 +167,4 @@ /**

export declare const eitherWith: {
<A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>, C extends Request.Request<any, any>>(that: DataSource<R2, B>, f: Described.Described<(_: C) => Either.Either<A, B>>): <R>(self: DataSource<R, A>) => DataSource<R2 | R, C>;
<R, A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>, C extends Request.Request<any, any>>(self: DataSource<R, A>, that: DataSource<R2, B>, f: Described.Described<(_: C) => Either.Either<A, B>>): DataSource<R | R2, C>;
<A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>, C extends Request.Request<any, any>>(that: DataSource<R2, B>, f: Described.Described<(_: C) => Either.Either<A, B>>): <R>(self: DataSource<R, A>) => DataSource<R2 | R, C>;
};

@@ -276,4 +276,4 @@ /**

export declare const provideContext: {
<R>(context: Described.Described<Context.Context<R>>): <A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<never, A>;
<R, A extends Request.Request<any, any>>(self: DataSource<R, A>, context: Described.Described<Context.Context<R>>): DataSource<never, A>;
<R>(context: Described.Described<Context.Context<R>>): <A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<never, A>;
};

@@ -289,5 +289,5 @@ /**

export declare const race: {
<R2, A2 extends Request.Request<any, any>>(that: DataSource<R2, A2>): <R, A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<R2 | R, A2 | A>;
<R, A extends Request.Request<any, any>, R2, A2 extends Request.Request<any, any>>(self: DataSource<R, A>, that: DataSource<R2, A2>): DataSource<R | R2, A | A2>;
<R2, A2 extends Request.Request<any, any>>(that: DataSource<R2, A2>): <R, A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<R2 | R, A2 | A>;
};
//# sourceMappingURL=DataSource.d.ts.map

14

internal_effect_untraced/completedRequestMap.js

@@ -10,4 +10,4 @@ "use strict";

var MutableRef = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/MutableRef"));
var Debug = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/io/Debug"));
var Either = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Either"));
var _Function = /*#__PURE__*/require("@fp-ts/core/Function");
var Option = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Option"));

@@ -40,3 +40,3 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

exports.make = make;
const combine = /*#__PURE__*/Debug.dual(2, (self, that) => {
const combine = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => {
const selfMap = MutableRef.get(self.map);

@@ -48,6 +48,6 @@ const thatMap = MutableRef.get(that.map);

exports.combine = combine;
const get = /*#__PURE__*/Debug.dual(2, (self, request) => HashMap.get(MutableRef.get(self.map), request));
const get = /*#__PURE__*/(0, _Function.dual)(2, (self, request) => HashMap.get(MutableRef.get(self.map), request));
/** @internal */
exports.get = get;
const has = /*#__PURE__*/Debug.dual(2, (self, request) => HashMap.has(MutableRef.get(self.map), request));
const has = /*#__PURE__*/(0, _Function.dual)(2, (self, request) => HashMap.has(MutableRef.get(self.map), request));
/** @internal */

@@ -58,3 +58,3 @@ exports.has = has;

exports.requests = requests;
const set = /*#__PURE__*/Debug.dual(3, (self, request, result) => {
const set = /*#__PURE__*/(0, _Function.dual)(3, (self, request, result) => {
const map = MutableRef.get(self.map);

@@ -65,6 +65,6 @@ MutableRef.set(self.map, HashMap.set(map, request, result));

exports.set = set;
const setOption = /*#__PURE__*/Debug.dual(3, (self, request, result) => {
Either.match(e => set(self, request, Either.left(e)), Option.match(() => self, a => set(self, request, Either.right(a))))(result);
const setOption = /*#__PURE__*/(0, _Function.dual)(3, (self, request, result) => {
Either.match(result, e => set(self, request, Either.left(e)), Option.match(() => self, a => set(self, request, Either.right(a))));
});
exports.setOption = setOption;
//# sourceMappingURL=completedRequestMap.js.map

14

internal_effect_untraced/request.js

@@ -45,21 +45,21 @@ "use strict";

exports.tagged = tagged;
const complete = /*#__PURE__*/Debug.dual(2, (self, result) => Effect.serviceWith(completedRequestMap.Tag, map => completedRequestMap.set(map, self, result)));
const complete = /*#__PURE__*/Debug.dualWithTrace(2, trace => (self, result) => Effect.serviceWith(completedRequestMap.Tag, map => completedRequestMap.set(map, self, result)).traced(trace));
/** @internal */
exports.complete = complete;
const completeEffect = /*#__PURE__*/Debug.dual(2, (self, effect) => Effect.matchEffect(effect,
const completeEffect = /*#__PURE__*/Debug.dualWithTrace(2, trace => (self, effect) => Effect.matchEffect(effect,
// @ts-expect-error
error => complete(self, Either.left(error)),
// @ts-expect-error
value => complete(self, Either.right(value))));
value => complete(self, Either.right(value))).traced(trace));
/** @internal */
exports.completeEffect = completeEffect;
const fail = /*#__PURE__*/Debug.dual(2, (self, error) =>
const fail = /*#__PURE__*/Debug.dualWithTrace(2, trace => (self, error) =>
// @ts-expect-error
complete(self, Either.left(error)));
complete(self, Either.left(error)).traced(trace));
/** @internal */
exports.fail = fail;
const succeed = /*#__PURE__*/Debug.dual(2, (self, value) =>
const succeed = /*#__PURE__*/Debug.dualWithTrace(2, trace => (self, value) =>
// @ts-expect-error
complete(self, Either.right(value)));
complete(self, Either.right(value)).traced(trace));
exports.succeed = succeed;
//# sourceMappingURL=request.js.map

8

package.json
{
"name": "@effect/query",
"version": "0.1.2",
"version": "0.1.3",
"license": "MIT",

@@ -10,5 +10,5 @@ "repository": {

"dependencies": {
"@effect/data": "~0.0.1",
"@effect/io": "~0.1.10",
"@fp-ts/core": "~0.1.1"
"@effect/data": "~0.1.0",
"@effect/io": "~0.1.11",
"@fp-ts/core": "~0.2.0"
},

@@ -15,0 +15,0 @@ "publishConfig": {

112

Query.d.ts
/**
* @since 1.0.0
*/
import type * as Chunk from "@effect/data/Chunk";
import type * as Context from "@effect/data/Context";
import type * as Duration from "@effect/data/Duration";
import type * as Cause from "@effect/io/Cause";

@@ -15,5 +18,2 @@ import type * as Debug from "@effect/io/Debug";

import type * as Option from "@fp-ts/core/Option";
import type * as Chunk from "@effect/data/Chunk";
import type * as Context from "@effect/data/Context";
import type * as Duration from "@effect/data/Duration";
/**

@@ -107,4 +107,4 @@ * @since 1.0.0

export declare const around: {
<R2, A2, R3, _>(before: Described.Described<Effect.Effect<R2, never, A2>>, after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R3 | R, E, A>;
<R, E, A, R2, A2, R3, _>(self: Query<R, E, A>, before: Described.Described<Effect.Effect<R2, never, A2>>, after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>): Query<R | R2 | R3, E, A>;
<R2, A2, R3, _>(before: Described.Described<Effect.Effect<R2, never, A2>>, after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R3 | R, E, A>;
};

@@ -118,4 +118,4 @@ /**

export declare const as: {
<A2>(value: A2): <R, E, A>(self: Query<R, E, A>) => Query<R, E, A2>;
<R, E, A, A2>(self: Query<R, E, A>, value: A2): Query<R, E, A2>;
<A2>(value: A2): <R, E, A>(self: Query<R, E, A>) => Query<R, E, A2>;
};

@@ -153,4 +153,4 @@ /**

export declare const catchAll: {
<E, R2, E2, A2>(f: (error: E) => Query<R2, E2, A2>): <R, A>(self: Query<R, E, A>) => Query<R2 | R, E2, A2 | A>;
<R, A, E, R2, E2, A2>(self: Query<R, E, A>, f: (error: E) => Query<R2, E2, A2>): Query<R | R2, E2, A | A2>;
<E, R2, E2, A2>(f: (error: E) => Query<R2, E2, A2>): <R, A>(self: Query<R, E, A>) => Query<R2 | R, E2, A2 | A>;
};

@@ -165,4 +165,4 @@ /**

export declare const catchAllCause: {
<E, R2, E2, A2>(f: (cause: Cause.Cause<E>) => Query<R2, E2, A2>): <R, A>(self: Query<R, E, A>) => Query<R2 | R, E2, A2 | A>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, f: (cause: Cause.Cause<E>) => Query<R2, E2, A2>): Query<R | R2, E2, A | A2>;
<E, R2, E2, A2>(f: (cause: Cause.Cause<E>) => Query<R2, E2, A2>): <R, A>(self: Query<R, E, A>) => Query<R2 | R, E2, A2 | A>;
};

@@ -229,4 +229,4 @@ /**

export declare const contramapContext: {
<R0, R>(f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>): <E, A>(self: Query<R, E, A>) => Query<R0, E, A>;
<R, E, A, R0>(self: Query<R, E, A>, f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>): Query<R0, E, A>;
<R0, R>(f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>): <E, A>(self: Query<R, E, A>) => Query<R0, E, A>;
};

@@ -265,4 +265,4 @@ /**

export declare const ensuring: {
<R2, E2, A2>(finalizer: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, finalizer: Query<R2, E2, A2>): Query<R | R2, E | E2, A>;
<R2, E2, A2>(finalizer: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>;
};

@@ -308,4 +308,4 @@ /**

export declare const flatMap: {
<A, R2, E2, A2>(f: (a: A) => Query<R2, E2, A2>): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, f: (a: A) => Query<R2, E2, A2>): Query<R | R2, E | E2, A2>;
<A, R2, E2, A2>(f: (a: A) => Query<R2, E2, A2>): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
};

@@ -331,4 +331,4 @@ /**

export declare const forEach: {
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>;
<A, R, E, B>(elements: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, E, Chunk.Chunk<B>>;
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>;
};

@@ -344,4 +344,4 @@ /**

export declare const forEachBatched: {
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>;
<A, R, E, B>(elements: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, E, Chunk.Chunk<B>>;
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>;
};

@@ -357,4 +357,4 @@ /**

export declare const forEachPar: {
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>;
<A, R, E, B>(elements: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, E, Chunk.Chunk<B>>;
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>;
};

@@ -415,4 +415,4 @@ /**

export declare const map: {
<A, B>(f: (a: A) => B): <R, E>(self: Query<R, E, A>) => Query<R, E, B>;
<R, E, A, B>(self: Query<R, E, A>, f: (a: A) => B): Query<R, E, B>;
<A, B>(f: (a: A) => B): <R, E>(self: Query<R, E, A>) => Query<R, E, B>;
};

@@ -427,4 +427,4 @@ /**

export declare const mapBoth: {
<E, E2, A, A2>(f: (e: E) => E2, g: (a: A) => A2): <R>(self: Query<R, E, A>) => Query<R, E2, A2>;
<R, E, E2, A, A2>(self: Query<R, E, A>, f: (e: E) => E2, g: (a: A) => A2): Query<R, E2, A2>;
<E, E2, A, A2>(f: (e: E) => E2, g: (a: A) => A2): <R>(self: Query<R, E, A>) => Query<R, E2, A2>;
};

@@ -438,4 +438,4 @@ /**

export declare const mapDataSources: {
<R, A, R2>(f: (dataSource: DataSource.DataSource<R, A>) => DataSource.DataSource<R2, A>): <E>(self: Query<R, E, A>) => Query<R | R2, E, A>;
<R, E, A, R2>(self: Query<R, E, A>, f: (dataSource: DataSource.DataSource<R, A>) => DataSource.DataSource<R2, A>): Query<R | R2, E, A>;
<R, A, R2>(f: (dataSource: DataSource.DataSource<R, A>) => DataSource.DataSource<R2, A>): <E>(self: Query<R, E, A>) => Query<R | R2, E, A>;
};

@@ -449,4 +449,4 @@ /**

export declare const mapError: {
<E, E2>(f: (e: E) => E2): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>;
<R, A, E, E2>(self: Query<R, E, A>, f: (e: E) => E2): Query<R, E2, A>;
<E, E2>(f: (e: E) => E2): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>;
};

@@ -462,4 +462,4 @@ /**

export declare const mapErrorCause: {
<E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>;
<R, E, A, E2>(self: Query<R, E, A>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Query<R, E2, A>;
<E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>;
};

@@ -473,4 +473,4 @@ /**

export declare const mapEffect: {
<A, R2, E2, A2>(f: (a: A) => Effect.Effect<R2, E2, A2>): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, A2>): Query<R | R2, E | E2, A2>;
<A, R2, E2, A2>(f: (a: A) => Effect.Effect<R2, E2, A2>): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
};

@@ -486,4 +486,4 @@ /**

export declare const match: {
<E, Z, A>(onFailure: (error: E) => Z, onSuccess: (value: A) => Z): <R>(self: Query<R, E, A>) => Query<R, never, Z>;
<R, E, A, Z>(self: Query<R, E, A>, onFailure: (error: E) => Z, onSuccess: (value: A) => Z): Query<R, never, Z>;
<E, Z, A>(onFailure: (error: E) => Z, onSuccess: (value: A) => Z): <R>(self: Query<R, E, A>) => Query<R, never, Z>;
};

@@ -498,4 +498,4 @@ /**

export declare const matchCauseQuery: {
<E, R2, E2, A2, A, R3, E3, A3>(onFailure: (cause: Cause.Cause<E>) => Query<R2, E2, A2>, onSuccess: (value: A) => Query<R3, E3, A3>): <R>(self: Query<R, E, A>) => Query<R2 | R3 | R, E2 | E3, A2 | A3>;
<R, E, A, R2, E2, A2, R3, E3, A3>(self: Query<R, E, A>, onFailure: (cause: Cause.Cause<E>) => Query<R2, E2, A2>, onSuccess: (value: A) => Query<R3, E3, A3>): Query<R | R2 | R3, E2 | E3, A2 | A3>;
<E, R2, E2, A2, A, R3, E3, A3>(onFailure: (cause: Cause.Cause<E>) => Query<R2, E2, A2>, onSuccess: (value: A) => Query<R3, E3, A3>): <R>(self: Query<R, E, A>) => Query<R2 | R3 | R, E2 | E3, A2 | A3>;
};

@@ -510,4 +510,4 @@ /**

export declare const matchQuery: {
<E, R2, E2, A2, A, R3, E3, A3>(onFailure: (error: E) => Query<R2, E2, A2>, onSuccess: (value: A) => Query<R3, E3, A3>): <R>(self: Query<R, E, A>) => Query<R2 | R3 | R, E2 | E3, A2 | A3>;
<R, E, A, R2, E2, A2, R3, E3, A3>(self: Query<R, E, A>, onFailure: (error: E) => Query<R2, E2, A2>, onSuccess: (value: A) => Query<R3, E3, A3>): Query<R | R2 | R3, E2 | E3, A2 | A3>;
<E, R2, E2, A2, A, R3, E3, A3>(onFailure: (error: E) => Query<R2, E2, A2>, onSuccess: (value: A) => Query<R3, E3, A3>): <R>(self: Query<R, E, A>) => Query<R2 | R3 | R, E2 | E3, A2 | A3>;
};

@@ -521,4 +521,4 @@ /**

export declare const maxBatchSize: {
(n: number): <R, E, A>(self: Query<R, E, A>) => Query<R, E, A>;
<R, E, A>(self: Query<R, E, A>, n: number): Query<R, E, A>;
(n: number): <R, E, A>(self: Query<R, E, A>) => Query<R, E, A>;
};

@@ -555,4 +555,4 @@ /**

export declare const orDieWith: {
<E>(f: (error: E) => unknown): <R, A>(self: Query<R, E, A>) => Query<R, never, A>;
<R, E, A>(self: Query<R, E, A>, f: (error: E) => unknown): Query<R, never, A>;
<E>(f: (error: E) => unknown): <R, A>(self: Query<R, E, A>) => Query<R, never, A>;
};

@@ -568,4 +568,4 @@ /**

export declare const partitionQuery: {
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>;
<A, R, E, B>(elements: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>;
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>;
};

@@ -581,4 +581,4 @@ /**

export declare const partitionQueryPar: {
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>;
<A, R, E, B>(elements: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>;
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>;
};

@@ -592,4 +592,4 @@ /**

export declare const provideContext: {
<R>(context: Described.Described<Context.Context<R>>): <E, A>(self: Query<R, E, A>) => Query<never, E, A>;
<R, E, A>(self: Query<R, E, A>, context: Described.Described<Context.Context<R>>): Query<never, E, A>;
<R>(context: Described.Described<Context.Context<R>>): <E, A>(self: Query<R, E, A>) => Query<never, E, A>;
};

@@ -603,4 +603,4 @@ /**

export declare const provideLayer: {
<R0, E2, R>(layer: Described.Described<Layer.Layer<R0, E2, R>>): <E, A>(self: Query<R, E, A>) => Query<R0, E2 | E, A>;
<R, E, A, R0, E2>(self: Query<R, E, A>, layer: Described.Described<Layer.Layer<R0, E2, R>>): Query<R0, E | E2, A>;
<R0, E2, R>(layer: Described.Described<Layer.Layer<R0, E2, R>>): <E, A>(self: Query<R, E, A>) => Query<R0, E2 | E, A>;
};

@@ -615,4 +615,4 @@ /**

export declare const provideSomeLayer: {
<R2, E2, A2>(layer: Described.Described<Layer.Layer<R2, E2, A2>>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | Exclude<R, A2>, E2 | E, A>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, layer: Described.Described<Layer.Layer<R2, E2, A2>>): Query<R2 | Exclude<R, A2>, E | E2, A>;
<R2, E2, A2>(layer: Described.Described<Layer.Layer<R2, E2, A2>>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | Exclude<R, A2>, E2 | E, A>;
};

@@ -627,4 +627,4 @@ /**

export declare const race: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2 | A>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A | A2>;
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2 | A>;
};

@@ -638,4 +638,4 @@ /**

export declare const refineOrDie: {
<E, E2>(pf: (error: E) => Option.Option<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>;
<R, E, A, E2>(self: Query<R, E, A>, pf: (error: E) => Option.Option<E2>): Query<R, E2, A>;
<E, E2>(pf: (error: E) => Option.Option<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>;
};

@@ -650,4 +650,4 @@ /**

export declare const refineOrDieWith: {
<E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>;
<R, E, A, E2>(self: Query<R, E, A>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): Query<R, E2, A>;
<E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>;
};

@@ -677,4 +677,4 @@ /**

export declare const runCache: {
(cache: Cache.Cache): <R, E, A>(self: Query<R, E, A>) => Effect.Effect<R, E, A>;
<R, E, A>(self: Query<R, E, A>, cache: Cache.Cache): Effect.Effect<R, E, A>;
(cache: Cache.Cache): <R, E, A>(self: Query<R, E, A>) => Effect.Effect<R, E, A>;
};

@@ -704,4 +704,4 @@ /**

export declare const sandboxWith: {
<R, E, A, R2, E2, A2>(f: (self: Query<R, Cause.Cause<E>, A>) => Query<R2, Cause.Cause<E2>, A2>): (self: Query<R, E, A>) => Query<R | R2, E2, A | A2>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, f: (self: Query<R, Cause.Cause<E>, A>) => Query<R2, Cause.Cause<E2>, A2>): Query<R | R2, E2, A | A2>;
<R, E, A, R2, E2, A2>(f: (self: Query<R, Cause.Cause<E>, A>) => Query<R2, Cause.Cause<E2>, A2>): (self: Query<R, E, A>) => Query<R | R2, E2, A | A2>;
};

@@ -753,4 +753,4 @@ /**

export declare const someOrElse: {
<A, B>(def: LazyArg<B>): <R, E>(self: Query<R, E, Option.Option<A>>) => Query<R, E, A | B>;
<R, E, A, B>(self: Query<R, E, Option.Option<A>>, def: LazyArg<B>): Query<R, E, A | B>;
<A, B>(def: LazyArg<B>): <R, E>(self: Query<R, E, Option.Option<A>>) => Query<R, E, A | B>;
};

@@ -764,4 +764,4 @@ /**

export declare const someOrElseEffect: {
<R2, E2, A2>(def: LazyArg<Query<R2, E2, A2>>): <R, E, A>(self: Query<R, E, Option.Option<A>>) => Query<R2 | R, E2 | E, A2 | A>;
<R, E, A, R2, E2, A2>(self: Query<R, E, Option.Option<A>>, def: LazyArg<Query<R2, E2, A2>>): Query<R | R2, E | E2, A | A2>;
<R2, E2, A2>(def: LazyArg<Query<R2, E2, A2>>): <R, E, A>(self: Query<R, E, Option.Option<A>>) => Query<R2 | R, E2 | E, A2 | A>;
};

@@ -775,4 +775,4 @@ /**

export declare const someOrFail: {
<E2>(error: LazyArg<E2>): <R, E, A>(self: Query<R, E, Option.Option<A>>) => Query<R, E2 | E, A>;
<R, E, A, E2>(self: Query<R, E, Option.Option<A>>, error: LazyArg<E2>): Query<R, E | E2, A>;
<E2>(error: LazyArg<E2>): <R, E, A>(self: Query<R, E, Option.Option<A>>) => Query<R, E2 | E, A>;
};

@@ -809,4 +809,4 @@ /**

export declare const summarized: {
<R2, E2, B, C>(summary: Effect.Effect<R2, E2, B>, f: (start: B, end: B) => C): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [C, A]>;
<R, E, A, R2, E2, B, C>(self: Query<R, E, A>, summary: Effect.Effect<R2, E2, B>, f: (start: B, end: B) => C): Query<R | R2, E | E2, readonly [C, A]>;
<R2, E2, B, C>(summary: Effect.Effect<R2, E2, B>, f: (start: B, end: B) => C): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [C, A]>;
};

@@ -842,4 +842,4 @@ /**

export declare const timeout: {
(duration: Duration.Duration): <R, E, A>(self: Query<R, E, A>) => Query<R, E, Option.Option<A>>;
<R, E, A>(self: Query<R, E, A>, duration: Duration.Duration): Query<R, E, Option.Option<A>>;
(duration: Duration.Duration): <R, E, A>(self: Query<R, E, A>) => Query<R, E, Option.Option<A>>;
};

@@ -854,4 +854,4 @@ /**

export declare const timeoutFail: {
<E2>(error: LazyArg<E2>, duration: Duration.Duration): <R, E, A>(self: Query<R, E, A>) => Query<R, E2 | E, A>;
<R, E, A, E2>(self: Query<R, E, A>, error: LazyArg<E2>, duration: Duration.Duration): Query<R, E | E2, A>;
<E2>(error: LazyArg<E2>, duration: Duration.Duration): <R, E, A>(self: Query<R, E, A>) => Query<R, E2 | E, A>;
};

@@ -866,4 +866,4 @@ /**

export declare const timeoutFailCause: {
<E2>(evaluate: LazyArg<Cause.Cause<E2>>, duration: Duration.Duration): <R, E, A>(self: Query<R, E, A>) => Query<R, E2 | E, A>;
<R, E, A, E2>(self: Query<R, E, A>, evaluate: LazyArg<Cause.Cause<E2>>, duration: Duration.Duration): Query<R, E | E2, A>;
<E2>(evaluate: LazyArg<Cause.Cause<E2>>, duration: Duration.Duration): <R, E, A>(self: Query<R, E, A>) => Query<R, E2 | E, A>;
};

@@ -879,4 +879,4 @@ /**

export declare const timeoutTo: {
<B2, A, B>(def: B2, f: (a: A) => B, duration: Duration.Duration): <R, E>(self: Query<R, E, A>) => Query<R, E, B2 | B>;
<R, E, A, B2, B>(self: Query<R, E, A>, def: B2, f: (a: A) => B, duration: Duration.Duration): Query<R, E, B2 | B>;
<B2, A, B>(def: B2, f: (a: A) => B, duration: Duration.Duration): <R, E>(self: Query<R, E, A>) => Query<R, E, B2 | B>;
};

@@ -920,4 +920,4 @@ /**

export declare const unrefine: {
<E, E2>(pf: (defect: unknown) => Option.Option<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E | E2, A>;
<R, E, A, E2>(self: Query<R, E, A>, pf: (defect: unknown) => Option.Option<E2>): Query<R, E | E2, A>;
<E, E2>(pf: (defect: unknown) => Option.Option<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E | E2, A>;
};

@@ -932,4 +932,4 @@ /**

export declare const unrefineWith: {
<E, E2, E3>(pf: (defect: unknown) => Option.Option<E2>, f: (error: E) => E3): <R, A>(self: Query<R, E, A>) => Query<R, E2 | E3, A>;
<R, E, A, E2, E3>(self: Query<R, E, A>, pf: (defect: unknown) => Option.Option<E2>, f: (error: E) => E3): Query<R, E2 | E3, A>;
<E, E2, E3>(pf: (defect: unknown) => Option.Option<E2>, f: (error: E) => E3): <R, A>(self: Query<R, E, A>) => Query<R, E2 | E3, A>;
};

@@ -967,4 +967,4 @@ /**

export declare const zip: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, readonly [A, A2]>;
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>;
};

@@ -980,4 +980,4 @@ /**

export declare const zipBatched: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, readonly [A, A2]>;
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>;
};

@@ -993,4 +993,4 @@ /**

export declare const zipBatchedLeft: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A>;
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>;
};

@@ -1006,4 +1006,4 @@ /**

export declare const zipBatchedRight: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A2>;
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
};

@@ -1018,4 +1018,4 @@ /**

export declare const zipLeft: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A>;
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>;
};

@@ -1030,4 +1030,4 @@ /**

export declare const zipRight: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A2>;
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
};

@@ -1042,4 +1042,4 @@ /**

export declare const zipPar: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, readonly [A, A2]>;
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>;
};

@@ -1054,4 +1054,4 @@ /**

export declare const zipParLeft: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A>;
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>;
};

@@ -1066,4 +1066,4 @@ /**

export declare const zipParRight: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A2>;
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>;
};

@@ -1080,4 +1080,4 @@ /**

export declare const zipWith: {
<R2, E2, B, A, C>(that: Query<R2, E2, B>, f: (a: A, b: B) => C): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, C>;
<R, E, A, R2, E2, B, C>(self: Query<R, E, A>, that: Query<R2, E2, B>, f: (a: A, b: B) => C): Query<R | R2, E | E2, C>;
<R2, E2, B, A, C>(that: Query<R2, E2, B>, f: (a: A, b: B) => C): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, C>;
};

@@ -1092,4 +1092,4 @@ /**

export declare const zipWithBatched: {
<A, R2, E2, B, C>(that: Query<R2, E2, B>, f: (a: A, b: B) => C): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, C>;
<R, E, A, R2, E2, B, C>(self: Query<R, E, A>, that: Query<R2, E2, B>, f: (a: A, b: B) => C): Query<R | R2, E | E2, C>;
<A, R2, E2, B, C>(that: Query<R2, E2, B>, f: (a: A, b: B) => C): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, C>;
};

@@ -1106,5 +1106,5 @@ /**

export declare const zipWithPar: {
<A, R2, E2, B, C>(that: Query<R2, E2, B>, f: (a: A, b: B) => C): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, C>;
<R, E, A, R2, E2, B, C>(self: Query<R, E, A>, that: Query<R2, E2, B>, f: (a: A, b: B) => C): Query<R | R2, E | E2, C>;
<A, R2, E2, B, C>(that: Query<R2, E2, B>, f: (a: A, b: B) => C): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, C>;
};
//# sourceMappingURL=Query.d.ts.map

10

Request.d.ts
/**
* @since 1.0.0
*/
import type * as Data from "@effect/data/Data";
import type * as Effect from "@effect/io/Effect";

@@ -8,3 +9,2 @@ import type * as CompletedRequestMap from "@effect/query/CompletedRequestMap";

import type * as Option from "@fp-ts/core/Option";
import type * as Data from "@effect/data/Data";
/**

@@ -109,4 +109,4 @@ * @since 1.0.0

export declare const complete: {
<A extends Request<any, any>>(result: Request.Result<A>): (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>;
<A extends Request<any, any>>(self: A, result: Request.Result<A>): Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>;
<A extends Request<any, any>>(result: Request.Result<A>): (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>;
};

@@ -122,4 +122,4 @@ /**

export declare const completeEffect: {
<A extends Request<any, any>, R>(effect: Effect.Effect<R, Request.Error<A>, Request.Success<A>>): (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap | R, never, void>;
<A extends Request<any, any>, R>(self: A, effect: Effect.Effect<R, Request.Error<A>, Request.Success<A>>): Effect.Effect<CompletedRequestMap.CompletedRequestMap | R, never, void>;
<A extends Request<any, any>, R>(effect: Effect.Effect<R, Request.Error<A>, Request.Success<A>>): (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap | R, never, void>;
};

@@ -133,4 +133,4 @@ /**

export declare const fail: {
<A extends Request<any, any>>(error: Request.Error<A>): (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>;
<A extends Request<any, any>>(self: A, error: Request.Error<A>): Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>;
<A extends Request<any, any>>(error: Request.Error<A>): (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>;
};

@@ -144,5 +144,5 @@ /**

export declare const succeed: {
<A extends Request<any, any>>(value: Request.Success<A>): (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>;
<A extends Request<any, any>>(self: A, value: Request.Success<A>): Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>;
<A extends Request<any, any>>(value: Request.Success<A>): (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>;
};
//# sourceMappingURL=Request.d.ts.map

26

src/Cache.ts

@@ -106,10 +106,8 @@ /**

<E, A>(
request: Request.Request<E, A>
): (self: Cache) => Effect.Effect<never, void, Ref.Ref<Option.Option<Either.Either<E, A>>>>
<E, A>(
self: Cache,
request: Request.Request<E, A>
): Effect.Effect<never, void, Ref.Ref<Option.Option<Either.Either<E, A>>>>
<E, A>(
request: Request.Request<E, A>
): (
self: Cache
) => Effect.Effect<never, void, Ref.Ref<Option.Option<Either.Either<E, A>>>>
} = internal.get

@@ -129,5 +127,6 @@

<E, A>(
self: Cache,
request: Request.Request<E, A>
): Effect.Effect<
): (
self: Cache
) => Effect.Effect<
never,

@@ -138,6 +137,5 @@ never,

<E, A>(
self: Cache,
request: Request.Request<E, A>
): (
self: Cache
) => Effect.Effect<
): Effect.Effect<
never,

@@ -158,10 +156,10 @@ never,

<E, A>(
self: Cache,
request: Request.Request<E, A>,
result: Ref.Ref<Option.Option<Either.Either<E, A>>>
): Effect.Effect<never, never, void>
): (self: Cache) => Effect.Effect<never, never, void>
<E, A>(
self: Cache,
request: Request.Request<E, A>,
result: Ref.Ref<Option.Option<Either.Either<E, A>>>
): (self: Cache) => Effect.Effect<never, never, void>
): Effect.Effect<never, never, void>
} = internal.set

@@ -176,4 +174,4 @@

export const remove: {
<E, A>(request: Request.Request<E, A>): (self: Cache) => Effect.Effect<never, never, void>
<E, A>(self: Cache, request: Request.Request<E, A>): Effect.Effect<never, never, void>
<E, A>(request: Request.Request<E, A>): (self: Cache) => Effect.Effect<never, never, void>
} = internal.remove

33

src/CompletedRequestMap.ts
/**
* @since 1.0.0
*/
import type * as Context from "@effect/data/Context"
import type * as HashMap from "@effect/data/HashMap"
import type * as HashSet from "@effect/data/HashSet"
import type * as MutableRef from "@effect/data/MutableRef"
import * as internal from "@effect/query/internal_effect_untraced/completedRequestMap"

@@ -8,6 +12,2 @@ import type * as Request from "@effect/query/Request"

import type * as Option from "@fp-ts/core/Option"
import type * as Context from "@effect/data/Context"
import type * as HashMap from "@effect/data/HashMap"
import type * as HashSet from "@effect/data/HashSet"
import type * as MutableRef from "@effect/data/MutableRef"

@@ -94,4 +94,4 @@ /**

export const combine: {
(that: CompletedRequestMap): (self: CompletedRequestMap) => CompletedRequestMap
(self: CompletedRequestMap, that: CompletedRequestMap): CompletedRequestMap
(that: CompletedRequestMap): (self: CompletedRequestMap) => CompletedRequestMap
} = internal.combine

@@ -107,10 +107,5 @@

<A extends Request.Request<any, any>>(
self: CompletedRequestMap,
request: A
): Option.Option<Request.Request.Result<A>>
<A extends Request.Request<any, any>>(
request: A
): (
self: CompletedRequestMap
) => Option.Option<Request.Request.Result<A>>
): (self: CompletedRequestMap) => Option.Option<Request.Request.Result<A>>
<A extends Request.Request<any, any>>(self: CompletedRequestMap, request: A): Option.Option<Request.Request.Result<A>>
} = internal.get

@@ -125,4 +120,4 @@

export const has: {
<A extends Request.Request<any, any>>(request: A): (self: CompletedRequestMap) => boolean
<A extends Request.Request<any, any>>(self: CompletedRequestMap, request: A): boolean
<A extends Request.Request<any, any>>(request: A): (self: CompletedRequestMap) => boolean
} = internal.has

@@ -147,10 +142,6 @@

<A extends Request.Request<any, any>>(
self: CompletedRequestMap,
request: A,
result: Request.Request.Result<A>
): void
<A extends Request.Request<any, any>>(
request: A,
result: Request.Request.Result<A>
): (self: CompletedRequestMap) => void
<A extends Request.Request<any, any>>(self: CompletedRequestMap, request: A, result: Request.Request.Result<A>): void
} = internal.set

@@ -166,10 +157,10 @@

<A extends Request.Request<any, any>>(
self: CompletedRequestMap,
request: A,
result: Request.Request.OptionalResult<A>
): void
): (self: CompletedRequestMap) => void
<A extends Request.Request<any, any>>(
self: CompletedRequestMap,
request: A,
result: Request.Request.OptionalResult<A>
): (self: CompletedRequestMap) => void
): void
} = internal.setOption

65

src/DataSource.ts

@@ -5,2 +5,5 @@ /**

import type * as Chunk from "@effect/data/Chunk"
import type * as Context from "@effect/data/Context"
import type * as Equal from "@effect/data/Equal"
import type * as Effect from "@effect/io/Effect"

@@ -13,5 +16,2 @@ import type * as CompletedRequestMap from "@effect/query/CompletedRequestMap"

import type * as Option from "@fp-ts/core/Option"
import type * as Chunk from "@effect/data/Chunk"
import type * as Context from "@effect/data/Context"
import type * as Equal from "@effect/data/Equal"

@@ -123,3 +123,7 @@ /**

export const around: {
<R, A extends Request.Request<any, any>, R2, A2, R3, _>(
<R2, A2, R3, _>(
before: Described.Described<Effect.Effect<R2, never, A2>>,
after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>
): <R, A>(self: DataSource<R, A>) => DataSource<R2 | R3 | R, A>
<R, A, R2, A2, R3, _>(
self: DataSource<R, A>,

@@ -129,6 +133,2 @@ before: Described.Described<Effect.Effect<R2, never, A2>>,

): DataSource<R | R2 | R3, A>
<R2, A2, R3, _>(
before: Described.Described<Effect.Effect<R2, never, A2>>,
after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>
): <R, A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<R2 | R3 | R, A>
} = internal.around

@@ -143,4 +143,4 @@

export const batchN: {
<R, A extends Request.Request<any, any>>(self: DataSource<R, A>, n: number): DataSource<R, A>
(n: number): <R, A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<R, A>
(n: number): <R, A>(self: DataSource<R, A>) => DataSource<R, A>
<R, A>(self: DataSource<R, A>, n: number): DataSource<R, A>
} = internal.batchN

@@ -157,2 +157,5 @@

export const contramap: {
<A extends Request.Request<any, any>, B extends Request.Request<any, any>>(
f: Described.Described<(_: B) => A>
): <R>(self: DataSource<R, A>) => DataSource<R, B>
<R, A extends Request.Request<any, any>, B extends Request.Request<any, any>>(

@@ -162,5 +165,2 @@ self: DataSource<R, A>,

): DataSource<R, B>
<A extends Request.Request<any, any>, B extends Request.Request<any, any>>(
f: Described.Described<(_: B) => A>
): <R>(self: DataSource<R, A>) => DataSource<R, B>
} = internal.contramap

@@ -175,2 +175,5 @@

export const contramapContext: {
<R0, R>(
f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>
): <A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<R0, A>
<R, A extends Request.Request<any, any>, R0>(

@@ -180,7 +183,2 @@ self: DataSource<R, A>,

): DataSource<R0, A>
<R0, R>(
f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>
): <A extends Request.Request<any, any>>(
self: DataSource<R, A>
) => DataSource<R0, A>
} = internal.contramapContext

@@ -197,2 +195,5 @@

export const contramapEffect: {
<A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>>(
f: Described.Described<(_: B) => Effect.Effect<R2, never, A>>
): <R>(self: DataSource<R, A>) => DataSource<R2 | R, B>
<R, A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>>(

@@ -202,5 +203,2 @@ self: DataSource<R, A>,

): DataSource<R | R2, B>
<A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>>(
f: Described.Described<(_: B) => Effect.Effect<R2, never, A>>
): <R>(self: DataSource<R, A>) => DataSource<R2 | R, B>
} = internal.contramapEffect

@@ -217,2 +215,6 @@

export const eitherWith: {
<A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>, C extends Request.Request<any, any>>(
that: DataSource<R2, B>,
f: Described.Described<(_: C) => Either.Either<A, B>>
): <R>(self: DataSource<R, A>) => DataSource<R2 | R, C>
<

@@ -229,11 +231,2 @@ R,

): DataSource<R | R2, C>
<
A extends Request.Request<any, any>,
R2,
B extends Request.Request<any, any>,
C extends Request.Request<any, any>
>(
that: DataSource<R2, B>,
f: Described.Described<(_: C) => Either.Either<A, B>>
): <R>(self: DataSource<R, A>) => DataSource<R2 | R, C>
} = internal.eitherWith

@@ -391,2 +384,5 @@

export const provideContext: {
<R>(
context: Described.Described<Context.Context<R>>
): <A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<never, A>
<R, A extends Request.Request<any, any>>(

@@ -396,5 +392,2 @@ self: DataSource<R, A>,

): DataSource<never, A>
<R>(
context: Described.Described<Context.Context<R>>
): <A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<never, A>
} = internal.provideContext

@@ -411,2 +404,5 @@

export const race: {
<R2, A2 extends Request.Request<any, any>>(
that: DataSource<R2, A2>
): <R, A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<R2 | R, A2 | A>
<R, A extends Request.Request<any, any>, R2, A2 extends Request.Request<any, any>>(

@@ -416,5 +412,2 @@ self: DataSource<R, A>,

): DataSource<R | R2, A | A2>
<R2, A2 extends Request.Request<any, any>>(
that: DataSource<R2, A2>
): <R, A extends Request.Request<any, any>>(self: DataSource<R, A>) => DataSource<R2 | R, A2 | A>
} = internal.race

24

src/internal_effect_untraced/cache.ts

@@ -95,9 +95,9 @@ import * as HashMap from "@effect/data/HashMap"

<E, A>(
self: Cache.Cache,
request: Request.Request<E, A>
) => (
self: Cache.Cache
) => Effect.Effect<never, void, Ref.Ref<Option.Option<Either.Either<E, A>>>>,
<E, A>(
self: Cache.Cache,
request: Request.Request<E, A>
) => (
self: Cache.Cache
) => Effect.Effect<never, void, Ref.Ref<Option.Option<Either.Either<E, A>>>>

@@ -109,4 +109,5 @@ >(2, (trace) => (self, request) => self.get(request).traced(trace))

<E, A>(
self: Cache.Cache,
request: Request.Request<E, A>
) => (
self: Cache.Cache
) => Effect.Effect<

@@ -121,5 +122,4 @@ never,

<E, A>(
self: Cache.Cache,
request: Request.Request<E, A>
) => (
self: Cache.Cache
) => Effect.Effect<

@@ -138,11 +138,11 @@ never,

<E, A>(
self: Cache.Cache,
request: Request.Request<E, A>,
result: Ref.Ref<Option.Option<Either.Either<E, A>>>
) => (
self: Cache.Cache
) => Effect.Effect<never, never, void>,
<E, A>(
self: Cache.Cache,
request: Request.Request<E, A>,
result: Ref.Ref<Option.Option<Either.Either<E, A>>>
) => (
self: Cache.Cache
) => Effect.Effect<never, never, void>

@@ -154,10 +154,10 @@ >(3, (trace) => (self, request, result) => self.set(request, result).traced(trace))

<E, A>(
self: Cache.Cache,
request: Request.Request<E, A>
) => (
self: Cache.Cache
) => Effect.Effect<never, never, void>,
<E, A>(
self: Cache.Cache,
request: Request.Request<E, A>
) => (
self: Cache.Cache
) => Effect.Effect<never, never, void>
>(2, (trace) => (self, request) => self.remove(request).traced(trace))

53

src/internal_effect_untraced/completedRequestMap.ts

@@ -5,7 +5,6 @@ import * as Context from "@effect/data/Context"

import * as MutableRef from "@effect/data/MutableRef"
import * as Debug from "@effect/io/Debug"
import type * as CompletedRequestMap from "@effect/query/CompletedRequestMap"
import type * as Request from "@effect/query/Request"
import * as Either from "@fp-ts/core/Either"
import { pipe } from "@fp-ts/core/Function"
import { dual } from "@fp-ts/core/Function"
import * as Option from "@fp-ts/core/Option"

@@ -49,11 +48,11 @@

/** @internal */
export const combine = Debug.dual<
export const combine = dual<
(
self: CompletedRequestMap.CompletedRequestMap,
that: CompletedRequestMap.CompletedRequestMap
) => (
self: CompletedRequestMap.CompletedRequestMap
) => CompletedRequestMap.CompletedRequestMap,
(
self: CompletedRequestMap.CompletedRequestMap,
that: CompletedRequestMap.CompletedRequestMap
) => (
self: CompletedRequestMap.CompletedRequestMap
) => CompletedRequestMap.CompletedRequestMap

@@ -67,11 +66,11 @@ >(2, (self, that) => {

/** @internal */
export const get = Debug.dual<
export const get = dual<
<A extends Request.Request<any, any>>(
self: CompletedRequestMap.CompletedRequestMap,
request: A
) => (
self: CompletedRequestMap.CompletedRequestMap
) => Option.Option<Request.Request.Result<A>>,
<A extends Request.Request<any, any>>(
self: CompletedRequestMap.CompletedRequestMap,
request: A
) => (
self: CompletedRequestMap.CompletedRequestMap
) => Option.Option<Request.Request.Result<A>>

@@ -84,5 +83,5 @@ >(2, <A extends Request.Request<any, any>>(

/** @internal */
export const has = Debug.dual<
<A extends Request.Request<any, any>>(self: CompletedRequestMap.CompletedRequestMap, request: A) => boolean,
<A extends Request.Request<any, any>>(request: A) => (self: CompletedRequestMap.CompletedRequestMap) => boolean
export const has = dual<
<A extends Request.Request<any, any>>(request: A) => (self: CompletedRequestMap.CompletedRequestMap) => boolean,
<A extends Request.Request<any, any>>(self: CompletedRequestMap.CompletedRequestMap, request: A) => boolean
>(2, (self, request) => HashMap.has(MutableRef.get(self.map), request))

@@ -96,12 +95,12 @@

/** @internal */
export const set = Debug.dual<
export const set = dual<
<A extends Request.Request<any, any>>(
self: CompletedRequestMap.CompletedRequestMap,
request: A,
result: Request.Request.Result<A>
) => void,
) => (self: CompletedRequestMap.CompletedRequestMap) => void,
<A extends Request.Request<any, any>>(
self: CompletedRequestMap.CompletedRequestMap,
request: A,
result: Request.Request.Result<A>
) => (self: CompletedRequestMap.CompletedRequestMap) => void
) => void
>(

@@ -123,23 +122,21 @@ 3,

/** @internal */
export const setOption = Debug.dual<
export const setOption = dual<
<A extends Request.Request<any, any>>(
self: CompletedRequestMap.CompletedRequestMap,
request: A,
result: Request.Request.OptionalResult<A>
) => void,
) => (self: CompletedRequestMap.CompletedRequestMap) => void,
<A extends Request.Request<any, any>>(
self: CompletedRequestMap.CompletedRequestMap,
request: A,
result: Request.Request.OptionalResult<A>
) => (self: CompletedRequestMap.CompletedRequestMap) => void
) => void
>(3, (self, request, result) => {
pipe(
Either.match(
result,
Either.match(
(e) => set(self, request, Either.left(e) as any),
Option.match(
() => self,
(a) => set(self, request, Either.right(a) as any)
)
(e) => set(self, request, Either.left(e) as any),
Option.match(
() => self,
(a) => set(self, request, Either.right(a) as any)
)
)
})

62

src/internal_effect_untraced/dataSource.ts

@@ -89,12 +89,12 @@ import * as Chunk from "@effect/data/Chunk"

export const around = Debug.untracedDual<
<R, A, R2, A2, R3, _>(
self: DataSource.DataSource<R, A>,
<R2, A2, R3, _>(
before: Described.Described<Effect.Effect<R2, never, A2>>,
after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>
) => <R, A>(
self: DataSource.DataSource<R, A>
) => DataSource.DataSource<R | R2 | R3, A>,
<R2, A2, R3, _>(
<R, A, R2, A2, R3, _>(
self: DataSource.DataSource<R, A>,
before: Described.Described<Effect.Effect<R2, never, A2>>,
after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>
) => <R, A>(
self: DataSource.DataSource<R, A>
) => DataSource.DataSource<R | R2 | R3, A>

@@ -115,4 +115,4 @@ >(3, (restore) =>

export const batchN = Debug.untracedDual<
<R, A>(self: DataSource.DataSource<R, A>, n: number) => DataSource.DataSource<R, A>,
(n: number) => <R, A>(self: DataSource.DataSource<R, A>) => DataSource.DataSource<R, A>
(n: number) => <R, A>(self: DataSource.DataSource<R, A>) => DataSource.DataSource<R, A>,
<R, A>(self: DataSource.DataSource<R, A>, n: number) => DataSource.DataSource<R, A>
>(2, (restore) =>

@@ -136,9 +136,9 @@ (self, n) =>

export const contramap = Debug.untracedDual<
<A extends Request.Request<any, any>, B extends Request.Request<any, any>>(
f: Described.Described<(_: B) => A>
) => <R>(self: DataSource.DataSource<R, A>) => DataSource.DataSource<R, B>,
<R, A extends Request.Request<any, any>, B extends Request.Request<any, any>>(
self: DataSource.DataSource<R, A>,
f: Described.Described<(_: B) => A>
) => DataSource.DataSource<R, B>,
<A extends Request.Request<any, any>, B extends Request.Request<any, any>>(
f: Described.Described<(_: B) => A>
) => <R>(self: DataSource.DataSource<R, A>) => DataSource.DataSource<R, B>
) => DataSource.DataSource<R, B>
>(2, (restore) =>

@@ -153,9 +153,9 @@ (self, f) =>

export const contramapContext = Debug.untracedDual<
<R0, R>(
f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>
) => <A extends Request.Request<any, any>>(self: DataSource.DataSource<R, A>) => DataSource.DataSource<R0, A>,
<R, A extends Request.Request<any, any>, R0>(
self: DataSource.DataSource<R, A>,
f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>
) => DataSource.DataSource<R0, A>,
<R0, R>(
f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>
) => <A extends Request.Request<any, any>>(self: DataSource.DataSource<R, A>) => DataSource.DataSource<R0, A>
) => DataSource.DataSource<R0, A>
>(2, (restore) =>

@@ -177,9 +177,9 @@ <R, A extends Request.Request<any, any>, R0>(

export const contramapEffect = Debug.untracedDual<
<A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>>(
f: Described.Described<(_: B) => Effect.Effect<R2, never, A>>
) => <R>(self: DataSource.DataSource<R, A>) => DataSource.DataSource<R | R2, B>,
<R, A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>>(
self: DataSource.DataSource<R, A>,
f: Described.Described<(_: B) => Effect.Effect<R2, never, A>>
) => DataSource.DataSource<R | R2, B>,
<A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>>(
f: Described.Described<(_: B) => Effect.Effect<R2, never, A>>
) => <R>(self: DataSource.DataSource<R, A>) => DataSource.DataSource<R | R2, B>
) => DataSource.DataSource<R | R2, B>
>(2, (restore) =>

@@ -199,3 +199,2 @@ (self, f) =>

<
R,
A extends Request.Request<any, any>,

@@ -206,7 +205,7 @@ R2,

>(
self: DataSource.DataSource<R, A>,
that: DataSource.DataSource<R2, B>,
f: Described.Described<(_: C) => Either.Either<A, B>>
) => DataSource.DataSource<R | R2, C>,
) => <R>(self: DataSource.DataSource<R, A>) => DataSource.DataSource<R | R2, C>,
<
R,
A extends Request.Request<any, any>,

@@ -217,5 +216,6 @@ R2,

>(
self: DataSource.DataSource<R, A>,
that: DataSource.DataSource<R2, B>,
f: Described.Described<(_: C) => Either.Either<A, B>>
) => <R>(self: DataSource.DataSource<R, A>) => DataSource.DataSource<R | R2, C>
) => DataSource.DataSource<R | R2, C>
>(

@@ -443,6 +443,2 @@ 3,

export const provideContext = Debug.untracedDual<
<R, A extends Request.Request<any, any>>(
self: DataSource.DataSource<R, A>,
context: Described.Described<Context.Context<R>>
) => DataSource.DataSource<never, A>,
<R>(

@@ -452,2 +448,6 @@ context: Described.Described<Context.Context<R>>

self: DataSource.DataSource<R, A>
) => DataSource.DataSource<never, A>,
<R, A extends Request.Request<any, any>>(
self: DataSource.DataSource<R, A>,
context: Described.Described<Context.Context<R>>
) => DataSource.DataSource<never, A>

@@ -463,6 +463,2 @@ >(2, () =>

export const race = Debug.untracedDual<
<R, A extends Request.Request<any, any>, R2, A2 extends Request.Request<any, any>>(
self: DataSource.DataSource<R, A>,
that: DataSource.DataSource<R2, A2>
) => DataSource.DataSource<R | R2, A | A2>,
<R2, A2 extends Request.Request<any, any>>(

@@ -472,2 +468,6 @@ that: DataSource.DataSource<R2, A2>

self: DataSource.DataSource<R, A>
) => DataSource.DataSource<R | R2, A | A2>,
<R, A extends Request.Request<any, any>, R2, A2 extends Request.Request<any, any>>(
self: DataSource.DataSource<R, A>,
that: DataSource.DataSource<R2, A2>
) => DataSource.DataSource<R | R2, A | A2>

@@ -474,0 +474,0 @@ >(

74

src/internal_effect_untraced/request.ts

@@ -49,58 +49,62 @@ import * as Data from "@effect/data/Data"

/** @internal */
export const complete = Debug.dual<
export const complete = Debug.dualWithTrace<
<A extends Request.Request<any, any>>(
self: A,
result: Request.Request.Result<A>
) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>,
) => (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>,
<A extends Request.Request<any, any>>(
self: A,
result: Request.Request.Result<A>
) => (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
>(2, (self, result) =>
Effect.serviceWith(
completedRequestMap.Tag,
(map) => completedRequestMap.set(map, self, result)
))
) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
>(2, (trace) =>
(self, result) =>
Effect.serviceWith(
completedRequestMap.Tag,
(map) => completedRequestMap.set(map, self, result)
).traced(trace))
/** @internal */
export const completeEffect = Debug.dual<
export const completeEffect = Debug.dualWithTrace<
<A extends Request.Request<any, any>, R>(
self: A,
effect: Effect.Effect<R, Request.Request.Error<A>, Request.Request.Success<A>>
) => Effect.Effect<R | CompletedRequestMap.CompletedRequestMap, never, void>,
) => (self: A) => Effect.Effect<R | CompletedRequestMap.CompletedRequestMap, never, void>,
<A extends Request.Request<any, any>, R>(
self: A,
effect: Effect.Effect<R, Request.Request.Error<A>, Request.Request.Success<A>>
) => (self: A) => Effect.Effect<R | CompletedRequestMap.CompletedRequestMap, never, void>
>(2, (self, effect) =>
Effect.matchEffect(
effect,
// @ts-expect-error
(error) => complete(self, Either.left(error)),
// @ts-expect-error
(value) => complete(self, Either.right(value))
))
) => Effect.Effect<R | CompletedRequestMap.CompletedRequestMap, never, void>
>(2, (trace) =>
(self, effect) =>
Effect.matchEffect(
effect,
// @ts-expect-error
(error) => complete(self, Either.left(error)),
// @ts-expect-error
(value) => complete(self, Either.right(value))
).traced(trace))
/** @internal */
export const fail = Debug.dual<
export const fail = Debug.dualWithTrace<
<A extends Request.Request<any, any>>(
self: A,
error: Request.Request.Error<A>
) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>,
) => (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>,
<A extends Request.Request<any, any>>(
self: A,
error: Request.Request.Error<A>
) => (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
>(2, (self, error) =>
// @ts-expect-error
complete(self, Either.left(error)))
) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
>(2, (trace) =>
(self, error) =>
// @ts-expect-error
complete(self, Either.left(error)).traced(trace))
/** @internal */
export const succeed = Debug.dual<
export const succeed = Debug.dualWithTrace<
<A extends Request.Request<any, any>>(
self: A,
value: Request.Request.Success<A>
) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>,
) => (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>,
<A extends Request.Request<any, any>>(
self: A,
value: Request.Request.Success<A>
) => (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
>(2, (self, value) =>
// @ts-expect-error
complete(self, Either.right(value)))
) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
>(2, (trace) =>
(self, value) =>
// @ts-expect-error
complete(self, Either.right(value)).traced(trace))

204

src/Query.ts
/**
* @since 1.0.0
*/
import type * as Chunk from "@effect/data/Chunk"
import type * as Context from "@effect/data/Context"
import type * as Duration from "@effect/data/Duration"
import type * as Cause from "@effect/io/Cause"

@@ -17,5 +20,2 @@ import type * as Debug from "@effect/io/Debug"

import type * as Option from "@fp-ts/core/Option"
import type * as Chunk from "@effect/data/Chunk"
import type * as Context from "@effect/data/Context"
import type * as Duration from "@effect/data/Duration"

@@ -118,2 +118,6 @@ /**

export const around: {
<R2, A2, R3, _>(
before: Described.Described<Effect.Effect<R2, never, A2>>,
after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>
): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R3 | R, E, A>
<R, E, A, R2, A2, R3, _>(

@@ -124,6 +128,2 @@ self: Query<R, E, A>,

): Query<R | R2 | R3, E, A>
<R2, A2, R3, _>(
before: Described.Described<Effect.Effect<R2, never, A2>>,
after: Described.Described<(a: A2) => Effect.Effect<R3, never, _>>
): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R3 | R, E, A>
} = internal.around

@@ -138,4 +138,4 @@

export const as: {
<A2>(value: A2): <R, E, A>(self: Query<R, E, A>) => Query<R, E, A2>
<R, E, A, A2>(self: Query<R, E, A>, value: A2): Query<R, E, A2>
<A2>(value: A2): <R, E, A>(self: Query<R, E, A>) => Query<R, E, A2>
} = internal.as

@@ -177,4 +177,4 @@

export const catchAll: {
<E, R2, E2, A2>(f: (error: E) => Query<R2, E2, A2>): <R, A>(self: Query<R, E, A>) => Query<R2 | R, E2, A2 | A>
<R, A, E, R2, E2, A2>(self: Query<R, E, A>, f: (error: E) => Query<R2, E2, A2>): Query<R | R2, E2, A | A2>
<E, R2, E2, A2>(f: (error: E) => Query<R2, E2, A2>): <R, A>(self: Query<R, E, A>) => Query<R2 | R, E2, A2 | A>
} = internal.catchAll

@@ -190,2 +190,5 @@

export const catchAllCause: {
<E, R2, E2, A2>(
f: (cause: Cause.Cause<E>) => Query<R2, E2, A2>
): <R, A>(self: Query<R, E, A>) => Query<R2 | R, E2, A2 | A>
<R, E, A, R2, E2, A2>(

@@ -195,5 +198,2 @@ self: Query<R, E, A>,

): Query<R | R2, E2, A | A2>
<E, R2, E2, A2>(
f: (cause: Cause.Cause<E>) => Query<R2, E2, A2>
): <R, A>(self: Query<R, E, A>) => Query<R2 | R, E2, A2 | A>
} = internal.catchAllCause

@@ -275,2 +275,5 @@

export const contramapContext: {
<R0, R>(
f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>
): <E, A>(self: Query<R, E, A>) => Query<R0, E, A>
<R, E, A, R0>(

@@ -280,5 +283,2 @@ self: Query<R, E, A>,

): Query<R0, E, A>
<R0, R>(
f: Described.Described<(context: Context.Context<R0>) => Context.Context<R>>
): <E, A>(self: Query<R, E, A>) => Query<R0, E, A>
} = internal.contramapContext

@@ -321,4 +321,4 @@

export const ensuring: {
<R2, E2, A2>(finalizer: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, finalizer: Query<R2, E2, A2>): Query<R | R2, E | E2, A>
<R2, E2, A2>(finalizer: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>
} = internal.ensuring

@@ -369,4 +369,4 @@

export const flatMap: {
<A, R2, E2, A2>(f: (a: A) => Query<R2, E2, A2>): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, f: (a: A) => Query<R2, E2, A2>): Query<R | R2, E | E2, A2>
<A, R2, E2, A2>(f: (a: A) => Query<R2, E2, A2>): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>
} = internal.flatMap

@@ -395,4 +395,4 @@

export const forEach: {
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>
<A, R, E, B>(elements: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, E, Chunk.Chunk<B>>
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>
} = internal.forEach

@@ -409,4 +409,4 @@

export const forEachBatched: {
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>
<A, R, E, B>(elements: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, E, Chunk.Chunk<B>>
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>
} = internal.forEachBatched

@@ -423,4 +423,4 @@

export const forEachPar: {
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>
<A, R, E, B>(elements: Iterable<A>, f: (a: A) => Query<R, E, B>): Query<R, E, Chunk.Chunk<B>>
<A, R, E, B>(f: (a: A) => Query<R, E, B>): (elements: Iterable<A>) => Query<R, E, Chunk.Chunk<B>>
} = internal.forEachPar

@@ -495,4 +495,4 @@

export const map: {
<A, B>(f: (a: A) => B): <R, E>(self: Query<R, E, A>) => Query<R, E, B>
<R, E, A, B>(self: Query<R, E, A>, f: (a: A) => B): Query<R, E, B>
<A, B>(f: (a: A) => B): <R, E>(self: Query<R, E, A>) => Query<R, E, B>
} = internal.map

@@ -508,4 +508,4 @@

export const mapBoth: {
<E, E2, A, A2>(f: (e: E) => E2, g: (a: A) => A2): <R>(self: Query<R, E, A>) => Query<R, E2, A2>
<R, E, E2, A, A2>(self: Query<R, E, A>, f: (e: E) => E2, g: (a: A) => A2): Query<R, E2, A2>
<E, E2, A, A2>(f: (e: E) => E2, g: (a: A) => A2): <R>(self: Query<R, E, A>) => Query<R, E2, A2>
} = internal.mapBoth

@@ -520,2 +520,5 @@

export const mapDataSources: {
<R, A, R2>(
f: (dataSource: DataSource.DataSource<R, A>) => DataSource.DataSource<R2, A>
): <E>(self: Query<R, E, A>) => Query<R | R2, E, A>
<R, E, A, R2>(

@@ -525,5 +528,2 @@ self: Query<R, E, A>,

): Query<R | R2, E, A>
<R, A, R2>(
f: (dataSource: DataSource.DataSource<R, A>) => DataSource.DataSource<R2, A>
): <E>(self: Query<R, E, A>) => Query<R | R2, E, A>
} = internal.mapDataSources

@@ -538,4 +538,4 @@

export const mapError: {
<E, E2>(f: (e: E) => E2): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>
<R, A, E, E2>(self: Query<R, E, A>, f: (e: E) => E2): Query<R, E2, A>
<E, E2>(f: (e: E) => E2): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>
} = internal.mapError

@@ -552,4 +552,4 @@

export const mapErrorCause: {
<E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>
<R, E, A, E2>(self: Query<R, E, A>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Query<R, E2, A>
<E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>
} = internal.mapErrorCause

@@ -564,4 +564,4 @@

export const mapEffect: {
<A, R2, E2, A2>(f: (a: A) => Effect.Effect<R2, E2, A2>): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, f: (a: A) => Effect.Effect<R2, E2, A2>): Query<R | R2, E | E2, A2>
<A, R2, E2, A2>(f: (a: A) => Effect.Effect<R2, E2, A2>): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>
} = internal.mapEffect

@@ -578,4 +578,4 @@

export const match: {
<E, Z, A>(onFailure: (error: E) => Z, onSuccess: (value: A) => Z): <R>(self: Query<R, E, A>) => Query<R, never, Z>
<R, E, A, Z>(self: Query<R, E, A>, onFailure: (error: E) => Z, onSuccess: (value: A) => Z): Query<R, never, Z>
<E, Z, A>(onFailure: (error: E) => Z, onSuccess: (value: A) => Z): <R>(self: Query<R, E, A>) => Query<R, never, Z>
} = internal.match

@@ -591,2 +591,6 @@

export const matchCauseQuery: {
<E, R2, E2, A2, A, R3, E3, A3>(
onFailure: (cause: Cause.Cause<E>) => Query<R2, E2, A2>,
onSuccess: (value: A) => Query<R3, E3, A3>
): <R>(self: Query<R, E, A>) => Query<R2 | R3 | R, E2 | E3, A2 | A3>
<R, E, A, R2, E2, A2, R3, E3, A3>(

@@ -597,6 +601,2 @@ self: Query<R, E, A>,

): Query<R | R2 | R3, E2 | E3, A2 | A3>
<E, R2, E2, A2, A, R3, E3, A3>(
onFailure: (cause: Cause.Cause<E>) => Query<R2, E2, A2>,
onSuccess: (value: A) => Query<R3, E3, A3>
): <R>(self: Query<R, E, A>) => Query<R2 | R3 | R, E2 | E3, A2 | A3>
} = internal.matchCauseQuery

@@ -612,2 +612,6 @@

export const matchQuery: {
<E, R2, E2, A2, A, R3, E3, A3>(
onFailure: (error: E) => Query<R2, E2, A2>,
onSuccess: (value: A) => Query<R3, E3, A3>
): <R>(self: Query<R, E, A>) => Query<R2 | R3 | R, E2 | E3, A2 | A3>
<R, E, A, R2, E2, A2, R3, E3, A3>(

@@ -618,6 +622,2 @@ self: Query<R, E, A>,

): Query<R | R2 | R3, E2 | E3, A2 | A3>
<E, R2, E2, A2, A, R3, E3, A3>(
onFailure: (error: E) => Query<R2, E2, A2>,
onSuccess: (value: A) => Query<R3, E3, A3>
): <R>(self: Query<R, E, A>) => Query<R2 | R3 | R, E2 | E3, A2 | A3>
} = internal.matchQuery

@@ -632,4 +632,4 @@

export const maxBatchSize: {
(n: number): <R, E, A>(self: Query<R, E, A>) => Query<R, E, A>
<R, E, A>(self: Query<R, E, A>, n: number): Query<R, E, A>
(n: number): <R, E, A>(self: Query<R, E, A>) => Query<R, E, A>
} = internal.maxBatchSize

@@ -670,4 +670,4 @@

export const orDieWith: {
<E>(f: (error: E) => unknown): <R, A>(self: Query<R, E, A>) => Query<R, never, A>
<R, E, A>(self: Query<R, E, A>, f: (error: E) => unknown): Query<R, never, A>
<E>(f: (error: E) => unknown): <R, A>(self: Query<R, E, A>) => Query<R, never, A>
} = internal.orDieWith

@@ -685,8 +685,8 @@

<A, R, E, B>(
f: (a: A) => Query<R, E, B>
): (elements: Iterable<A>) => Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>
<A, R, E, B>(
elements: Iterable<A>,
f: (a: A) => Query<R, E, B>
): Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>
<A, R, E, B>(
f: (a: A) => Query<R, E, B>
): (elements: Iterable<A>) => Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>
} = internal.partitionQuery

@@ -704,8 +704,8 @@

<A, R, E, B>(
f: (a: A) => Query<R, E, B>
): (elements: Iterable<A>) => Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>
<A, R, E, B>(
elements: Iterable<A>,
f: (a: A) => Query<R, E, B>
): Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>
<A, R, E, B>(
f: (a: A) => Query<R, E, B>
): (elements: Iterable<A>) => Query<R, never, readonly [Chunk.Chunk<E>, Chunk.Chunk<B>]>
} = internal.partitionQueryPar

@@ -720,4 +720,4 @@

export const provideContext: {
<R>(context: Described.Described<Context.Context<R>>): <E, A>(self: Query<R, E, A>) => Query<never, E, A>
<R, E, A>(self: Query<R, E, A>, context: Described.Described<Context.Context<R>>): Query<never, E, A>
<R>(context: Described.Described<Context.Context<R>>): <E, A>(self: Query<R, E, A>) => Query<never, E, A>
} = internal.provideContext

@@ -732,4 +732,4 @@

export const provideLayer: {
<R0, E2, R>(layer: Described.Described<Layer.Layer<R0, E2, R>>): <E, A>(self: Query<R, E, A>) => Query<R0, E2 | E, A>
<R, E, A, R0, E2>(self: Query<R, E, A>, layer: Described.Described<Layer.Layer<R0, E2, R>>): Query<R0, E | E2, A>
<R0, E2, R>(layer: Described.Described<Layer.Layer<R0, E2, R>>): <E, A>(self: Query<R, E, A>) => Query<R0, E2 | E, A>
} = internal.provideLayer

@@ -745,2 +745,5 @@

export const provideSomeLayer: {
<R2, E2, A2>(
layer: Described.Described<Layer.Layer<R2, E2, A2>>
): <R, E, A>(self: Query<R, E, A>) => Query<R2 | Exclude<R, A2>, E2 | E, A>
<R, E, A, R2, E2, A2>(

@@ -750,5 +753,2 @@ self: Query<R, E, A>,

): Query<R2 | Exclude<R, A2>, E | E2, A>
<R2, E2, A2>(
layer: Described.Described<Layer.Layer<R2, E2, A2>>
): <R, E, A>(self: Query<R, E, A>) => Query<R2 | Exclude<R, A2>, E2 | E, A>
} = internal.provideSomeLayer

@@ -764,4 +764,4 @@

export const race: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2 | A>
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A | A2>
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2 | A>
} = internal.race

@@ -776,4 +776,4 @@

export const refineOrDie: {
<E, E2>(pf: (error: E) => Option.Option<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>
<R, E, A, E2>(self: Query<R, E, A>, pf: (error: E) => Option.Option<E2>): Query<R, E2, A>
<E, E2>(pf: (error: E) => Option.Option<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>
} = internal.refineOrDie

@@ -789,3 +789,2 @@

export const refineOrDieWith: {
<R, E, A, E2>(self: Query<R, E, A>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): Query<R, E2, A>
<E, E2>(

@@ -795,2 +794,3 @@ pf: (error: E) => Option.Option<E2>,

): <R, A>(self: Query<R, E, A>) => Query<R, E2, A>
<R, E, A, E2>(self: Query<R, E, A>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): Query<R, E2, A>
} = internal.refineOrDieWith

@@ -824,4 +824,4 @@

export const runCache: {
(cache: Cache.Cache): <R, E, A>(self: Query<R, E, A>) => Effect.Effect<R, E, A>
<R, E, A>(self: Query<R, E, A>, cache: Cache.Cache): Effect.Effect<R, E, A>
(cache: Cache.Cache): <R, E, A>(self: Query<R, E, A>) => Effect.Effect<R, E, A>
} = internal.runCache

@@ -855,8 +855,8 @@

<R, E, A, R2, E2, A2>(
f: (self: Query<R, Cause.Cause<E>, A>) => Query<R2, Cause.Cause<E2>, A2>
): (self: Query<R, E, A>) => Query<R | R2, E2, A | A2>
<R, E, A, R2, E2, A2>(
self: Query<R, E, A>,
f: (self: Query<R, Cause.Cause<E>, A>) => Query<R2, Cause.Cause<E2>, A2>
): Query<R | R2, E2, A | A2>
<R, E, A, R2, E2, A2>(
f: (self: Query<R, Cause.Cause<E>, A>) => Query<R2, Cause.Cause<E2>, A2>
): (self: Query<R, E, A>) => Query<R | R2, E2, A | A2>
} = internal.sandboxWith

@@ -923,4 +923,4 @@

export const someOrElse: {
<A, B>(def: LazyArg<B>): <R, E>(self: Query<R, E, Option.Option<A>>) => Query<R, E, A | B>
<R, E, A, B>(self: Query<R, E, Option.Option<A>>, def: LazyArg<B>): Query<R, E, A | B>
<A, B>(def: LazyArg<B>): <R, E>(self: Query<R, E, Option.Option<A>>) => Query<R, E, A | B>
} = internal.someOrElse

@@ -935,2 +935,5 @@

export const someOrElseEffect: {
<R2, E2, A2>(
def: LazyArg<Query<R2, E2, A2>>
): <R, E, A>(self: Query<R, E, Option.Option<A>>) => Query<R2 | R, E2 | E, A2 | A>
<R, E, A, R2, E2, A2>(

@@ -940,5 +943,2 @@ self: Query<R, E, Option.Option<A>>,

): Query<R | R2, E | E2, A | A2>
<R2, E2, A2>(
def: LazyArg<Query<R2, E2, A2>>
): <R, E, A>(self: Query<R, E, Option.Option<A>>) => Query<R2 | R, E2 | E, A2 | A>
} = internal.someOrElseEffect

@@ -953,4 +953,4 @@

export const someOrFail: {
<E2>(error: LazyArg<E2>): <R, E, A>(self: Query<R, E, Option.Option<A>>) => Query<R, E2 | E, A>
<R, E, A, E2>(self: Query<R, E, Option.Option<A>>, error: LazyArg<E2>): Query<R, E | E2, A>
<E2>(error: LazyArg<E2>): <R, E, A>(self: Query<R, E, Option.Option<A>>) => Query<R, E2 | E, A>
} = internal.someOrFail

@@ -991,2 +991,6 @@

export const summarized: {
<R2, E2, B, C>(
summary: Effect.Effect<R2, E2, B>,
f: (start: B, end: B) => C
): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [C, A]>
<R, E, A, R2, E2, B, C>(

@@ -997,6 +1001,2 @@ self: Query<R, E, A>,

): Query<R | R2, E | E2, readonly [C, A]>
<R2, E2, B, C>(
summary: Effect.Effect<R2, E2, B>,
f: (start: B, end: B) => C
): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [C, A]>
} = internal.summarized

@@ -1036,4 +1036,4 @@

export const timeout: {
(duration: Duration.Duration): <R, E, A>(self: Query<R, E, A>) => Query<R, E, Option.Option<A>>
<R, E, A>(self: Query<R, E, A>, duration: Duration.Duration): Query<R, E, Option.Option<A>>
(duration: Duration.Duration): <R, E, A>(self: Query<R, E, A>) => Query<R, E, Option.Option<A>>
} = internal.timeout

@@ -1049,4 +1049,4 @@

export const timeoutFail: {
<E2>(error: LazyArg<E2>, duration: Duration.Duration): <R, E, A>(self: Query<R, E, A>) => Query<R, E2 | E, A>
<R, E, A, E2>(self: Query<R, E, A>, error: LazyArg<E2>, duration: Duration.Duration): Query<R, E | E2, A>
<E2>(error: LazyArg<E2>, duration: Duration.Duration): <R, E, A>(self: Query<R, E, A>) => Query<R, E2 | E, A>
} = internal.timeoutFail

@@ -1062,2 +1062,6 @@

export const timeoutFailCause: {
<E2>(
evaluate: LazyArg<Cause.Cause<E2>>,
duration: Duration.Duration
): <R, E, A>(self: Query<R, E, A>) => Query<R, E2 | E, A>
<R, E, A, E2>(

@@ -1068,6 +1072,2 @@ self: Query<R, E, A>,

): Query<R, E | E2, A>
<E2>(
evaluate: LazyArg<Cause.Cause<E2>>,
duration: Duration.Duration
): <R, E, A>(self: Query<R, E, A>) => Query<R, E2 | E, A>
} = internal.timeoutFailCause

@@ -1084,4 +1084,4 @@

export const timeoutTo: {
<B2, A, B>(def: B2, f: (a: A) => B, duration: Duration.Duration): <R, E>(self: Query<R, E, A>) => Query<R, E, B2 | B>
<R, E, A, B2, B>(self: Query<R, E, A>, def: B2, f: (a: A) => B, duration: Duration.Duration): Query<R, E, B2 | B>
<B2, A, B>(def: B2, f: (a: A) => B, duration: Duration.Duration): <R, E>(self: Query<R, E, A>) => Query<R, E, B2 | B>
} = internal.timeoutTo

@@ -1132,4 +1132,4 @@

export const unrefine: {
<E, E2>(pf: (defect: unknown) => Option.Option<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E | E2, A>
<R, E, A, E2>(self: Query<R, E, A>, pf: (defect: unknown) => Option.Option<E2>): Query<R, E | E2, A>
<E, E2>(pf: (defect: unknown) => Option.Option<E2>): <R, A>(self: Query<R, E, A>) => Query<R, E | E2, A>
} = internal.unrefine

@@ -1145,2 +1145,6 @@

export const unrefineWith: {
<E, E2, E3>(
pf: (defect: unknown) => Option.Option<E2>,
f: (error: E) => E3
): <R, A>(self: Query<R, E, A>) => Query<R, E2 | E3, A>
<R, E, A, E2, E3>(

@@ -1151,6 +1155,2 @@ self: Query<R, E, A>,

): Query<R, E2 | E3, A>
<E, E2, E3>(
pf: (defect: unknown) => Option.Option<E2>,
f: (error: E) => E3
): <R, A>(self: Query<R, E, A>) => Query<R, E2 | E3, A>
} = internal.unrefineWith

@@ -1193,4 +1193,4 @@

export const zip: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, readonly [A, A2]>
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>
} = internal.zip

@@ -1207,4 +1207,4 @@

export const zipBatched: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, readonly [A, A2]>
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>
} = internal.zipBatched

@@ -1221,4 +1221,4 @@

export const zipBatchedLeft: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A>
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>
} = internal.zipBatchedLeft

@@ -1235,4 +1235,4 @@

export const zipBatchedRight: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A2>
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>
} = internal.zipBatchedRight

@@ -1248,4 +1248,4 @@

export const zipLeft: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A>
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>
} = internal.zipLeft

@@ -1261,4 +1261,4 @@

export const zipRight: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A2>
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>
} = internal.zipRight

@@ -1274,4 +1274,4 @@

export const zipPar: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, readonly [A, A2]>
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, readonly [A, A2]>
} = internal.zipPar

@@ -1287,4 +1287,4 @@

export const zipParLeft: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A>
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A>
} = internal.zipParLeft

@@ -1300,4 +1300,4 @@

export const zipParRight: {
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>
<R, E, A, R2, E2, A2>(self: Query<R, E, A>, that: Query<R2, E2, A2>): Query<R | R2, E | E2, A2>
<R2, E2, A2>(that: Query<R2, E2, A2>): <R, E, A>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, A2>
} = internal.zipParRight

@@ -1315,7 +1315,13 @@

export const zipWith: {
<R, E, A, R2, E2, B, C>(self: Query<R, E, A>, that: Query<R2, E2, B>, f: (a: A, b: B) => C): Query<R | R2, E | E2, C>
<R2, E2, B, A, C>(
that: Query<R2, E2, B>,
f: (a: A, b: B) => C
): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, C>
): <R, E>(
self: Query<R, E, A>
) => Query<R2 | R, E2 | E, C>
<R, E, A, R2, E2, B, C>(
self: Query<R, E, A>,
that: Query<R2, E2, B>,
f: (a: A, b: B) => C
): Query<R | R2, E | E2, C>
} = internal.zipWith

@@ -1331,7 +1337,13 @@

export const zipWithBatched: {
<R, E, A, R2, E2, B, C>(self: Query<R, E, A>, that: Query<R2, E2, B>, f: (a: A, b: B) => C): Query<R | R2, E | E2, C>
<A, R2, E2, B, C>(
that: Query<R2, E2, B>,
f: (a: A, b: B) => C
): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, C>
): <R, E>(
self: Query<R, E, A>
) => Query<R2 | R, E2 | E, C>
<R, E, A, R2, E2, B, C>(
self: Query<R, E, A>,
that: Query<R2, E2, B>,
f: (a: A, b: B) => C
): Query<R | R2, E | E2, C>
} = internal.zipWithBatched

@@ -1349,7 +1361,13 @@

export const zipWithPar: {
<R, E, A, R2, E2, B, C>(self: Query<R, E, A>, that: Query<R2, E2, B>, f: (a: A, b: B) => C): Query<R | R2, E | E2, C>
<A, R2, E2, B, C>(
that: Query<R2, E2, B>,
f: (a: A, b: B) => C
): <R, E>(self: Query<R, E, A>) => Query<R2 | R, E2 | E, C>
): <R, E>(
self: Query<R, E, A>
) => Query<R2 | R, E2 | E, C>
<R, E, A, R2, E2, B, C>(
self: Query<R, E, A>,
that: Query<R2, E2, B>,
f: (a: A, b: B) => C
): Query<R | R2, E | E2, C>
} = internal.zipWithPar

34

src/Request.ts
/**
* @since 1.0.0
*/
import type * as Data from "@effect/data/Data"
import type * as Effect from "@effect/io/Effect"

@@ -9,3 +10,2 @@ import type * as CompletedRequestMap from "@effect/query/CompletedRequestMap"

import type * as Option from "@fp-ts/core/Option"
import type * as Data from "@effect/data/Data"

@@ -125,10 +125,8 @@ /**

<A extends Request<any, any>>(
result: Request.Result<A>
): (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
<A extends Request<any, any>>(
self: A,
result: Request.Result<A>
): Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
<A extends Request<any, any>>(
result: Request.Result<A>
): (
self: A
) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
} = internal.complete

@@ -146,10 +144,8 @@

<A extends Request<any, any>, R>(
effect: Effect.Effect<R, Request.Error<A>, Request.Success<A>>
): (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap | R, never, void>
<A extends Request<any, any>, R>(
self: A,
effect: Effect.Effect<R, Request.Error<A>, Request.Success<A>>
): Effect.Effect<CompletedRequestMap.CompletedRequestMap | R, never, void>
<A extends Request<any, any>, R>(
effect: Effect.Effect<R, Request.Error<A>, Request.Success<A>>
): (
self: A
) => Effect.Effect<CompletedRequestMap.CompletedRequestMap | R, never, void>
} = internal.completeEffect

@@ -165,10 +161,8 @@

<A extends Request<any, any>>(
error: Request.Error<A>
): (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
<A extends Request<any, any>>(
self: A,
error: Request.Error<A>
): Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
<A extends Request<any, any>>(
error: Request.Error<A>
): (
self: A
) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
} = internal.fail

@@ -184,10 +178,8 @@

<A extends Request<any, any>>(
value: Request.Success<A>
): (self: A) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
<A extends Request<any, any>>(
self: A,
value: Request.Success<A>
): Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
<A extends Request<any, any>>(
value: Request.Success<A>
): (
self: A
) => Effect.Effect<CompletedRequestMap.CompletedRequestMap, never, void>
} = internal.succeed
Cache.d.ts.map

Sorry, the diff of this file is not supported yet

Cache.js.map

Sorry, the diff of this file is not supported yet

CompletedRequestMap.d.ts.map

Sorry, the diff of this file is not supported yet

CompletedRequestMap.js.map

Sorry, the diff of this file is not supported yet

DataSource.d.ts.map

Sorry, the diff of this file is not supported yet

DataSource.js.map

Sorry, the diff of this file is not supported yet

internal_effect_untraced/completedRequestMap.js.map

Sorry, the diff of this file is not supported yet

internal_effect_untraced/query.d.ts.map

Sorry, the diff of this file is not supported yet

internal_effect_untraced/query.js.map

Sorry, the diff of this file is not supported yet

internal_effect_untraced/request.js.map

Sorry, the diff of this file is not supported yet

mjs/Cache.mjs.map

Sorry, the diff of this file is not supported yet

mjs/CompletedRequestMap.mjs

Sorry, the diff of this file is not supported yet

mjs/CompletedRequestMap.mjs.map

Sorry, the diff of this file is not supported yet

mjs/DataSource.mjs.map

Sorry, the diff of this file is not supported yet

mjs/internal_effect_untraced/completedRequestMap.mjs

Sorry, the diff of this file is not supported yet

mjs/internal_effect_untraced/completedRequestMap.mjs.map

Sorry, the diff of this file is not supported yet

mjs/internal_effect_untraced/query.mjs.map

Sorry, the diff of this file is not supported yet

mjs/internal_effect_untraced/request.mjs

Sorry, the diff of this file is not supported yet

mjs/internal_effect_untraced/request.mjs.map

Sorry, the diff of this file is not supported yet

mjs/Query.mjs.map

Sorry, the diff of this file is not supported yet

mjs/Request.mjs.map

Sorry, the diff of this file is not supported yet

Query.d.ts.map

Sorry, the diff of this file is not supported yet

Query.js.map

Sorry, the diff of this file is not supported yet

Request.d.ts.map

Sorry, the diff of this file is not supported yet

Request.js.map

Sorry, the diff of this file is not supported yet

src/internal_effect_untraced/query.ts

Sorry, the diff of this file is too big to display

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc