/**
* @since 2.0.0
*/
import { Either } from './Either.js';
import { Eq } from './Eq.js';
import { Magma } from './Magma.js';
import { Monoid } from './Monoid.js';
import { Option } from './Option.js';
import { Ord } from './Ord.js';
import { Predicate } from './Predicate.js';
import { Refinement } from './Refinement.js';
import { Semigroup } from './Semigroup.js';
import { Separated } from './Separated.js';
import { Show } from './Show.js';
/**
* @category instances
* @since 2.0.0
*/
export declare const getShow: (S: Show) => Show>;
/**
* @category instances
* @since 2.0.0
*/
export declare const getEq: (E: Eq) => Eq>;
/**
* `map` can be used to turn functions `(a: A) => B` into functions `(fa: F) => F` whose argument and return types
* use the type constructor `F` to represent some computational context.
*
* @since 2.0.0
*/
export declare function map(E: Eq): (f: (x: A) => B) => (set: Set) => Set;
/**
* Composes computations in sequence, using the return value of one computation to determine the next computation.
*
* @since 2.0.0
*/
export declare function chain(E: Eq): (f: (x: A) => Set) => (set: Set) => Set;
/**
* @since 2.0.0
*/
export declare function filter(refinement: Refinement): (set: Set) => Set;
export declare function filter(predicate: Predicate): (set: Set) => Set;
export declare function filter(predicate: Predicate): (set: Set) => Set;
/**
* @since 2.0.0
*/
export declare function partition(refinement: Refinement): (set: Set) => Separated, Set>;
export declare function partition(predicate: Predicate): (set: Set) => Separated, Set>;
export declare function partition(predicate: Predicate): (set: Set) => Separated, Set>;
/**
* Form the union of two sets
*
* @since 2.0.0
*/
export declare function union(E: Eq): {
(that: Set): (me: Set) => Set;
(me: Set, that: Set): Set;
};
/**
* The set of elements which are in both the first and second set
*
* @since 2.0.0
*/
export declare function intersection(E: Eq): {
(that: Set): (me: Set) => Set;
(me: Set, that: Set): Set;
};
/**
* @since 2.0.0
*/
export declare function partitionMap(EB: Eq, EC: Eq): (f: (a: A) => Either) => (set: Set) => Separated, Set>;
/**
* Form the set difference (`x` - `y`)
*
* @example
* import { difference } from 'fp-ts/Set'
* import * as N from 'fp-ts/number'
* import { pipe } from 'fp-ts/function'
*
* assert.deepStrictEqual(pipe(new Set([1, 2]), difference(N.Eq)(new Set([1, 3]))), new Set([2]))
*
* @since 2.0.0
*/
export declare function difference(E: Eq): {
(that: Set): (me: Set) => Set;
(me: Set, that: Set): Set;
};
/**
* @category instances
* @since 2.11.0
*/
export declare const getUnionSemigroup: (E: Eq) => Semigroup>;
/**
* @category instances
* @since 2.0.0
*/
export declare const getUnionMonoid: (E: Eq) => Monoid>;
/**
* @category instances
* @since 2.0.0
*/
export declare const getIntersectionSemigroup: (E: Eq) => Semigroup>;
/**
* @category instances
* @since 2.11.0
*/
export declare const getDifferenceMagma: (E: Eq) => Magma>;
/**
* @category folding
* @since 2.0.0
*/
export declare const reduce: (O: Ord) => (b: B, f: (b: B, a: A) => B) => (fa: Set) => B;
/**
* @category folding
* @since 2.0.0
*/
export declare const foldMap: (O: Ord, M: Monoid) => (f: (a: A) => M) => (fa: Set) => M;
/**
* @category folding
* @since 2.11.0
*/
export declare const reduceRight: (O: Ord) => (b: B, f: (a: A, b: B) => B) => (fa: Set) => B;
/**
* Create a set with one element
*
* @category constructors
* @since 2.0.0
*/
export declare const singleton: (a: A) => Set;
/**
* Insert a value into a set
*
* @since 2.0.0
*/
export declare function insert(E: Eq): (a: A) => (set: Set) => Set;
/**
* Delete a value from a set
*
* @since 2.0.0
*/
export declare const remove: (E: Eq) => (a: A) => (set: Set) => Set;
/**
* Checks an element is a member of a set;
* If yes, removes the value from the set
* If no, inserts the value to the set
*
* @since 2.5.0
*/
export declare const toggle: (E: Eq) => ((a: A) => (set: Set) => Set);
/**
* Create a set from an array
*
* @category conversions
* @since 2.0.0
*/
export declare const fromArray: (E: Eq) => (as: Array) => Set;
/**
* @since 2.0.0
*/
export declare const compact: (E: Eq) => ((fa: Set>) => Set);
/**
* @since 2.0.0
*/
export declare function separate(EE: Eq, EA: Eq): (fa: Set>) => Separated, Set>;
/**
* @since 2.0.0
*/
export declare function filterMap(E: Eq): (f: (a: A) => Option) => (fa: Set) => Set;
/**
* @since 2.0.0
*/
export declare const empty: Set;
/**
* Test whether a `Set` is empty.
*
* @since 2.10.0
*/
export declare const isEmpty: (set: Set) => boolean;
/**
* Calculate the number of elements in a `Set`.
*
* @since 2.10.0
*/
export declare const size: (set: Set) => number;
/**
* @since 2.0.0
*/
export declare const some: (predicate: Predicate) => (set: Set) => boolean;
/**
* @since 2.0.0
*/
export declare const every: {
(refinement: Refinement): Refinement, Set>;
(predicate: Predicate): Predicate>;
};
/**
* @since 2.10.0
*/
export declare const isSubset: (E: Eq) => (that: Set) => (me: Set) => boolean;
/**
* Test if a value is a member of a set
*
* @since 2.0.0
*/
export declare const elem: (E: Eq) => {
(a: A): (set: Set) => boolean;
(a: A, set: Set): boolean;
};
/**
* Get a sorted `Array` of the values contained in a `Set`.
*
* @category conversions
* @since 2.0.0
*/
export declare const toArray: (O: Ord) => (set: Set) => Array;
/**
* Use [`isSubset`](#issubset) instead.
*
* @category zone of death
* @since 2.0.0
* @deprecated
*/
export declare const subset: (E: Eq) => {
(that: Set): (me: Set) => boolean;
(me: Set, that: Set): boolean;
};