Merge branch 'better_set2' into better_set

Author: rafaqz

Project.toml

@@ -1,7 +1,7 @@
 name = "DimensionalData"
 uuid = "0703355e-b756-11e9-17c0-8b28908087d0"
 authors = ["Rafael Schouten <rafaelschouten@gmail.com>"]
-version = "0.29.12"
+version = "0.29.13"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"

docs/src/api/reference.md

@@ -69,6 +69,7 @@ For transforming DimensionalData objects:
 
 ```@docs
 groupby
+combine
 DimensionalData.DimGroupByArray
 Bins
 ranges

src/DimensionalData.jl

@@ -41,7 +41,7 @@ using .Dimensions: StandardIndices, DimOrDimType, DimTuple, DimTupleOrEmpty, Dim
 import .Dimensions: dims, refdims, name, lookup, kw2dims, hasdim, label, checkaxes, _astuple
 
 import .Lookups: Safety, Safe, Unsafe, SelectorOrInterval, Begin, End
-import .Lookups: metadata, reorder, set, _set, rebuild, basetypeof, 
+import .Lookups: metadata, reorder, set, unsafe_set, _set, rebuild, basetypeof, 
     order, span, sampling, locus, val, index, bounds, intervalbounds,
     hasselection, units
 
@@ -87,7 +87,7 @@ export dimnum, hasdim, hasselection, otherdims
 export set, rebuild, reorder, modify, broadcast_dims, broadcast_dims!,
     mergedims, unmergedims, maplayers
 
-export groupby, seasons, months, hours, intervals, ranges
+export groupby, combine, seasons, months, hours, intervals, ranges
 
 
 export @d
@@ -120,6 +120,7 @@ include("tables.jl")
 include("plotrecipes.jl")
 include("utils.jl")
 include("set.jl")
+include("opaque.jl")
 include("groupby.jl")
 include("precompile.jl")
 include("interface_tests.jl")

src/Dimensions/dimension.jl

@@ -277,6 +277,7 @@ Base.axes(d::Dimension, i) = axes(d)[i]
 Base.eachindex(d::Dimension) = eachindex(val(d))
 Base.length(d::Dimension) = length(val(d))
 Base.ndims(d::Dimension) = 0
+Base.parentindices(d::Dimension{<:AbstractArray}) = parentindices(parent(d))
 Base.ndims(d::Dimension{<:AbstractArray}) = ndims(val(d))
 Base.iterate(d::Dimension{<:AbstractArray}, args...) = iterate(lookup(d), args...)
 Base.first(d::Dimension) = val(d)

src/Dimensions/primitives.jl

@@ -211,20 +211,25 @@ julia> dimnum(A, Y)
 ```
 """
 function dimnum end
-@inline function dimnum(x, q1, query...)
-    all(hasdim(x, q1, query...)) || _extradimserror(otherdims(x, (q1, query...)))
-    _dim_query(_dimnum, MaybeFirst(), x, q1, query...)
+@inline function dimnum(x, query::Tuple)
+    all(hasdim(x, query)) || _extradimserror(otherdims(x, query))
+    _dim_query(_dimnum, MaybeFirst(), x, query...)
 end
+@inline dimnum(x, q1::Union{DimOrDimType,Integer}, query::Union{DimOrDimType,Integer}...) =
+   dimnum(x, (q1, query...))
 @inline dimnum(x, query::Function) =
     _dim_query(_dimnum, MaybeFirst(), x, query)
+@inline dimnum(x, q1, query...) =
+    throw(ArgumentError("`dimnum` accepts Dimensions, Symbols, Integers or any of these in a Tuple, or a predicate, function. not $((q1, query...))."))
 
-@inline _dimnum(f::Function, ds::Tuple, query::Tuple{Vararg{Int}}) = query
+@inline _dimnum(f::Function, ds::Tuple, query::Tuple{Vararg{Integer}}) = query
 @inline function _dimnum(f::Function, ds::Tuple, query::Tuple)
     numbered = map(ds, ntuple(identity, length(ds))) do d, i
         rebuild(d, i)
     end
     map(val, _dims(f, numbered, query))
 end
+_dimnum(f::Function, ds::Tuple) = ()
 
 """
     hasdim([f], x, query::Tuple) => NTuple{Bool}

src/Dimensions/set.jl

@@ -13,7 +13,7 @@ unsafe_set(dims::DimTuple, a1::Union{Dimension,Pair}, a2::Union{Dimension,Pair},
     _set(Unsafe(), dims, a1, a2, args...)
 
 _set(s::Safety, dims::DimTuple, l::LookupSetters) =
-    _set(s, dims, map(d -> basedims(d) => l, dims)...)
+    _set(s, dims, map(d -> rebuild(d, l), dims)...)
 
 # Convert pairs to wrapped dims and set
 _set(s::Safety, dims::DimTuple, p::Pair, ps::Pair...) =
@@ -40,9 +40,10 @@ end
 # Set things wrapped in dims
 _set(s::Safety, dim::Dimension, wrapper::Dimension{<:DimSetters}) = begin
     rewrapped = _set(s, dim, basetypeof(wrapper))
-    x = _set(s, rewrapped, val(wrapper))
-    x
+    _set(s, rewrapped, val(wrapper))
 end
+_set(s::Safety, dim::Dimension, l::Union{Lookup,LookupSetters}) =
+    rebuild(dim, _set(s, val(dim), l))
 # Set the dim, checking the lookup
 _set(s::Safety, dim::Dimension, newdim::Dimension) =
     _set(s, newdim, _set(s, val(dim), val(newdim)))
@@ -61,6 +62,9 @@ _set(::Safety, ::Nothing, x::Dimension) = x
 _set(::Safety, ::Nothing, ::Nothing) = nothing
 _set(::Safety, x, ::Nothing) = x
 _set(::Safety, ::Nothing, x) = x
+# For ambiguity
+_set(::Safety, dims::DimTuple, ::Nothing) = dims
+_set(::Safety, dims::Lookup, ::Nothing) = dims
 
 @noinline _wrongdimserr(dims, w) =
     throw(ArgumentError("dim $(basetypeof(w))) not in $(map(basetypeof, dims))"))

src/Lookups/Lookups.jl

@@ -59,17 +59,15 @@ export Unaligned, Transformed, ArrayLookup
 # Deprecated
 export LookupArray
 
-const StandardIndices = Union{AbstractArray{<:Integer},Colon,Integer,CartesianIndex,CartesianIndices}
-
 # As much as possible keyword rebuild is automatic
 rebuild(x; kw...) = ConstructionBase.setproperties(x, (; kw...))
 
-include("metadata.jl")
 include("lookup_traits.jl")
+include("metadata.jl")
 include("lookup_arrays.jl")
+include("beginend.jl")
 include("predicates.jl")
 include("selector.jl")
-include("beginend.jl")
 include("indexing.jl")
 include("methods.jl")
 include("utils.jl")

src/Lookups/beginend.jl

@@ -45,6 +45,8 @@ Base.to_indices(A, inds, (r, args...)::Tuple{<:Union{Begin,End,<:LazyMath},Varar
 _to_index(inds, a::Int) = a
 _to_index(inds, ::Begin) = first(inds)
 _to_index(inds, ::End) = last(inds)
+_to_index(inds, ::Type{Begin}) = first(inds)
+_to_index(inds, ::Type{End}) = last(inds)
 _to_index(inds, l::LazyMath{End}) = l.f(last(inds))
 _to_index(inds, l::LazyMath{Begin}) = l.f(first(inds))
 

src/Lookups/lookup_arrays.jl

@@ -32,6 +32,7 @@ Base.first(l::Lookup) = first(parent(l))
 Base.last(l::Lookup) = last(parent(l))
 Base.firstindex(l::Lookup) = firstindex(parent(l))
 Base.lastindex(l::Lookup) = lastindex(parent(l))
+Base.parentindices(l::Lookup) = parentindices(parent(l))
 function Base.:(==)(l1::Lookup, l2::Lookup)
     basetypeof(l1) == basetypeof(l2) && parent(l1) == parent(l2)
 end
@@ -159,11 +160,10 @@ NoLookup() = NoLookup(AutoValues())
 rebuild(l::NoLookup; data=parent(l), kw...) = NoLookup(data)
 
 # Used in @d broadcasts
-struct Length1NoLookup <: AbstractNoLookup end
-Length1NoLookup(::AbstractVector) = Length1NoLookup()
-
-rebuild(l::Length1NoLookup; kw...) = Length1NoLookup()
-Base.parent(::Length1NoLookup) = Base.OneTo(1)
+struct Length1NoLookup{A<:AbstractUnitRange} <: AbstractNoLookup 
+    data::A
+end
+Length1NoLookup() = Length1NoLookup(Base.OneTo(1))
 
 """
     AbstractSampled <: Aligned
@@ -468,7 +468,7 @@ abstract type AbstractCategorical{T,O} <: Aligned{T,O} end
 order(lookup::AbstractCategorical) = lookup.order
 metadata(lookup::AbstractCategorical) = lookup.metadata
 
-const CategoricalEltypes = Union{AbstractChar,Symbol,AbstractString}
+const CategoricalEltypes = Union{AbstractChar,Symbol,AbstractString,DataType}
 
 function Adapt.adapt_structure(to, l::AbstractCategorical)
     rebuild(l; data=Adapt.adapt(to, parent(l)), metadata=NoMetadata())
@@ -866,6 +866,7 @@ promote_first(x1, x2, xs...) =
 # Fallback NoLookup if not identical type
 promote_first(l1::Lookup) = l1
 promote_first(l1::L, ls::L...) where L<:Lookup = rebuild(l1; metadata=NoMetadata)
+promote_first(l1::L, ls::L...) where L<:AbstractNoLookup = l1
 function promote_first(l1::Lookup, ls1::Lookup...)
     ls = _remove(Length1NoLookup, l1, ls1...)
     if length(ls) != length(ls1) + 1

src/Lookups/selector.jl

@@ -1,3 +1,12 @@
+const StandardIndices = Union{
+    AbstractArray{<:Integer},
+    Colon,
+    Integer,
+    CartesianIndex,
+    CartesianIndices,
+    BeginEndRange,
+}
+
 struct SelectorError{L,S} <: Exception
     lookup::L
     selector::S