/**
 * A module for making uniform APIs for similar operations across different typeclass
 * instances. For example, `_(a, "+", b)` could be applied to a rational Field instance,
 * or a matrix AbelianGroup instance for adding together two fractions or matricies respectively.
 *
 * @since 1.0.0
 */
import * as Eq from 'fp-ts/Eq';
import * as Fld from 'fp-ts/Field';
import * as Mn from 'fp-ts/Monoid';
import * as Rng from 'fp-ts/Ring';
import * as Ord from 'fp-ts/Ord';
import * as TC from './typeclasses';
/**
 * @since 1.0.0
 * @category Model
 */
export declare type MonoidSymbol = '<>';
/**
 * @since 1.0.0
 * @category Model
 */
export declare type AbelianGroupSymbol = '+' | '-';
/**
 * @since 1.0.0
 * @category Model
 */
export declare type LeftModuleSymbol = '.*';
/**
 * @since 1.0.0
 * @category Model
 */
export declare type RightModuleSymbol = '*.';
/**
 * @since 1.0.0
 * @category Model
 */
export declare type RingSymbol = AbelianGroupSymbol | '*';
/**
 * @since 1.0.0
 * @category Model
 */
export declare type DivisionRingSymbol = RingSymbol | '/.' | './';
/**
 * @since 1.0.0
 * @category Model
 */
export declare type EuclideanRingSymbol = RingSymbol | '/';
/**
 * @since 1.0.0
 * @category Model
 */
export declare type FieldSymbol = EuclideanRingSymbol | '%';
/**
 * @since 1.0.0
 * @category Model
 */
export declare type EqSymbol = '==' | '!=';
/**
 * @since 1.0.0
 * @category Model
 */
export declare type OrdSymbol = EqSymbol | '<' | '<=' | '>' | '>=';
/**
 * Infix operators can sometimes be more convenient than using the full typeclass instance
 *
 * @since 1.0.0
 * @example
 *   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 makePolishInfix: <S extends string, A, B, C>(fns: Readonly<Record<S, (x: A, y: B) => C>>) => (s: S, x: A, y: B) => C;
/**
 * Infix operators can sometimes be more convenient than using the full typeclass instance
 *
 * @since 1.0.0
 * @example
 *   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, '+')
 */
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;
/**
 * Infix operators can sometimes be more convenient than using the full typeclass instance
 *
 * @since 1.0.0
 * @example
 *   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 makeInfix: <S extends string, A, B, C>(fns: Readonly<Record<S, (x: A, y: B) => C>>) => (x: A, s: S, y: B) => C;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getAbGrpPolishInfix: <A>(M: TC.AbelianGroup<A>) => (s: AbelianGroupSymbol, x: A, y: A) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getAbGrpReversePolishInfix: <A>(M: TC.AbelianGroup<A>) => (a: A, b: A, s: AbelianGroupSymbol) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getAbGrpInfix: <A>(M: TC.AbelianGroup<A>) => (a: A, s: AbelianGroupSymbol, b: A) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getMonoidPolishInfix: <A>(M: Mn.Monoid<A>) => (s: MonoidSymbol, x: A, y: A) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getMonoidReversePolishInfix: <A>(M: Mn.Monoid<A>) => (a: A, b: A, s: "<>") => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getMonoidInfix: <A>(M: Mn.Monoid<A>) => (a: A, s: "<>", b: A) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getRingPolishInfix: <A>(F: Rng.Ring<A>) => (s: RingSymbol, x: A, y: A) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getRingReversePolishInfix: <A>(F: Rng.Ring<A>) => (a: A, b: A, s: RingSymbol) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getRingInfix: <A>(F: Rng.Ring<A>) => (a: A, s: RingSymbol, b: A) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getEuclideanRingPolishInfix: <A>(F: TC.EuclidianRing<A>) => (s: EuclideanRingSymbol, x: A, y: A) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getEuclideanRingReversePolishInfix: <A>(F: TC.EuclidianRing<A>) => (a: A, b: A, s: EuclideanRingSymbol) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getEuclideanRingInfix: <A>(F: TC.EuclidianRing<A>) => (a: A, s: EuclideanRingSymbol, b: A) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getDivisionRingPolishInfix: <A>(F: TC.DivisionRing<A>) => (s: DivisionRingSymbol, x: A, y: A) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getDivisionRingReversePolishInfix: <A>(F: TC.DivisionRing<A>) => (a: A, b: A, s: DivisionRingSymbol) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getDivisionRingInfix: <A>(F: TC.DivisionRing<A>) => (a: A, s: DivisionRingSymbol, b: A) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getFieldPolishInfix: <A>(F: Fld.Field<A>) => (s: FieldSymbol, x: A, y: A) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getFieldReversePolishInfix: <A>(F: Fld.Field<A>) => (a: A, b: A, s: FieldSymbol) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getFieldInfix: <A>(F: Fld.Field<A>) => (a: A, s: FieldSymbol, b: A) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getEqPolishInfix: <A>(E: Eq.Eq<A>) => (s: EqSymbol, x: A, y: A) => boolean;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getEqReversePolishInfix: <A>(E: Eq.Eq<A>) => (a: A, b: A, s: EqSymbol) => boolean;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getEqInfix: <A>(E: Eq.Eq<A>) => (a: A, s: EqSymbol, b: A) => boolean;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getOrdPolishInfix: <A>(O: Ord.Ord<A>) => (s: OrdSymbol, x: A, y: A) => boolean;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getOrdReverseInfix: <A>(O: Ord.Ord<A>) => (a: A, b: A, s: OrdSymbol) => boolean;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getOrdInfix: <A>(O: Ord.Ord<A>) => (a: A, s: OrdSymbol, b: A) => boolean;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getLeftModulePolishInfix: <L, A>(L: TC.LeftModule<A, L>) => (s: LeftModuleSymbol, l: L, a: A) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getLeftModuleReversePolishInfix: <L, A>(L: TC.LeftModule<A, L>) => (a: L, b: A, s: ".*") => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getLeftModuleInfix: <L, A>(L: TC.LeftModule<A, L>) => (a: L, s: ".*", b: A) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getRightModulePolishInfix: <R, A>(L: TC.RightModule<A, R>) => (s: RightModuleSymbol, a: A, r: R) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getRightModuleReversePolishInfix: <R, A>(L: TC.RightModule<A, R>) => (a: A, b: R, s: "*.") => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getRightModuleInfix: <L, A>(L: TC.LeftModule<A, L>) => (a: L, s: ".*", b: A) => A;
//# sourceMappingURL=infix.d.ts.map