Addition/subtraction for some AnchoredIntervals produces unexpected results

[spurll]

Arithmetic involving an AnchoredInterval{P, T} when P isa Period runs afoul of the rounding code in the constructor, producing counterintuitive results:

julia> he = HourEnding(now())
HourEnding{DateTime}(2018-02-28T18:00:00, Inclusivity(false, true))

julia> he - Minute(30)
HourEnding{DateTime}(2018-02-28T18:00:00, Inclusivity(false, true))

julia> he + Minute(30)
HourEnding{DateTime}(2018-02-28T19:00:00, Inclusivity(false, true))

Rounding will have to be removed from the AnchoredInterval{P, T} constructor to resolve this issue, but it is nice being able to call HourEnding(now()) without having to explicitly round now() to the nearest hour.

Of the many possible solutions @omus and I have considered, two seem most promising:

1. HourEnding{T} remains a type alias for AnchoredInterval{Hour(-1), T}, but only the HourEnding constructor will perform the rounding operation
   • This means that HourEnding{DateTime}(now()) will not be rounded (as it's just an alias for AnchoredInterval{Hour(-1), DateTime}), which may lead to confusion
2. HourEnding and AnchoredInterval both become subtypes of a new AbstractAnchoredInterval (Curt has suggested SpanInterval as a replacement name)
   • This doesn't sit particularly well with me because, aside from the rounding that happens in the constructor, the functionality will be identical

Either way, I'll have to fix the way string(::AnchoredInterval{P, T}) works, because currently it assumes that everything will be rounded when T <: TimeType.

[spurll]

My plan is to proceed with solution 1 for now, and consider 2 in the future.

[omus]

This means that HourEnding{DateTime}(now()) will not be rounded (as it's just an alias for AnchoredInterval{Hour(-1), DateTime}), which may lead to confusion

One way to support HourEnding{DateTime}(now()) to be rounded while having AnchoredInterval{Hour(-1), DateTime}) not be rounded while still using type aliases would be to introduce an additional type parameter.

MWE:

using Base.Dates
using Base.Dates: TimeType
const AbstractDateTime = TimeType

struct AnchoredInterval{P, T, R}
    anchor::T
end

AnchoredInterval{P, T}(i::T) where {P, T} = AnchoredInterval{P, T, false}(i)

const HourEnding{T} = AnchoredInterval{Hour(-1), T, true} where T <: AbstractDateTime
HourEnding{T}(i::T) where T <: AbstractDateTime = invoke(HourEnding{T}, Tuple{Any}, ceil(i, Hour))

HourEnding{DateTime}(now())
AnchoredInterval{Hour(-1), DateTime}(now())

[omus]

I think I would prefer option 2 however.

[spurll]

It seems to me that the third type parameter is likely to cause a lot of confusion.

How do you feel about something like:

AbstractInterval{T} (abstract)
↳ Interval{T} (concrete)
↳ AbstractAnchoredInterval{P, T} (abstract)
  ↳ AnchoredInterval{P, T} (concrete)
  ↳ RoundedAnchoredInterval{P, T} (concrete)
    ↳ HourEnding{T} (type alias for RoundedAnchoredInterval{Hour(-1), T})
    ↳ HourBeginning{T} (type alias for RoundedAnchoredInterval{Hour(1), T})

Names subject to change, of course.

[omus]

I like that proposal. My only issue is that I think AbstractAnchoredInterval will be used allot and it a little long.