export declare const combine: {
  (that: Ordering): (self: Ordering) => Ordering
  (self: Ordering, that: Ordering): Ordering
}

export declare const combineAll: (collection: Iterable<Ordering>) => Ordering

export declare const combineMany: {
  (collection: Iterable<Ordering>): (self: Ordering) => Ordering
  (self: Ordering, collection: Iterable<Ordering>): Ordering
}

export type Ordering = -1 | 0 | 1

export declare const match: {
  <A, B, C = B>(options: {
    readonly onLessThan: LazyArg<A>
    readonly onEqual: LazyArg<B>
    readonly onGreaterThan: LazyArg<C>
  }): (self: Ordering) => A | B | C
  <A, B, C = B>(
    o: Ordering,
    options: { readonly onLessThan: LazyArg<A>; readonly onEqual: LazyArg<B>; readonly onGreaterThan: LazyArg<C> }
  ): A | B | C
}

import { Ordering } from "effect"
import { constant } from "effect/Function"

const toMessage = Ordering.match({
  onLessThan: constant("less than"),
  onEqual: constant("equal"),
  onGreaterThan: constant("greater than")
})

assert.deepStrictEqual(toMessage(-1), "less than")
assert.deepStrictEqual(toMessage(0), "equal")
assert.deepStrictEqual(toMessage(1), "greater than")

export declare const reverse: (o: Ordering) => Ordering

import { reverse } from "effect/Ordering"

assert.deepStrictEqual(reverse(1), -1)
assert.deepStrictEqual(reverse(-1), 1)
assert.deepStrictEqual(reverse(0), 0)