Optimize zero(FD{T,f}): implement via reinterpret not convert. (#46)

* Optimize zero(FD{T,f}): reinterpret not convert.

I also noticed, though, that reinterpret() is still not fully
const-folding. It often folds away in simple constructions, but inside
complex expressions it isn't.

I fixed this by marking both `reinterpret` and `max_exp10` as `Base.@pure`.

* Add comment explaining motivation for `Base.zero(FD)`

* Spacing fix in src/FixedPointDecimals.jl

Co-Authored-By: NHDaly <NHDaly@gmail.com>

* Also optimize `Base.one` to fully const-fold.

- Add definition for Base.one(::Type{FD{T,f}})
- Mark coefficient(::Type{FD{T,f}}) as `Base.@pure` as well.

* Update comment for coefficient being `@pure`

Author: NHDaly

src/FixedPointDecimals.jl

@@ -85,7 +85,8 @@ struct FixedDecimal{T <: Integer, f} <: Real
     i::T
 
     # inner constructor
-    function Base.reinterpret(::Type{FixedDecimal{T, f}}, i::Integer) where {T, f}
+    # This function is marked as `Base.@pure`. It does not have or depend on any side-effects.
+    Base.@pure function Base.reinterpret(::Type{FixedDecimal{T, f}}, i::Integer) where {T, f}
         n = max_exp10(T)
         if f >= 0 && (n < 0 || f <= n)
             new{T, f}(i % T)
@@ -335,6 +336,10 @@ Base.@pure function promote_rule(::Type{FD{T, f}}, ::Type{FD{U, g}}) where {T, f
     FD{promote_type(T, U), max(f, g)}
 end
 
+# The default `zero` and `one` call `convert`, which is expensive, so we call reinterpret.
+Base.zero(::Type{FD{T, f}}) where {T, f} = reinterpret(FD{T, f}, zero(T))
+Base.one(::Type{FD{T, f}}) where {T, f} = reinterpret(FD{T, f}, coefficient(FD{T, f}))
+
 # comparison
 ==(x::T, y::T) where {T <: FD} = x.i == y.i
  <(x::T, y::T) where {T <: FD} = x.i  < y.i
@@ -464,7 +469,11 @@ end
 The highest value of `x` which does not result in an overflow when evaluating `T(10)^x`. For
 types of `T` that do not overflow -1 will be returned.
 """
-function max_exp10(::Type{T}) where {T <: Integer}
+Base.@pure function max_exp10(::Type{T}) where {T <: Integer}
+    # This function is marked as `Base.@pure`. Even though it does call some generic
+    # functions, they are all simple methods that should be able to be evaluated as
+    # constants. This function does not have or depend on any side-effects.
+
     W = widen(T)
     type_max = W(typemax(T))
 
@@ -485,14 +494,16 @@ max_exp10(::Type{BigInt}) = -1
 # optimized away by the compiler during const-folding.
 @eval max_exp10(::Type{Int128}) = $(max_exp10(Int128))
 
+# coefficient is marked pure. This is needed to ensure that the result is always available
+# at compile time, and can therefore be used when optimizing mathematical operations.
 """
     coefficient(::Type{FD{T, f}}) -> T
 
 Compute `10^f` as an Integer without overflow. Note that overflow will not occur for any
 constructable `FD{T, f}`.
 """
-coefficient(::Type{FD{T, f}}) where {T, f} = T(10)^f
-coefficient(fd::FD{T, f}) where {T, f} = coefficient(FD{T, f})
+Base.@pure coefficient(::Type{FD{T, f}}) where {T, f} = T(10)^f
+Base.@pure coefficient(fd::FD{T, f}) where {T, f} = coefficient(FD{T, f})
 value(fd::FD) = fd.i
 
 # for generic hashing