####
2.4 KiB

2.4 KiB

# typomath

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

Roadmap:

- Install over.ts and get an example of add with number and bigint implementations working with it. [DONE]
- 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.]
- Make a version of over.ts, call it util/overload.ts, that takes an array of implementations without redundant type annotation. [DONE]
- Improve that version of overload with rtti to select the implementation without the implementations having to throw errors. [DONE]
- Use the builder pattern to get a single object with both an add and a negate method, with both defined incrementally, working. [DONE]
- Incorporate a subtract method that works on numbers and bigint by separate definitions but with dependencies on add and negate.
- Incorporate a subtract method that works with one generic implementation that works for both number and bigint with dependencies on add and negate.
- Attempt to eliminate redundant specification of implementation signatures.
- Incorporate multi-argument reducing implementation of add.
- Actually split into multiple source files to make sure that works.
- Add a template Complex type with add and subtract.
- 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.
- 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.