Semigroup.ts overview
Since v0.24.0
Exports Grouped by Category
combinators
array
Given a type A, this function creates and returns a Semigroup for ReadonlyArray<A>. The returned Semigroup combines two arrays by concatenating them.
Signature
declare const array: <A>() => Semigroup<ReadonlyArray<A>>
Since v0.24.0
struct
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 { readonly [x: string]: Semigroup<any> }>(
fields: R
) => Semigroup<{ readonly [K in keyof R]: [R[K]] extends [Semigroup<infer A>] ? A : never }>
Since v0.24.0
tuple
Similar to Promise.all but operates on Semigroups.
[Semigroup<A>, Semigroup<B>, ...] -> Semigroup<[A, B, ...]>
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<{ readonly [I in keyof T]: [T[I]] extends [Semigroup<infer A>] ? A : never }>
Since v0.24.0
constructors
constant
Signature
declare const constant: <A>(a: A) => Semigroup<A>
Since v0.24.0
make
The combineMany parameter is optional and defaults to a standard implementation. You can provide a custom implementation when performance optimizations are possible.
Signature
declare const make: <A>(combine: Semigroup<A>["combine"], combineMany?: Semigroup<A>["combineMany"]) => Semigroup<A>
Since v0.24.0
max
Semigroup that returns last maximum of elements.
Signature
declare const max: <A>(O: Order<A>) => Semigroup<A>
Since v0.24.0
min
Semigroup that returns last minimum of elements.
Signature
declare const min: <A>(O: Order<A>) => Semigroup<A>
Since v0.24.0
instances
Invariant
Signature
declare const Invariant: invariant.Invariant<SemigroupTypeLambda>
Since v0.24.0
Product
Signature
declare const Product: product_.Product<SemigroupTypeLambda>
Since v0.24.0
SemiProduct
Signature
declare const SemiProduct: semiProduct.SemiProduct<SemigroupTypeLambda>
Since v0.24.0
first
Always return the first argument.
Signature
declare const first: <A = never>() => Semigroup<A>
Since v0.24.0
last
Always return the last argument.
Signature
declare const last: <A = never>() => Semigroup<A>
Since v0.24.0
type class
Semigroup (interface)
Signature
export interface Semigroup<A> {
readonly combine: (self: A, that: A) => A
readonly combineMany: (self: A, collection: Iterable<A>) => A
}
Since v0.24.0
type lambdas
SemigroupTypeLambda (interface)
Signature
export interface SemigroupTypeLambda extends TypeLambda {
readonly type: Semigroup<this["Target"]>
}
Since v0.24.0
utils
imap
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>
}
Since v0.24.0
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>
}
Since v0.24.0
reverse
The dual of a Semigroup, obtained by flipping the arguments of combine.
Signature
declare const reverse: <A>(S: Semigroup<A>) => Semigroup<A>
Since v0.24.0