/**
* @since 2.0.0
*/
import { Either } from './Either'
import { Eq } from './Eq'
import { Magma } from './Magma'
import { Monoid } from './Monoid'
import { Option } from './Option'
import { Ord } from './Ord'
import { Predicate } from './Predicate'
import { Refinement } from './Refinement'
import { Semigroup } from './Semigroup'
import { Separated } from './Separated'
import { Show } from './Show'
/**
* @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: A[]) => Set
/**
* @since 2.0.0
*/
export declare const compact: (E: Eq) => (fa: Set