typomath/README.md

# typomath

Proof of concepts for a PocoMath-adjacent approach to a possible math.ts (TypeScript analogue of mathjs)

Roadmap:

1. Install over.ts and get an example of add with number and bigint implementations working with it. [DONE]
2. Use the builder pattern to get add working with its implmentations defined incrementally before producing the final overload. [Didn't quite work the way we wnated, but maybe we can do an alternative later.]
3. Make a version of over.ts, call it util/overload.ts, that takes an array of implementations without redundant type annotation. [DONE]
4. Improve that version of overload with rtti to select the implementation without the implementations having to throw errors. [DONE]
5. Use the builder pattern to get a single object with both an add and a negate method, with both defined incrementally, working. [DONE]
4. Incorporate a subtract method that works on numbers and bigint by separate definitions but with dependencies on add and negate.
5. Incorporate a subtract method that works with one generic implementation that works for both number and bigint with dependencies on add and negate.
5. Attempt to eliminate redundant specification of implementation signatures.
6. Incorporate multi-argument reducing implementation of add.
7. Actually split into multiple source files to make sure that works.
8. Add a template Complex type with add and subtract.
9. Define a sqrt method that depends on a literal constant non-mutable config object that has to be set before loading sqrt, but with two different imports that use different settings for the config.
10. Add a NumInt type to the existing methods. For reference in the case of positive numbers: https://stackoverflow.com/questions/71670965/how-do-i-assert-a-number-type-is-positive. One can make a similar template for integers, esp. using `${bigint}` in a template literal. But as the comments point out, this doesn't work for computed arguments, only literals. (I think there was a package or repository or other library of lots of such examples, but now I can't find it :-( but anyhow...). So I am not really sure how a type that can't really be precisely represented in TypeScript is going to work out in this approach... Maybe there is a way to automatically combine branded types with type guards. Check out newtype-ts, it has a type library with a bunch of branded types.

If we get that far, then math.ts is probably feasible.
Initial commit 2022-09-04 02:53:08 +00:00			`# typomath`

doc: Add a roadmap to the README 2022-09-06 21:28:43 +00:00			`Proof of concepts for a PocoMath-adjacent approach to a possible math.ts (TypeScript analogue of mathjs)`

			`Roadmap:`

feat: New array-style overloading Step two didn't work so well, so this is actually step three. Avoids too much redundant type information. 2022-09-25 14:39:16 +00:00			`1. Install over.ts and get an example of add with number and bigint implementations working with it. [DONE]`
			`2. Use the builder pattern to get add working with its implmentations defined incrementally before producing the final overload. [Didn't quite work the way we wnated, but maybe we can do an alternative later.]`
			`3. Make a version of over.ts, call it util/overload.ts, that takes an array of implementations without redundant type annotation. [DONE]`
feat(overload): Use typescript-rtti to select implementations (#4) Note that the changes to module resolution cause steps one and two no longer to run because node can't find the imports, although they still compile fine. Co-authored-by: Glen Whitney <glen@studioinfinity.org> Reviewed-on: https://code.studioinfinity.org/glen/typomath/pulls/4 2022-09-25 20:02:01 +00:00			`4. Improve that version of overload with rtti to select the implementation without the implementations having to throw errors. [DONE]`
feat: Incremental building and simultaneous overloading of object values So we can start with literal objects whose keys are operator names, and whose values are arrays of implementations, and merge them, and then replace every value with the overloaded function it specifies. 2022-09-26 05:36:25 +00:00			`5. Use the builder pattern to get a single object with both an add and a negate method, with both defined incrementally, working. [DONE]`
doc: Add an intermediate step in roadmap Separates adding dependencies to overloads into its own step, as it is likely to be a major task. 2022-09-07 00:24:29 +00:00			`4. Incorporate a subtract method that works on numbers and bigint by separate definitions but with dependencies on add and negate.`
			`5. Incorporate a subtract method that works with one generic implementation that works for both number and bigint with dependencies on add and negate.`
doc: Add a roadmap to the README 2022-09-06 21:28:43 +00:00			`5. Attempt to eliminate redundant specification of implementation signatures.`
			`6. Incorporate multi-argument reducing implementation of add.`
			`7. Actually split into multiple source files to make sure that works.`
			`8. Add a template Complex type with add and subtract.`
			`9. Define a sqrt method that depends on a literal constant non-mutable config object that has to be set before loading sqrt, but with two different imports that use different settings for the config.`
			10. Add a NumInt type to the existing methods. For reference in the case of positive numbers: https://stackoverflow.com/questions/71670965/how-do-i-assert-a-number-type-is-positive. One can make a similar template for integers, esp. using `${bigint}` in a template literal. But as the comments point out, this doesn't work for computed arguments, only literals. (I think there was a package or repository or other library of lots of such examples, but now I can't find it :-( but anyhow...). So I am not really sure how a type that can't really be precisely represented in TypeScript is going to work out in this approach... Maybe there is a way to automatically combine branded types with type guards. Check out newtype-ts, it has a type library with a bunch of branded types.

			`If we get that far, then math.ts is probably feasible.`