Tuple composition in Scala and Scala.js.
// tupleN + scalar, scalar + tupleN, tupleN + tupleM, up to Tuple22
"app.tulz" %%% "tuplez-full" % "0.4.0"
// or
// tupleN + scalar, scalar + tupleN, tupleN + tupleM, up to Tuple10
"app.tulz" %%% "tuplez-full-light" % "0.4.0"
// or
// tupleN + scalar, up to Tuple22
"app.tulz" %%% "tuplez-basic" % "0.4.0"
// or
// tupleN + scalar, up to Tuple10
"app.tulz" %%% "tuplez-basic-light" % "0.4.0" // utilities to build API's that allow using a FunctionN[A, B, C, ... Out] instead of Function1[TupleN[A, B, C, ...], Out]
"app.tulz" %%% "tuplez-apply" % "0.4.0"Published for Scala 2.12, 2.13 and 3.2.1, JVM and Scala.js 1.5.1+.
Source code is 100% generated.
app.tulz.tuplez.TupleComposition
abstract class Composition[L, R] {
type Composed
val compose: (L, R) => Composed
def decompose(c: Composed): (L, R)
}Implicit values are provided for composing tuples with tuples, and tuples with scalars (both prepending and appending).
Implicits are defined by the generated code.
The companion object provides utility functions to compose/decompose two tuples (or a tuple and a scalar)
object TupleComposition {
def compose[L, R](l: L, r: R)(implicit composition: Composition[L, R]): composition.Composed = composition.compose(l, r)
def decompose[L, R, C](c: C)(implicit composition: Composition.Aux[L, R, C]): (L, R) = composition.decompose(c)
}
Examples:
import app.tulz.tuplez.TupleComposition
TupleComposition.compose( Tuple1(1), Tuple1(2) ) // (1, 2)
TupleComposition.compose( 1, 2 ) // (1, 2)
TupleComposition.compose( (1, 2, 3, 4), (5, 6) ) // (1, 2, 3, 4, 5, 6)
TupleComposition.compose( (1, 2, 3), 4 ) // (1, 2, 3, 4)
TupleComposition.compose( 1, (2, 3, 4) ) // (1, 2, 3, 4)
TupleComposition.compose( (1, 2, 3), Tuple1(4) ) // (1, 2, 3, 4)
TupleComposition.compose( Tuple1(1), (2, 3, 4) ) // (1, 2, 3, 4)
TupleComposition.compose( (1, 2, 3), () ) // (1, 2, 3)
TupleComposition.compose( (), (1, 2, 3) ) // (1, 2, 3)
// etcapp.tulz.tuplez.ApplyConverter
Utilities for converting FunctionN[..., Out] into Function1[TupleN[...], Out]
Example:
import app.tulz.tuplez._
object instances extends ApplyConverters[String]
// in order to make type and implicits resolution possible, the apply converters are generated for a fixed output type
import instances._
val acceptingTupledFunc: ((Int, Int, Int, Int) => String) => String = func => func((1, 2, 3, 4))
val nonTupledFunction = (x1: Int, x2: Int, x3: Int, x4: Int) => s"I return [${x1}, ${x2}, ${x3}, ${x4}]"
assert(acceptingTupledFunc(toTupled4(nonTupledFunction)) == "I return [1, 2, 3, 4]")Simple example:
import app.tulz.tuplez._
case class MyStructure[T](
data: T
) {
def appendScalar[U](value: U)(implicit composition: Composition[T, U]): MyStructure[composition.Composed] =
copy(data = composition.compose(data, value))
// or
// copy(data = TupleComposition.compose(data, value))
}A more complete example: https://github.com/tulz-app/frontroute/blob/main/src/main/scala/io/frontroute/DirectiveApplyConverters.scala
Iurii Malchenko – @yurique
tuplez is provided under the MIT license.
