export declare const getAbGrpInfix: <A>(M: TC.AbelianGroup<A>) => (a: A, s: AbelianGroupSymbol, b: A) => A

export declare const getAbGrpPolishInfix: <A>(M: TC.AbelianGroup<A>) => (s: AbelianGroupSymbol, x: A, y: A) => A

export declare const getAbGrpReversePolishInfix: <A>(M: TC.AbelianGroup<A>) => (a: A, b: A, s: AbelianGroupSymbol) => A

export declare const getDivisionRingInfix: <A>(F: TC.DivisionRing<A>) => (a: A, s: DivisionRingSymbol, b: A) => A

export declare const getDivisionRingPolishInfix: <A>(F: TC.DivisionRing<A>) => (s: DivisionRingSymbol, x: A, y: A) => A

export declare const getDivisionRingReversePolishInfix: <A>(
  F: TC.DivisionRing<A>
) => (a: A, b: A, s: DivisionRingSymbol) => A

export declare const getEqInfix: <A>(E: Eq.Eq<A>) => (a: A, s: EqSymbol, b: A) => boolean

export declare const getEqPolishInfix: <A>(E: Eq.Eq<A>) => (s: EqSymbol, x: A, y: A) => boolean

export declare const getEqReversePolishInfix: <A>(E: Eq.Eq<A>) => (a: A, b: A, s: EqSymbol) => boolean

export declare const getEuclideanRingInfix: <A>(F: TC.EuclidianRing<A>) => (a: A, s: EuclideanRingSymbol, b: A) => A

export declare const getEuclideanRingPolishInfix: <A>(
  F: TC.EuclidianRing<A>
) => (s: EuclideanRingSymbol, x: A, y: A) => A

export declare const getEuclideanRingReversePolishInfix: <A>(
  F: TC.EuclidianRing<A>
) => (a: A, b: A, s: EuclideanRingSymbol) => A

export declare const getFieldInfix: <A>(F: Fld.Field<A>) => (a: A, s: FieldSymbol, b: A) => A

export declare const getFieldPolishInfix: <A>(F: Fld.Field<A>) => (s: FieldSymbol, x: A, y: A) => A

export declare const getFieldReversePolishInfix: <A>(F: Fld.Field<A>) => (a: A, b: A, s: FieldSymbol) => A

export declare const getLeftModuleInfix: <L, A>(L: TC.LeftModule<A, L>) => (a: L, s: '.*', b: A) => A

export declare const getLeftModulePolishInfix: <L, A>(L: TC.LeftModule<A, L>) => (s: LeftModuleSymbol, l: L, a: A) => A

export declare const getLeftModuleReversePolishInfix: <L, A>(L: TC.LeftModule<A, L>) => (a: L, b: A, s: '.*') => A

export declare const getMonoidInfix: <A>(M: Mn.Monoid<A>) => (a: A, s: '<>', b: A) => A

export declare const getMonoidPolishInfix: <A>(M: Mn.Monoid<A>) => (s: MonoidSymbol, x: A, y: A) => A

export declare const getMonoidReversePolishInfix: <A>(M: Mn.Monoid<A>) => (a: A, b: A, s: '<>') => A

export declare const getOrdInfix: <A>(O: Ord.Ord<A>) => (a: A, s: OrdSymbol, b: A) => boolean

export declare const getOrdPolishInfix: <A>(O: Ord.Ord<A>) => (s: OrdSymbol, x: A, y: A) => boolean

export declare const getOrdReverseInfix: <A>(O: Ord.Ord<A>) => (a: A, b: A, s: OrdSymbol) => boolean

export declare const getRightModuleInfix: <L, A>(L: TC.LeftModule<A, L>) => (a: L, s: '.*', b: A) => A

export declare const getRightModulePolishInfix: <R, A>(
  L: TC.RightModule<A, R>
) => (s: RightModuleSymbol, a: A, r: R) => A

export declare const getRightModuleReversePolishInfix: <R, A>(L: TC.RightModule<A, R>) => (a: A, b: R, s: '*.') => A

export declare const getRingInfix: <A>(F: Rng.Ring<A>) => (a: A, s: RingSymbol, b: A) => A

export declare const getRingPolishInfix: <A>(F: Rng.Ring<A>) => (s: RingSymbol, x: A, y: A) => A

export declare const getRingReversePolishInfix: <A>(F: Rng.Ring<A>) => (a: A, b: A, s: RingSymbol) => A

export type AbelianGroupSymbol = '+' | '-'

export type DivisionRingSymbol = RingSymbol | '/.' | './'

export type EqSymbol = '==' | '!='

export type EuclideanRingSymbol = RingSymbol | '/'

export type FieldSymbol = EuclideanRingSymbol | '%'

export type LeftModuleSymbol = '.*'

export type MonoidSymbol = '<>'

export type OrdSymbol = EqSymbol | '<' | '<=' | '>' | '>='

export type RightModuleSymbol = '*.'

export type RingSymbol = AbelianGroupSymbol | '*'

export declare const makeInfix: <S extends string, A, B, C>(
  fns: Readonly<Record<S, (x: A, y: B) => C>>
) => (x: A, s: S, y: B) => C

import { makeInfix } from '@jacob-alford/matrix-ts/infix'
import * as H from '@jacob-alford/matrix-ts/quaternion'

type QuatSymbol = '+' | '-' | '*' | '/'

const _ = makeInfix<QuatSymbol, H.Quaternion, H.Quaternion, H.Quaternion>({
  '+': H.DivisionRing.add,
  '-': H.DivisionRing.sub,
  '*': H.DivisionRing.mul,
  '/': (x, y) => H.DivisionRing.mul(x, H.DivisionRing.recip(y)),
})

_(H.zero, '+', H.zero)

export declare const makePolishInfix: <S extends string, A, B, C>(
  fns: Readonly<Record<S, (x: A, y: B) => C>>
) => (s: S, x: A, y: B) => C

import { makePolishInfix } from '@jacob-alford/matrix-ts/infix'
import * as H from '@jacob-alford/matrix-ts/quaternion'

type QuatSymbol = '+' | '-' | '*' | '/'

const _ = makePolishInfix<QuatSymbol, H.Quaternion, H.Quaternion, H.Quaternion>({
  '+': H.DivisionRing.add,
  '-': H.DivisionRing.sub,
  '*': H.DivisionRing.mul,
  '/': (x, y) => H.DivisionRing.mul(x, H.DivisionRing.recip(y)),
})

_('+', H.zero, H.zero)

export declare const makeReversePolishInfix: <S extends string, A, B, C>(
  fns: Readonly<Record<S, (x: A, y: B) => C>>
) => (x: A, y: B, s: S) => C

import { makeReversePolishInfix } from '@jacob-alford/matrix-ts/infix'
import * as H from '@jacob-alford/matrix-ts/quaternion'

type QuatSymbol = '+' | '-' | '*' | '/'

const _ = makeReversePolishInfix<QuatSymbol, H.Quaternion, H.Quaternion, H.Quaternion>({
  '+': H.DivisionRing.add,
  '-': H.DivisionRing.sub,
  '*': H.DivisionRing.mul,
  '/': (x, y) => H.DivisionRing.mul(x, H.DivisionRing.recip(y)),
})

_(H.zero, H.zero, '+')