Translator from an input I to an output O, designed to be built recursively.

Translation by Splitting and joining

The most import class of translators are constructed from

* a split map I => Option[X], where X is obtained from I by taking Tuples, Lists and sub-types

* a join map Y => Option[O], where Y is obtained from O structurally, in the same way as X is obtained from I, e.g. X = (I, I) and Y = (O, O).

However X and Y may involve taking sub-types independently of each other.

Such a translator splits an input, recursively translates X to Y and combines the result with the join (all steps work optionally).

Combinations, Basic Translators

Translators are built by combining others by OrElse, starting with basic translators specified by a function I => Option[O]. One can instead start with an empty translator.

Note that we can restrict the domain or extend the codomain of a translator by just using it as a function I => Option[O]. However this should be done after making all OrElse combinations, as the wrapped translator does not combine recursively.

A typical example of usage is as below

scala> import provingground._
import provingground._

scala> import translation._, Translator._
import translation._
import Translator._

scala> import cats._, cats.implicits._
import cats._
import cats.implicits._

scala> class A
defined class A

scala> case class B(x: A, y: A) extends A
defined class B

scala> case class C(x: A, y: A) extends A
defined class C

scala> case object D extends A
defined object D

scala> import Functors._
import Functors._

scala> val Bpat = Pattern.partial[A, II]{case B(x, y) => (x, y)}


scala> val Dpat = Pattern.partial[A, Un]{case D => ()}


scala> case object E extends A
defined object E

scala> val trans = Translator.Empty[A, A] || Bpat >>> {case (x, y) => C(x,y)} || Dpat >>> {case _ => E}
trans: provingground.translation.Translator.OrElse[A,A] = <function1>

scala> trans(B(B(D, D), B(B(D, D), D)))
res0: Option[A] = Some(C(C(E,E),C(C(E,E),E)))

scala> trans(C(D, D))
res1: Option[A] = None