Re-add composition with ∘ and new compose function

Author: goerz

docs/src/operations.md

@@ -12,6 +12,7 @@ There are two functions that take a `Bijection` and return a new
 Given a `Bijection` `b`, calling `inv(b)` creates a new `Bijection`
 that is the inverse of `b`. The new `Bijection` is completely independent
 of the original, `b`. Changes to one do not affect the other:
+
 ```
 julia> b = Bijection{Int,String}()
 Bijection Dict{Int64, String}()
@@ -80,3 +81,15 @@ julia> for (x,y) in b; println("$x --> $y"); end
 1 --> alpha
 ```
 
+## Composition
+
+Given two `Bijection`s `a` and `b`, their composition `c = a ∘ b` or `c = compose(a, b)` is a new `Bijection` with the property that `c[x] = a[b[x]]` for all `x` in the
+domain of `b`.
+
+```
+julia> a = Bijection{Int,Int}(1 => 10, 2 => 20);
+julia> b = Bijection{String,Int}("hi" => 1, "bye" => 2);
+julia> c = a ∘ b;
+julia> c["hi"]
+10
+```

src/Bijections.jl

@@ -2,7 +2,7 @@ module Bijections
 
 using Serialization: Serialization
 
-export Bijection, active_inv, inverse, hasvalue
+export Bijection, active_inv, inverse, hasvalue, compose
 
 struct Bijection{K,V,F,Finv} <: AbstractDict{K,V}
     f::F          # map from domain to range
@@ -269,4 +269,21 @@ function Serialization.deserialize(
     return B(f)
 end
 
+"""
+    c = (∘)(a::Bijection{A,B}, b::Bijection{B,C})::Bijection{A,C} where {A,B,C}
+    c = compose(a, b)
+
+The result of `a ∘ b` or `compose(a, b)` is a new `Bijection` `c` such that
+`c[x]` is `a[b[x]]` for `x` in the domain of `b`.
+"""
+function compose(a::Bijection{B,A}, b::Bijection{C,B}) where {A,B,C}
+    c = Bijection{C,A}()
+    for x in keys(b)
+        c[x] = a[b[x]]
+    end
+    return c
+end
+
+Base.:(∘)(a::Bijection, b::Bijection) = compose(a, b)
+
 end # end of module Bijections

test/runtests.jl

@@ -38,6 +38,22 @@ using Serialization
     @test Bijection(collect(b)) == b
 end
 
+# check composition
+@testset "Composition" begin
+    a = Bijection{Int,Int}()
+    a[1] = 10
+    a[2] = 20
+
+    b = Bijection{String,Int}()
+    b["hi"] = 1
+    b["bye"] = 2
+
+    c = a ∘ b
+    @test c["hi"] == 10
+
+    @test compose(a, b) == c
+end
+
 # Test empty constructor
 @testset "empty_constructor" begin
     b = Bijection{Int,String}()