Semigroup
Combinators
Signature
declare function array<A>(): Semigroup<readonly Array<A>>This function creates and returns a new Semigroup for a struct of values based on the given Semigroups for each property in the struct. The returned Semigroup combines two structs of the same type by applying the corresponding Semigroup passed as arguments to each property in the struct.
It is useful when you need to combine two structs of the same type and you have a specific way of combining each property of the struct.
Signature
declare const struct: <
R extends {
[x: string]: Semigroup<any>;
},
>(
fields: R,
) => Semigroup<{ [K in keyof R]: [R[K]] extends [Semigroup<infer A>] ? A : never }>;Similar to Promise.all but operates on Semigroups.
This function creates and returns a new Semigroup for a tuple of values based on the given Semigroups for each element in the tuple. The returned Semigroup combines two tuples of the same type by applying the corresponding Semigroup passed as arguments to each element in the tuple.
It is useful when you need to combine two tuples of the same type and you have a specific way of combining each element of the tuple.
Signature
declare const tuple: <T extends ReadonlyArray<Semigroup<any>>>(
...elements: T
) => Semigroup<{ [I in keyof T]: [T[I]] extends [Semigroup<infer A>] ? A : never }>;Example
[Semigroup<A>, Semigroup<B>, ...] -> Semigroup<[A, B, ...]>Constructors
Signature
declare function constant<A>(a: A): Semigroup<A>;The combineMany parameter is optional and defaults to a standard implementation. You can provide a custom implementation when performance optimizations are possible.
Signature
declare function make<A>(
combine: (self: A, that: A) => A,
combineMany: (self: A, collection: Iterable<A>) => A,
): Semigroup<A>;Semigroup that returns last maximum of elements.
Signature
declare function max<A>(O: Order<A>): Semigroup<A>;Semigroup that returns last minimum of elements.
Signature
declare function min<A>(O: Order<A>): Semigroup<A>;Instances
Always return the first argument.
Signature
declare function first<A = never>(): Semigroup<A>;Signature
declare const Invariant: invariant.Invariant<SemigroupTypeLambda>;Always return the last argument.
Signature
declare function last<A = never>(): Semigroup<A>;Signature
declare const Product: product_.Product<SemigroupTypeLambda>;SemiProduct
Signature
declare const SemiProduct: semiProduct.SemiProduct<SemigroupTypeLambda>;Other
Signature
declare const imap: {
<A, B>(to: (a: A) => B, from: (b: B) => A): (self: Semigroup<A>) => Semigroup<B>;
<A, B>(self: Semigroup<A>, to: (a: A) => B, from: (b: B) => A): Semigroup<B>;
};intercalate
The intercalate API returns a function that takes a Semigroup instance and a separator value, and returns a new Semigroup instance that combines values with the given separator.
This API is useful when you want to combine values with a specific separator. For example, when you want to concatenate an array of strings with a separator string in between.
It is interesting to note that there is no equivalent API in the Monoid module. This is because the value empty, which is required for the Monoid interface, cannot exist.
Signature
declare const intercalate: {
<A>(separator: A): (S: Semigroup<A>) => Semigroup<A>;
<A>(S: Semigroup<A>, separator: A): Semigroup<A>;
};The dual of a Semigroup, obtained by flipping the arguments of combine.
Signature
declare function reverse<A>(S: Semigroup<A>): Semigroup<A>;Type Class
Type Lambdas
SemigroupTypeLambda interface
Signature
interface SemigroupTypeLambda extends TypeLambda {
readonly type: Semigroup<unknown>;
}
Given a type
A, this function creates and returns aSemigroupforReadonlyArray<A>. The returnedSemigroupcombines two arrays by concatenating them.