@toolproof-core/genesis 1.0.50 → 1.0.52

package/src/implementations/tools.ts

@@ -1,214 +1,214 @@
-import type {
-    Boolean,
-    Natural,
-    ResourceType,
-    Tool,
-} from '../../generated-src/types/types.js';
-
-type GenericAssignmentByRoleName<GenericRoleName extends string> = Record<GenericRoleName, ResourceType>;
-
-type InstantiationToolHandleBySpecializationKey = Record<string, Tool>;
-
-type TemplateInputs<GenericRoleName extends string> = {
-    GenericAssignmentByRoleName: GenericAssignmentByRoleName<GenericRoleName>;
-    InstantiationToolHandleBySpecializationKey: InstantiationToolHandleBySpecializationKey;
-};
-
-type TemplateOutputs = {
-    InstantiationTool: Tool;
-};
-
-type OperandTemplateInputs = TemplateInputs<'OperandType'>;
-
-const OPERAND_TYPE_ROLE_NAMES = ['OperandType'] as const;
-
-function assertExactKeys(actualKeys: string[], expectedKeys: readonly string[], label: string): void {
-    const sortedActualKeys = [...actualKeys].sort();
-    const sortedExpectedKeys = [...expectedKeys].sort();
-
-    if (sortedActualKeys.length !== sortedExpectedKeys.length) {
-        throw new Error(
-            `${label} must contain exactly [${sortedExpectedKeys.join(', ')}], got [${sortedActualKeys.join(', ')}]`
-        );
-    }
-
-    for (let index = 0; index < sortedExpectedKeys.length; index += 1) {
-        if (sortedActualKeys[index] !== sortedExpectedKeys[index]) {
-            throw new Error(
-                `${label} must contain exactly [${sortedExpectedKeys.join(', ')}], got [${sortedActualKeys.join(', ')}]`
-            );
-        }
-    }
-}
-
-function asNatural(value: number, label: string): Natural {
-    if (!Number.isInteger(value) || value < 0) {
-        throw new Error(`${label} must be a non-negative integer, got ${value}`);
-    }
-
-    return value as Natural;
-}
-
-export function createSpecializationKey(assignments: Record<string, ResourceType>): string {
-    return JSON.stringify(
-        Object.entries(assignments)
-            .sort(([leftRoleName], [rightRoleName]) => leftRoleName.localeCompare(rightRoleName))
-            .map(([roleName, resourceType]) => [roleName, resourceType.handle])
-    );
-}
-
-function resolveTemplateInstantiation<GenericRoleName extends string>(
-    inputs: TemplateInputs<GenericRoleName>,
-    expectedGenericRoleNames: readonly GenericRoleName[]
-): TemplateOutputs {
-    const { GenericAssignmentByRoleName, InstantiationToolHandleBySpecializationKey } = inputs;
-
-    assertExactKeys(
-        Object.keys(GenericAssignmentByRoleName),
-        expectedGenericRoleNames,
-        'GenericAssignmentByRoleName'
-    );
-
-    const specializationKey = createSpecializationKey(GenericAssignmentByRoleName);
-    const instantiationTool = InstantiationToolHandleBySpecializationKey[specializationKey];
-
-    if (!instantiationTool) {
-        throw new Error(`No instantiation tool registered for specializationKey ${specializationKey}`);
-    }
-
-    return {
-        InstantiationTool: instantiationTool,
-    };
-}
-
-export function Identity(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Add(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Subtract(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Multiply(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Divide(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function Double(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function LessThan(inputs: OperandTemplateInputs): TemplateOutputs {
-    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
-}
-
-export function BooleanIdentity(inputs: { In: Boolean }): { Out: Boolean } {
-    return {
-        Out: inputs.In,
-    };
-}
-
-export function NaturalIdentity(inputs: { In: Natural }): { Out: Natural } {
-    return {
-        Out: inputs.In,
-    };
-}
-
-export function NaturalLessThan(inputs: {
-    LessThanSource: Natural;
-    LessThanTarget: Natural;
-}): { LessThanDecision: Boolean } {
-    return {
-        LessThanDecision: inputs.LessThanSource < inputs.LessThanTarget,
-    };
-}
-
-export function NaturalAdd(inputs: {
-    AddendOne: Natural;
-    AddendTwo: Natural;
-}): { Sum: Natural } {
-    return {
-        Sum: asNatural(inputs.AddendOne + inputs.AddendTwo, 'Sum'),
-    };
-}
-
-export function NaturalSubtract(inputs: {
-    Minuend: Natural;
-    Subtrahend: Natural;
-}): { Difference: Natural } {
-    return {
-        Difference: asNatural(inputs.Minuend - inputs.Subtrahend, 'Difference'),
-    };
-}
-
-export function NaturalMultiply(inputs: {
-    Multiplicand: Natural;
-    Multiplier: Natural;
-}): { Product: Natural } {
-    return {
-        Product: asNatural(inputs.Multiplicand * inputs.Multiplier, 'Product'),
-    };
-}
-
-export function NaturalDivide(inputs: {
-    Dividend: Natural;
-    Divisor: Natural;
-}): { Quotient: Natural; Remainder: Natural } {
-    if (inputs.Divisor === 0) {
-        throw new Error('Divisor must be non-zero');
-    }
-
-    return {
-        Quotient: asNatural(Math.floor(inputs.Dividend / inputs.Divisor), 'Quotient'),
-        Remainder: asNatural(inputs.Dividend % inputs.Divisor, 'Remainder'),
-    };
-}
-
-export function NaturalDouble(inputs: { N: Natural }): { Doubled: Natural } {
-    return {
-        Doubled: asNatural(inputs.N * 2, 'Doubled'),
-    };
-}
-
-export const TOOL_IMPLEMENTATION_BY_NAME = {
-    Identity,
-    Add,
-    Subtract,
-    Multiply,
-    Divide,
-    Double,
-    LessThan,
-    BooleanIdentity,
-    NaturalIdentity,
-    NaturalLessThan,
-    NaturalAdd,
-    NaturalSubtract,
-    NaturalMultiply,
-    NaturalDivide,
-    NaturalDouble,
-} as const;
-
-export const TOOL_IMPLEMENTATION_BY_HANDLE = {
-    'TOOL-Identity': Identity,
-    'TOOL-Add': Add,
-    'TOOL-Subtract': Subtract,
-    'TOOL-Multiply': Multiply,
-    'TOOL-Divide': Divide,
-    'TOOL-Double': Double,
-    'TOOL-LessThan': LessThan,
-    'TOOL-BooleanIdentity': BooleanIdentity,
-    'TOOL-NaturalIdentity': NaturalIdentity,
-    'TOOL-NaturalLessThan': NaturalLessThan,
-    'TOOL-NaturalAdd': NaturalAdd,
-    'TOOL-NaturalSubtract': NaturalSubtract,
-    'TOOL-NaturalMultiply': NaturalMultiply,
-    'TOOL-NaturalDivide': NaturalDivide,
-    'TOOL-NaturalDouble': NaturalDouble,
-} as const;
+import type {
+    Boolean,
+    Natural,
+    ResourceType,
+    Tool,
+} from '../../generated-src/types/types.js';
+
+type GenericAssignmentByRoleName<GenericRoleName extends string> = Record<GenericRoleName, ResourceType>;
+
+type InstantiationToolHandleBySpecializationKey = Record<string, Tool>;
+
+type TemplateInputs<GenericRoleName extends string> = {
+    GenericAssignmentByRoleName: GenericAssignmentByRoleName<GenericRoleName>;
+    InstantiationToolHandleBySpecializationKey: InstantiationToolHandleBySpecializationKey;
+};
+
+type TemplateOutputs = {
+    InstantiationTool: Tool;
+};
+
+type OperandTemplateInputs = TemplateInputs<'OperandType'>;
+
+const OPERAND_TYPE_ROLE_NAMES = ['OperandType'] as const;
+
+function assertExactKeys(actualKeys: string[], expectedKeys: readonly string[], label: string): void {
+    const sortedActualKeys = [...actualKeys].sort();
+    const sortedExpectedKeys = [...expectedKeys].sort();
+
+    if (sortedActualKeys.length !== sortedExpectedKeys.length) {
+        throw new Error(
+            `${label} must contain exactly [${sortedExpectedKeys.join(', ')}], got [${sortedActualKeys.join(', ')}]`
+        );
+    }
+
+    for (let index = 0; index < sortedExpectedKeys.length; index += 1) {
+        if (sortedActualKeys[index] !== sortedExpectedKeys[index]) {
+            throw new Error(
+                `${label} must contain exactly [${sortedExpectedKeys.join(', ')}], got [${sortedActualKeys.join(', ')}]`
+            );
+        }
+    }
+}
+
+function asNatural(value: number, label: string): Natural {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative integer, got ${value}`);
+    }
+
+    return value as Natural;
+}
+
+export function createSpecializationKey(assignments: Record<string, ResourceType>): string {
+    return JSON.stringify(
+        Object.entries(assignments)
+            .sort(([leftRoleName], [rightRoleName]) => leftRoleName.localeCompare(rightRoleName))
+            .map(([roleName, resourceType]) => [roleName, resourceType.handle])
+    );
+}
+
+function resolveTemplateInstantiation<GenericRoleName extends string>(
+    inputs: TemplateInputs<GenericRoleName>,
+    expectedGenericRoleNames: readonly GenericRoleName[]
+): TemplateOutputs {
+    const { GenericAssignmentByRoleName, InstantiationToolHandleBySpecializationKey } = inputs;
+
+    assertExactKeys(
+        Object.keys(GenericAssignmentByRoleName),
+        expectedGenericRoleNames,
+        'GenericAssignmentByRoleName'
+    );
+
+    const specializationKey = createSpecializationKey(GenericAssignmentByRoleName);
+    const instantiationTool = InstantiationToolHandleBySpecializationKey[specializationKey];
+
+    if (!instantiationTool) {
+        throw new Error(`No instantiation tool registered for specializationKey ${specializationKey}`);
+    }
+
+    return {
+        InstantiationTool: instantiationTool,
+    };
+}
+
+export function Identity(inputs: OperandTemplateInputs): TemplateOutputs {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+
+export function Add(inputs: OperandTemplateInputs): TemplateOutputs {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+
+export function Subtract(inputs: OperandTemplateInputs): TemplateOutputs {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+
+export function Multiply(inputs: OperandTemplateInputs): TemplateOutputs {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+
+export function Divide(inputs: OperandTemplateInputs): TemplateOutputs {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+
+export function Double(inputs: OperandTemplateInputs): TemplateOutputs {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+
+export function LessThan(inputs: OperandTemplateInputs): TemplateOutputs {
+    return resolveTemplateInstantiation(inputs, OPERAND_TYPE_ROLE_NAMES);
+}
+
+export function BooleanIdentity(inputs: { In: Boolean }): { Out: Boolean } {
+    return {
+        Out: inputs.In,
+    };
+}
+
+export function NaturalIdentity(inputs: { In: Natural }): { Out: Natural } {
+    return {
+        Out: inputs.In,
+    };
+}
+
+export function NaturalLessThan(inputs: {
+    LessThanSource: Natural;
+    LessThanTarget: Natural;
+}): { LessThanDecision: Boolean } {
+    return {
+        LessThanDecision: inputs.LessThanSource < inputs.LessThanTarget,
+    };
+}
+
+export function NaturalAdd(inputs: {
+    AddendOne: Natural;
+    AddendTwo: Natural;
+}): { Sum: Natural } {
+    return {
+        Sum: asNatural(inputs.AddendOne + inputs.AddendTwo, 'Sum'),
+    };
+}
+
+export function NaturalSubtract(inputs: {
+    Minuend: Natural;
+    Subtrahend: Natural;
+}): { Difference: Natural } {
+    return {
+        Difference: asNatural(inputs.Minuend - inputs.Subtrahend, 'Difference'),
+    };
+}
+
+export function NaturalMultiply(inputs: {
+    Multiplicand: Natural;
+    Multiplier: Natural;
+}): { Product: Natural } {
+    return {
+        Product: asNatural(inputs.Multiplicand * inputs.Multiplier, 'Product'),
+    };
+}
+
+export function NaturalDivide(inputs: {
+    Dividend: Natural;
+    Divisor: Natural;
+}): { Quotient: Natural; Remainder: Natural } {
+    if (inputs.Divisor === 0) {
+        throw new Error('Divisor must be non-zero');
+    }
+
+    return {
+        Quotient: asNatural(Math.floor(inputs.Dividend / inputs.Divisor), 'Quotient'),
+        Remainder: asNatural(inputs.Dividend % inputs.Divisor, 'Remainder'),
+    };
+}
+
+export function NaturalDouble(inputs: { N: Natural }): { Doubled: Natural } {
+    return {
+        Doubled: asNatural(inputs.N * 2, 'Doubled'),
+    };
+}
+
+export const TOOL_IMPLEMENTATION_BY_NAME = {
+    Identity,
+    Add,
+    Subtract,
+    Multiply,
+    Divide,
+    Double,
+    LessThan,
+    BooleanIdentity,
+    NaturalIdentity,
+    NaturalLessThan,
+    NaturalAdd,
+    NaturalSubtract,
+    NaturalMultiply,
+    NaturalDivide,
+    NaturalDouble,
+} as const;
+
+export const TOOL_IMPLEMENTATION_BY_HANDLE = {
+    'TOOL-Identity': Identity,
+    'TOOL-Add': Add,
+    'TOOL-Subtract': Subtract,
+    'TOOL-Multiply': Multiply,
+    'TOOL-Divide': Divide,
+    'TOOL-Double': Double,
+    'TOOL-LessThan': LessThan,
+    'TOOL-BooleanIdentity': BooleanIdentity,
+    'TOOL-NaturalIdentity': NaturalIdentity,
+    'TOOL-NaturalLessThan': NaturalLessThan,
+    'TOOL-NaturalAdd': NaturalAdd,
+    'TOOL-NaturalSubtract': NaturalSubtract,
+    'TOOL-NaturalMultiply': NaturalMultiply,
+    'TOOL-NaturalDivide': NaturalDivide,
+    'TOOL-NaturalDouble': NaturalDouble,
+} as const;