From 1b9d6b64287cdc4629a774ebee0367cfe7a90cc1 Mon Sep 17 00:00:00 2001
From: Jos de Jong <wjosdejong@gmail.com>
Date: Wed, 4 Jan 2023 12:28:24 +0100
Subject: [PATCH] chore: use direct function definitions instead of `{ params,
 returns }`

---
 src/Complex/arithmetic.ts    |  4 ++--
 src/Complex/type.ts          |  2 +-
 src/interfaces/arithmetic.ts | 27 +++++++++++----------------
 src/interfaces/predicate.ts  |  7 ++++---
 src/interfaces/relational.ts |  6 +++---
 src/interfaces/type.ts       | 13 ++++++-------
 6 files changed, 27 insertions(+), 32 deletions(-)

diff --git a/src/Complex/arithmetic.ts b/src/Complex/arithmetic.ts
index e11d91e..cc3d49b 100644
--- a/src/Complex/arithmetic.ts
+++ b/src/Complex/arithmetic.ts
@@ -9,8 +9,8 @@ declare module "../interfaces/type" {
       // after removing any `_...` suffixes; the following should be
       // additional dispatches for add and divide, not separate
       // operations, in the final mathjs bundle.
-      add_real:    {params: [T, RealType<T>], returns: T}
-      divide_real: {params: [T, RealType<T>], returns: T}
+      add_real:    (a: T, b: RealType<T>) => T
+      divide_real: (a: T, b: RealType<T>) => T
    }
 }
 
diff --git a/src/Complex/type.ts b/src/Complex/type.ts
index 43c79fe..50a1314 100644
--- a/src/Complex/type.ts
+++ b/src/Complex/type.ts
@@ -32,7 +32,7 @@ declare module "../interfaces/type" {
    }
 
    interface Signatures<T> {
-      complex: {params: [T] | [T,T], returns: Complex<T>}
+      complex: ((re: T) => Complex<T>) | ((re: T, im: T) => Complex<T>)
    }
 }
 
diff --git a/src/interfaces/arithmetic.ts b/src/interfaces/arithmetic.ts
index f77ceb1..df2d765 100644
--- a/src/interfaces/arithmetic.ts
+++ b/src/interfaces/arithmetic.ts
@@ -1,23 +1,18 @@
 import type {Complex} from '../Complex/type.js'
 import type {RealType} from './type.js'
 
-type UnaryOperator<T>  = {params: [T], returns: T}
-type BinaryOperator<T> = {params: [T, T], returns: T}
 declare module "./type" {
    interface Signatures<T> {
-      add:              BinaryOperator<T>
-      unaryMinus:       UnaryOperator<T>
-      conj:             UnaryOperator<T>
-      subtract:         BinaryOperator<T>
-      multiply:         BinaryOperator<T>
-      square:           UnaryOperator<T>
-      absquare:         {params: [T], returns: RealType<T>}
-      reciprocal:       UnaryOperator<T>
-      divide:           BinaryOperator<T>
-      conservativeSqrt: UnaryOperator<T>
-      sqrt: {
-         params: [T],
-         returns: T extends Complex<any> ? T : T | Complex<T>
-      }
+      add:              (a: T, b: T) => T
+      unaryMinus:       (a: T) => T
+      conj:             (a: T) => T
+      subtract:         (a: T, b: T) => T
+      multiply:         (a: T, b: T) => T
+      square:           (a: T) => T
+      absquare:         (a: T) => RealType<T>
+      reciprocal:       (a: T) => T
+      divide:           (a: T, b: T) => T
+      conservativeSqrt: (a: T) => T
+      sqrt: (a: T)=> T extends Complex<unknown> ? T : T | Complex<T>
    }
 }
diff --git a/src/interfaces/predicate.ts b/src/interfaces/predicate.ts
index b4c7393..93d3b4a 100644
--- a/src/interfaces/predicate.ts
+++ b/src/interfaces/predicate.ts
@@ -1,9 +1,10 @@
 // Warning: a module must have something besides just a "declare module"
 // section; otherwise it is ignored.
-export type UnaryPredicate<T> = {params: [T], returns: boolean}
+export type UnaryPredicate<T> = (a: T) => boolean
+
 declare module "./type" {
    interface Signatures<T> {
-      isReal:   UnaryPredicate<T>
-      isSquare: UnaryPredicate<T>
+      isReal:   (a: T) => boolean
+      isSquare: (a: T) => boolean
    }
 }
diff --git a/src/interfaces/relational.ts b/src/interfaces/relational.ts
index 9b511b0..e2aa3a1 100644
--- a/src/interfaces/relational.ts
+++ b/src/interfaces/relational.ts
@@ -1,9 +1,9 @@
 // Warning: a module must have something besides just a "declare module"
 // section; otherwise it is ignored.
-export type BinaryPredicate<T> = {params: [T, T], returns: boolean}
+export type BinaryPredicate<T> = (a: T, b: T) => T
 declare module "./type" {
    interface Signatures<T> {
-      equal:   BinaryPredicate<T>
-      unequal: BinaryPredicate<T>
+      equal:   (a: T, b: T) => boolean
+      unequal: (a: T, b: T) => boolean
    }
 }
diff --git a/src/interfaces/type.ts b/src/interfaces/type.ts
index 4596d7f..c68c98a 100644
--- a/src/interfaces/type.ts
+++ b/src/interfaces/type.ts
@@ -58,17 +58,16 @@ export type RealType<T> = ALookup<T, 'real'>
  * key 're' in the interface.
  ****/
 export interface Signatures<T> {
-   zero: {params: [T], returns: ZeroType<T>}
-   one:  {params: [T], returns: OneType<T>}
+   zero: (a: T) => ZeroType<T>
+   one:  (a: T) => OneType<T>
    // nan needs to be able to operate on its own output for everything
    // else to compile. That's why its parameter type is widened:
-   nan:  {params: [T | NaNType<T>], returns: NaNType<T>}
-   re:   {params: [T], returns: RealType<T>}
+   nan:  (a: T | NaNType<T>) => NaNType<T>
+   re:   (a: T) => RealType<T>
 }
 
 type SignatureKey = keyof Signatures<unknown>
 
-export type Returns<Name extends SignatureKey, T> = Signatures<T>[Name]['returns']
-export type Signature<Name extends SignatureKey, T> =
-   (...args: Signatures<T>[Name]['params']) => Returns<Name, T>
+export type Signature<Name extends SignatureKey, T> = Signatures<T>[Name]
+export type Returns<Name extends SignatureKey, T> = ReturnType<Signatures<T>[Name]>
 export type Dependencies<Name extends SignatureKey, T> = {[K in Name]: Signature<K, T>}