Separation of Decimal and Context

[jayd3e]

What's the reasoning for the separation of Decimal and Context? Whenever I use a decimal type, I tend to need to use an arithmetic operation on it. Having to define a context, my relevant decimal objects, and determine a precision for the operation each time I need to calculate a value is a bit unwieldy. On the note of precision, I usually want the most precise value during a series of operations and then I will round at the end of the series. Having to determine a precision for each operation is not ideal in that case, as it may result in a loss of precision at one of the steps in the series.

[maddyblue]

You say:

I usually want the most precise value during a series of operations and then I will round at the end of the series

So let's do that example. Say we are attempting to compute 1 + 2 / 3 with 5 digits of precision, using the above proposal. We start with the 2 / 3, so you run a division. But 2 / 3 produces a result with a repeating decimal, so its most precise value is an infinite number of digits long. Clearly we cannot represent that, and so we must instead choose some precision at which to perform the operation, and thus the proposal as worded there can't work in the general case.

You could argue that apd can just choose a high-enough precision so the end result will be within some error bound, but that would require apd to understand entire computations and be able to determine how precise the end result would be based, and then compute the desired precision from that. This to me sounds incredibly complicated (especially considering we support sqrt, ln, exp, etc.). Until then we just require users to specify precision.

Contrast this to other projects where the precision is a global variable (and thus unsafe to change during concurrent operations):
https://github.com/shopspring/decimal/blob/aed1bfe463fa3c9cc268d60dcc1491db613bff7e/decimal.go#L45
or a global const, making it not possible to configure:
https://github.com/ericlagergren/decimal/blob/522450d1e655d86ef13b0bfad42d090a0240ce03/const.go#L19

All of the decimal packages must have this precision specified. Some just hide it from the user more than apd.

You can use apd.BaseContext, which is a 0-precision context, and will thus provide exact operations where possible, and error on any operation that requires a precision (like division, or any more complicated operation that uses division underneath). Or just use apd.BaseContext.WithPrecision(20) like we do for most stuff and that's pretty good.

Also see python, which has a really similar API as apd, and requires precision to be specified: https://docs.python.org/2/library/decimal.html