Rename Parallel to ParallelTableTransform (#138)

Author: juliohm

src/TableTransforms.jl

@@ -67,7 +67,5 @@ export
   PCA, DRS, SDS,
   RowTable,
   ColTable,
-  Sequential,
-  Parallel,
   →, ⊔
 end

src/transforms/parallel.jl

@@ -3,7 +3,7 @@
 # ------------------------------------------------------------------
 
 """
-    Parallel(transforms)
+    ParallelTableTransform(transforms)
 
 A transform where `transforms` are applied in parallel.
 
@@ -14,25 +14,25 @@ Scale(low=0.3, high=0.6) ⊔ EigenAnalysis(:VDV)
 ZScore() ⊔ EigenAnalysis(:V)
 ```
 """
-struct Parallel <: TableTransform
+struct ParallelTableTransform <: TableTransform
   transforms::Vector{TableTransform}
 end
 
 # AbstractTrees interface
-AbstractTrees.nodevalue(::Parallel) = Parallel
-AbstractTrees.children(p::Parallel) = p.transforms
+AbstractTrees.nodevalue(::ParallelTableTransform) = ParallelTableTransform
+AbstractTrees.children(p::ParallelTableTransform) = p.transforms
 
-Base.show(io::IO, p::Parallel) =
+Base.show(io::IO, p::ParallelTableTransform) =
   print(io, join(p.transforms, " ⊔ "))
 
-function Base.show(io::IO, ::MIME"text/plain", p::Parallel)
+function Base.show(io::IO, ::MIME"text/plain", p::ParallelTableTransform)
   tree = repr_tree(p, context=io)
   print(io, tree[begin:end-1]) # remove \n at end
 end
 
-isrevertible(p::Parallel) = any(isrevertible, p.transforms)
+isrevertible(p::ParallelTableTransform) = any(isrevertible, p.transforms)
 
-function apply(p::Parallel, table)
+function apply(p::ParallelTableTransform, table)
   # apply transforms in parallel
   f(transform) = apply(transform, table)
   vals = tcollect(f(t) for t in p.transforms)
@@ -75,7 +75,7 @@ function apply(p::Parallel, table)
   newtable, (caches, rinfo)
 end
 
-function revert(p::Parallel, newtable, cache)
+function revert(p::ParallelTableTransform, newtable, cache)
   # retrieve cache
   caches = cache[1]
   rinfo  = cache[2]
@@ -110,7 +110,7 @@ function revert(p::Parallel, newtable, cache)
   attach(feat, meta)
 end
 
-function reapply(p::Parallel, table, cache)
+function reapply(p::ParallelTableTransform, table, cache)
   # retrieve caches
   caches = cache[1]
 
@@ -160,10 +160,14 @@ end
 """
     transform₁ ⊔ transform₂ ⊔ ⋯ ⊔ transformₙ
 
-Create a [`Parallel`](@ref) transform with
+Create a [`ParallelTableTransform`](@ref) transform with
 `[transform₁, transform₂, …, transformₙ]`.
 """
-⊔(t1::TableTransform, t2::TableTransform) = Parallel([t1, t2])
-⊔(t1::TableTransform, t2::Parallel)       = Parallel([t1; t2.transforms])
-⊔(t1::Parallel, t2::TableTransform)       = Parallel([t1.transforms; t2])
-⊔(t1::Parallel, t2::Parallel)             = Parallel([t1.transforms; t2.transforms])
+⊔(t1::TableTransform, t2::TableTransform) =
+  ParallelTableTransform([t1, t2])
+⊔(t1::TableTransform, t2::ParallelTableTransform) =
+  ParallelTableTransform([t1; t2.transforms])
+⊔(t1::ParallelTableTransform, t2::TableTransform) =
+  ParallelTableTransform([t1.transforms; t2])
+⊔(t1::ParallelTableTransform, t2::ParallelTableTransform) =
+  ParallelTableTransform([t1.transforms; t2.transforms])

test/shows.jl

@@ -354,7 +354,7 @@
     └─ Scale(all, 0, 1)"""
   end
 
-  @testset "Parallel" begin
+  @testset "ParallelTableTransform" begin
     t1 = Scale(low=0.3, high=0.6)
     t2 = EigenAnalysis(:VDV)
     t3 = Functional(cos)
@@ -367,12 +367,12 @@
     # full mode
     iostr = sprint(show, MIME("text/plain"), pipeline)
     @test iostr == """
-    Parallel
+    ParallelTableTransform
     ├─ Scale(all, 0.3, 0.6)
     ├─ EigenAnalysis(:VDV, nothing, 1.0)
     └─ Functional(all, cos)"""
 
-    # Parallel with Sequential
+    # parallel and sequential
     f1 = ZScore()
     f2 = Scale()
     f3 = Functional(cos)
@@ -386,7 +386,7 @@
     # full mode
     iostr = sprint(show, MIME("text/plain"), pipeline)
     @test iostr == """
-    Parallel
+    ParallelTableTransform
     ├─ Sequential
     │  ├─ ZScore(all)
     │  └─ Scale(all, 0.25, 0.75)

test/transforms/parallel.jl

@@ -8,7 +8,7 @@
   tₒ = revert(T, n, c)
   @test Tables.matrix(t) ≈ Tables.matrix(tₒ)
 
-  # check cardinality of Parallel
+  # check cardinality of parallel transform
   x = rand(Normal(0, 10), 1500)
   y = x + rand(Normal(0, 2), 1500)
   z = y + rand(Normal(0, 5), 1500)
@@ -17,7 +17,7 @@
   n = T(t)
   @test length(Tables.columnnames(n)) == 6
 
-  # distributivity with respect to Sequential
+  # distributivity with respect to sequential transform
   x = rand(Normal(0, 10), 1500)
   y = x + rand(Normal(0, 2), 1500)
   z = y + rand(Normal(0, 5), 1500)
@@ -31,7 +31,7 @@
   n₂ = P₂(t)
   @test Tables.matrix(n₁) ≈ Tables.matrix(n₂)
 
-  # reapply with Parallel transform
+  # reapply with parallel transform
   t = Table(x=rand(1000))
   T = ZScore() ⊔ Quantile()
   n1, c1 = apply(T, t)