Aktueller Stand
This commit is contained in:
260
backend/node_modules/effect/dist/dts/Order.d.ts
generated
vendored
Normal file
260
backend/node_modules/effect/dist/dts/Order.d.ts
generated
vendored
Normal file
@@ -0,0 +1,260 @@
|
||||
import type { TypeLambda } from "./HKT.js";
|
||||
/**
|
||||
* @category type class
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export interface Order<in A> {
|
||||
(self: A, that: A): -1 | 0 | 1;
|
||||
}
|
||||
/**
|
||||
* @category type lambdas
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export interface OrderTypeLambda extends TypeLambda {
|
||||
readonly type: Order<this["Target"]>;
|
||||
}
|
||||
/**
|
||||
* @category constructors
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const make: <A>(compare: (self: A, that: A) => -1 | 0 | 1) => Order<A>;
|
||||
/**
|
||||
* @category instances
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const string: Order<string>;
|
||||
/**
|
||||
* @category instances
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const number: Order<number>;
|
||||
/**
|
||||
* @category instances
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const boolean: Order<boolean>;
|
||||
/**
|
||||
* @category instances
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const bigint: Order<bigint>;
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const reverse: <A>(O: Order<A>) => Order<A>;
|
||||
/**
|
||||
* @category combining
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const combine: {
|
||||
/**
|
||||
* @category combining
|
||||
* @since 2.0.0
|
||||
*/
|
||||
<A>(that: Order<A>): (self: Order<A>) => Order<A>;
|
||||
/**
|
||||
* @category combining
|
||||
* @since 2.0.0
|
||||
*/
|
||||
<A>(self: Order<A>, that: Order<A>): Order<A>;
|
||||
};
|
||||
/**
|
||||
* @category combining
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const combineMany: {
|
||||
/**
|
||||
* @category combining
|
||||
* @since 2.0.0
|
||||
*/
|
||||
<A>(collection: Iterable<Order<A>>): (self: Order<A>) => Order<A>;
|
||||
/**
|
||||
* @category combining
|
||||
* @since 2.0.0
|
||||
*/
|
||||
<A>(self: Order<A>, collection: Iterable<Order<A>>): Order<A>;
|
||||
};
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const empty: <A>() => Order<A>;
|
||||
/**
|
||||
* @category combining
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const combineAll: <A>(collection: Iterable<Order<A>>) => Order<A>;
|
||||
/**
|
||||
* @category mapping
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const mapInput: {
|
||||
/**
|
||||
* @category mapping
|
||||
* @since 2.0.0
|
||||
*/
|
||||
<B, A>(f: (b: B) => A): (self: Order<A>) => Order<B>;
|
||||
/**
|
||||
* @category mapping
|
||||
* @since 2.0.0
|
||||
*/
|
||||
<A, B>(self: Order<A>, f: (b: B) => A): Order<B>;
|
||||
};
|
||||
/**
|
||||
* @category instances
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const Date: Order<Date>;
|
||||
/**
|
||||
* @category combining
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const product: {
|
||||
<B>(that: Order<B>): <A>(self: Order<A>) => Order<readonly [A, B]>;
|
||||
<A, B>(self: Order<A>, that: Order<B>): Order<readonly [A, B]>;
|
||||
};
|
||||
/**
|
||||
* @category combining
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const all: <A>(collection: Iterable<Order<A>>) => Order<ReadonlyArray<A>>;
|
||||
/**
|
||||
* @category combining
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const productMany: {
|
||||
<A>(collection: Iterable<Order<A>>): (self: Order<A>) => Order<readonly [A, ...Array<A>]>;
|
||||
<A>(self: Order<A>, collection: Iterable<Order<A>>): Order<readonly [A, ...Array<A>]>;
|
||||
};
|
||||
/**
|
||||
* Similar to `Promise.all` but operates on `Order`s.
|
||||
*
|
||||
* ```
|
||||
* [Order<A>, Order<B>, ...] -> Order<[A, B, ...]>
|
||||
* ```
|
||||
*
|
||||
* This function creates and returns a new `Order` for a tuple of values based on the given `Order`s for each element in the tuple.
|
||||
* The returned `Order` compares two tuples of the same type by applying the corresponding `Order` to each element in the tuple.
|
||||
* It is useful when you need to compare two tuples of the same type and you have a specific way of comparing each element
|
||||
* of the tuple.
|
||||
*
|
||||
* @category combinators
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const tuple: <T extends ReadonlyArray<Order<any>>>(...elements: T) => Order<Readonly<{ [I in keyof T]: [T[I]] extends [Order<infer A>] ? A : never; }>>;
|
||||
/**
|
||||
* This function creates and returns a new `Order` for an array of values based on a given `Order` for the elements of the array.
|
||||
* The returned `Order` compares two arrays by applying the given `Order` to each element in the arrays.
|
||||
* If all elements are equal, the arrays are then compared based on their length.
|
||||
* It is useful when you need to compare two arrays of the same type and you have a specific way of comparing each element of the array.
|
||||
*
|
||||
* @category combinators
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const array: <A>(O: Order<A>) => Order<ReadonlyArray<A>>;
|
||||
/**
|
||||
* This function creates and returns a new `Order` for a struct of values based on the given `Order`s
|
||||
* for each property in the struct.
|
||||
*
|
||||
* @category combinators
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const struct: <R extends {
|
||||
readonly [x: string]: Order<any>;
|
||||
}>(fields: R) => Order<{ [K in keyof R]: [R[K]] extends [Order<infer A>] ? A : never; }>;
|
||||
/**
|
||||
* Test whether one value is _strictly less than_ another.
|
||||
*
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const lessThan: <A>(O: Order<A>) => {
|
||||
(that: A): (self: A) => boolean;
|
||||
(self: A, that: A): boolean;
|
||||
};
|
||||
/**
|
||||
* Test whether one value is _strictly greater than_ another.
|
||||
*
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const greaterThan: <A>(O: Order<A>) => {
|
||||
(that: A): (self: A) => boolean;
|
||||
(self: A, that: A): boolean;
|
||||
};
|
||||
/**
|
||||
* Test whether one value is _non-strictly less than_ another.
|
||||
*
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const lessThanOrEqualTo: <A>(O: Order<A>) => {
|
||||
(that: A): (self: A) => boolean;
|
||||
(self: A, that: A): boolean;
|
||||
};
|
||||
/**
|
||||
* Test whether one value is _non-strictly greater than_ another.
|
||||
*
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const greaterThanOrEqualTo: <A>(O: Order<A>) => {
|
||||
(that: A): (self: A) => boolean;
|
||||
(self: A, that: A): boolean;
|
||||
};
|
||||
/**
|
||||
* Take the minimum of two values. If they are considered equal, the first argument is chosen.
|
||||
*
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const min: <A>(O: Order<A>) => {
|
||||
(that: A): (self: A) => A;
|
||||
(self: A, that: A): A;
|
||||
};
|
||||
/**
|
||||
* Take the maximum of two values. If they are considered equal, the first argument is chosen.
|
||||
*
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const max: <A>(O: Order<A>) => {
|
||||
(that: A): (self: A) => A;
|
||||
(self: A, that: A): A;
|
||||
};
|
||||
/**
|
||||
* Clamp a value between a minimum and a maximum.
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* import * as assert from "node:assert"
|
||||
* import { Order, Number } from "effect"
|
||||
*
|
||||
* const clamp = Order.clamp(Number.Order)({ minimum: 1, maximum: 5 })
|
||||
*
|
||||
* assert.equal(clamp(3), 3)
|
||||
* assert.equal(clamp(0), 1)
|
||||
* assert.equal(clamp(6), 5)
|
||||
* ```
|
||||
*
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const clamp: <A>(O: Order<A>) => {
|
||||
(options: {
|
||||
minimum: A;
|
||||
maximum: A;
|
||||
}): (self: A) => A;
|
||||
(self: A, options: {
|
||||
minimum: A;
|
||||
maximum: A;
|
||||
}): A;
|
||||
};
|
||||
/**
|
||||
* Test whether a value is between a minimum and a maximum (inclusive).
|
||||
*
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export declare const between: <A>(O: Order<A>) => {
|
||||
(options: {
|
||||
minimum: A;
|
||||
maximum: A;
|
||||
}): (self: A) => boolean;
|
||||
(self: A, options: {
|
||||
minimum: A;
|
||||
maximum: A;
|
||||
}): boolean;
|
||||
};
|
||||
//# sourceMappingURL=Order.d.ts.map
|
||||
Reference in New Issue
Block a user