interface Semigroup<A> {
  readonly concat: (x: A, y: A) => A
}

concat(x, concat(y, z)) = concat(concat(x, y), z)

import { Semigroup } from 'fp-ts/Semigroup'

const semigroupString: Semigroup<string> = {
  concat: (x, y) => x + y,
}

const x = 'x'
const y = 'y'
const z = 'z'

semigroupString.concat(x, y) // 'xy'

semigroupString.concat(x, semigroupString.concat(y, z)) // 'xyz'

semigroupString.concat(semigroupString.concat(x, y), z) // 'xyz'

export declare const intercalate: <A>(middle: A) => (S: Semigroup<A>) => Semigroup<A>

import { intercalate } from 'fp-ts/Semigroup'
import * as S from 'fp-ts/string'
import { pipe } from 'fp-ts/function'

const S1 = pipe(S.Semigroup, intercalate(' + '))

assert.strictEqual(S1.concat('a', 'b'), 'a + b')

export declare const reverse: <A>(S: Semigroup<A>) => Semigroup<A>

import { reverse } from 'fp-ts/Semigroup'
import * as S from 'fp-ts/string'

assert.deepStrictEqual(reverse(S.Semigroup).concat('a', 'b'), 'ba')

export declare const struct: <A>(
  semigroups: { [K in keyof A]: Semigroup<A[K]> }
) => Semigroup<{ readonly [K in keyof A]: A[K] }>

import { struct } from 'fp-ts/Semigroup'
import * as N from 'fp-ts/number'

interface Point {
  readonly x: number
  readonly y: number
}

const S = struct<Point>({
  x: N.SemigroupSum,
  y: N.SemigroupSum,
})

assert.deepStrictEqual(S.concat({ x: 1, y: 2 }, { x: 3, y: 4 }), { x: 4, y: 6 })

export declare const tuple: <A extends readonly unknown[]>(
  ...semigroups: { [K in keyof A]: Semigroup<A[K]> }
) => Semigroup<Readonly<A>>

import { tuple } from 'fp-ts/Semigroup'
import * as B from 'fp-ts/boolean'
import * as N from 'fp-ts/number'
import * as S from 'fp-ts/string'

const S1 = tuple(S.Semigroup, N.SemigroupSum)
assert.deepStrictEqual(S1.concat(['a', 1], ['b', 2]), ['ab', 3])

const S2 = tuple(S.Semigroup, N.SemigroupSum, B.SemigroupAll)
assert.deepStrictEqual(S2.concat(['a', 1, true], ['b', 2, false]), ['ab', 3, false])

export declare const getDualSemigroup: <A>(S: Semigroup<A>) => Semigroup<A>

export declare const getIntercalateSemigroup: <A>(middle: A) => (S: Semigroup<A>) => Semigroup<A>

export declare const getStructSemigroup: <O extends Readonly<Record<string, any>>>(
  semigroups: { [K in keyof O]: Semigroup<O[K]> }
) => Semigroup<O>

export declare const getTupleSemigroup: <T extends readonly Semigroup<any>[]>(
  ...semigroups: T
) => Semigroup<{ [K in keyof T]: T[K] extends Semigroup<infer A> ? A : never }>

export declare const constant: <A>(a: A) => Semigroup<A>

export declare const max: <A>(O: Or.Ord<A>) => Semigroup<A>

import * as N from 'fp-ts/number'
import * as S from 'fp-ts/Semigroup'

const S1 = S.max(N.Ord)

assert.deepStrictEqual(S1.concat(1, 2), 2)

export declare const min: <A>(O: Or.Ord<A>) => Semigroup<A>

import * as N from 'fp-ts/number'
import * as S from 'fp-ts/Semigroup'

const S1 = S.min(N.Ord)

assert.deepStrictEqual(S1.concat(1, 2), 1)

export declare const getJoinSemigroup: <A>(O: Or.Ord<A>) => Semigroup<A>

export declare const getMeetSemigroup: <A>(O: Or.Ord<A>) => Semigroup<A>

export declare const first: <A = never>() => Semigroup<A>

import * as S from 'fp-ts/Semigroup'

assert.deepStrictEqual(S.first<number>().concat(1, 2), 1)

export declare const last: <A = never>() => Semigroup<A>

import * as S from 'fp-ts/Semigroup'

assert.deepStrictEqual(S.last<number>().concat(1, 2), 2)

export declare const getFirstSemigroup: <A = never>() => Semigroup<A>

export declare const getFunctionSemigroup: <S>(S: Semigroup<S>) => <A = never>() => Semigroup<(a: A) => S>

export declare const getLastSemigroup: <A = never>() => Semigroup<A>

export declare const getObjectSemigroup: <A extends object = never>() => Semigroup<A>

export declare const semigroupAll: Semigroup<boolean>

export declare const semigroupAny: Semigroup<boolean>

export declare const semigroupProduct: Semigroup<number>

export declare const semigroupString: Semigroup<string>

export declare const semigroupSum: Semigroup<number>

export declare const semigroupVoid: Semigroup<void>

export interface Semigroup<A> extends Magma<A> {}

export declare const concatAll: <A>(S: Semigroup<A>) => (startWith: A) => (as: readonly A[]) => A

import { concatAll } from 'fp-ts/Semigroup'
import * as N from 'fp-ts/number'

const sum = concatAll(N.SemigroupSum)(0)

assert.deepStrictEqual(sum([1, 2, 3]), 6)
assert.deepStrictEqual(sum([]), 0)

export declare function fold<A>(
  S: Semigroup<A>
): {
  (startWith: A): (as: ReadonlyArray<A>) => A
  (startWith: A, as: ReadonlyArray<A>): A
}