Skip to content

Latest commit

 

History

History
132 lines (86 loc) · 3.49 KB

README.md

File metadata and controls

132 lines (86 loc) · 3.49 KB
Raw

Maven Central

tuplez

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

Source code is 100% generated.

Composition

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)
// etc

Apply converters

app.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]")

Intended usage

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

Author

Iurii Malchenko – @yurique

License

tuplez is provided under the MIT license.