arrow.generic.Coproduct arities

build.gradle

@@ -25,6 +25,7 @@ buildscript {
         daggerVersion = '2.15'
         kotlinxCoroutinesVersion = '0.23.3'
         kotlinxCollectionsImmutableVersion = '0.1'
+        kotlinPoetVersion='1.0.0-RC1'
     }
 
     repositories {

modules/core/arrow-annotations-processor/build.gradle

@@ -5,6 +5,7 @@ apply plugin: 'kotlin-kapt'
 
 dependencies {
     compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlinVersion"
+    compile "com.squareup:kotlinpoet:$kotlinPoetVersion"
     compile project(':arrow-annotations')
     compile 'me.eugeniomarletti.kotlin.metadata:kotlin-metadata:1.4.0'
     compileOnly 'com.google.auto.service:auto-service:1.0-rc4'

modules/core/arrow-annotations-processor/src/main/java/arrow/generic/CoproductFileGenerator.kt

@@ -0,0 +1,194 @@
+package arrow.generic
+
+import com.squareup.kotlinpoet.AnnotationSpec
+import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.FileSpec
+import com.squareup.kotlinpoet.FunSpec
+import com.squareup.kotlinpoet.KModifier
+import com.squareup.kotlinpoet.LambdaTypeName
+import com.squareup.kotlinpoet.ParameterSpec
+import com.squareup.kotlinpoet.ParameterizedTypeName
+import com.squareup.kotlinpoet.PropertySpec
+import com.squareup.kotlinpoet.TypeSpec
+import com.squareup.kotlinpoet.TypeVariableName
+import java.io.File
+import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+
+private val genericsToClassNames = mapOf(
+        "A" to "First",
+        "B" to "Second",
+        "C" to "Third",
+        "D" to "Fourth",
+        "E" to "Fifth",
+        "F" to "Sixth",
+        "G" to "Seventh",
+        "H" to "Eighth",
+        "I" to "Ninth",
+        "J" to "Tenth",
+        "K" to "Eleventh",
+        "L" to "Twelfth",
+        "M" to "Thirteenth",
+        "N" to "Fourteenth",
+        "O" to "Fifteenth",
+        "P" to "Sixteenth",
+        "Q" to "Seventeenth",
+        "R" to "Eighteenth",
+        "S" to "Nineteenth",
+        "T" to "Twentieth",
+        "U" to "TwentyFirst",
+        "V" to "TwentySecond"
+)
+
+fun generateCoproducts(destination: File) {
+    for (size in 2 until genericsToClassNames.size + 1) {
+        val generics = genericsToClassNames.keys.toList().take(size)
+
+        FileSpec.builder("arrow.generic.coproduct$size", "Coproduct$size")
+                .apply {
+                    addCoproductClassDeclaration(generics)
+                    addCoproductOfConstructors(generics)
+                    addCopExtensionConstructors(generics)
+                    addSelectFunctions(generics)
+                    addFoldFunction(generics)
+                }
+                .build()
+                .writeTo(destination)
+    }
+}
+
+private fun FileSpec.Builder.addCoproductClassDeclaration(generics: List<String>) {
+    addType(
+            TypeSpec.classBuilder("Coproduct${generics.size}")
+                    .addModifiers(KModifier.SEALED)
+                    .addTypeVariables(generics.map { TypeVariableName(it) })
+                    .build()
+    )
+
+    for (generic in generics) {
+        addType(
+                TypeSpec.classBuilder(genericsToClassNames[generic]!!)
+                        .addModifiers(KModifier.INTERNAL, KModifier.DATA)
+                        .addTypeVariables(generics.toTypeParameters())
+                        .superclass(parameterizedCoproductNClassName(generics))
+                        .addProperty(
+                                PropertySpec.builder(generic.toLowerCase(), TypeVariableName(generic))
+                                        .initializer(generic.toLowerCase())
+                                        .build()
+                        )
+                        .primaryConstructor(
+                                FunSpec.constructorBuilder()
+                                        .addParameter(generic.toLowerCase(), TypeVariableName(generic))
+                                        .build()
+                        )
+                        .build()
+        )
+    }
+}
+
+private fun FileSpec.Builder.addCoproductOfConstructors(generics: List<String>) {
+    for (generic in generics) {
+        val additionalParameterCount = generics.indexOf(generic)
+
+        addFunction(
+                FunSpec.builder("coproductOf")
+                        .addAnnotations(additionalParameterSuppressAnnotation(additionalParameterCount))
+                        .addTypeVariables(generics.toTypeParameters())
+                        .addParameter(generic.toLowerCase(), TypeVariableName(generic))
+                        .addParameters(additionalParameterSpecs(additionalParameterCount))
+                        .addStatement("return ${genericsToClassNames[generic]}(${generic.toLowerCase()})")
+                        .returns(parameterizedCoproductNClassName(generics))
+                        .build()
+        )
+    }
+}
+
+private fun FileSpec.Builder.addCopExtensionConstructors(generics: List<String>) {
+    for (generic in generics) {
+        val additionalParameterCount = generics.indexOf(generic)
+
+        addFunction(
+                FunSpec.builder("cop")
+                        .addAnnotations(additionalParameterSuppressAnnotation(additionalParameterCount))
+                        .receiver(TypeVariableName(generic))
+                        .addTypeVariables(generics.toTypeParameters())
+                        .addParameters(additionalParameterSpecs(additionalParameterCount))
+                        .addStatement("return coproductOf<${generics.joinToString(separator = ", ")}>(this)")
+                        .returns(parameterizedCoproductNClassName(generics))
+                        .build()
+        )
+    }
+}
+
+private fun FileSpec.Builder.addSelectFunctions(generics: List<String>) {
+    addImport("arrow.core", "Option")
+    addImport("arrow.core", "toOption")
+
+    for (generic in generics) {
+        val receiverGenerics = generics
+                .map { if (it == generic) TypeVariableName(generic) else TypeVariableName("*") }
+                .toTypedArray()
+        val additionalParameterCount = generics.indexOf(generic)
+
+        addFunction(
+                FunSpec.builder("select")
+                        .addAnnotations(additionalParameterSuppressAnnotation(additionalParameterCount))
+                        .addTypeVariable(TypeVariableName(generic))
+                        .receiver(ClassName("", "Coproduct${generics.size}").parameterizedBy(*receiverGenerics))
+                        .addParameters(additionalParameterSpecs(additionalParameterCount))
+                        .returns(ClassName("arrow.core", "Option").parameterizedBy(TypeVariableName(generic)))
+                        .addStatement("return (this as? ${genericsToClassNames[generic]})?.${generic.toLowerCase()}.toOption()")
+                        .build()
+        )
+    }
+}
+
+private fun FileSpec.Builder.addFoldFunction(generics: List<String>) {
+    addFunction(
+            FunSpec.builder("fold")
+                    .receiver(parameterizedCoproductNClassName(generics))
+                    .addTypeVariables(generics.toTypeParameters() + TypeVariableName("RESULT"))
+                    .addParameters(
+                            generics.map {
+                                ParameterSpec.builder(
+                                        it.toLowerCase(),
+                                        LambdaTypeName.get(
+                                                parameters = listOf(ParameterSpec.unnamed(TypeVariableName(it))),
+                                                returnType = TypeVariableName("RESULT")
+                                        )
+                                ).build()
+                            }
+                    )
+                    .returns(TypeVariableName("RESULT"))
+                    .apply {
+                        beginControlFlow("return when (this)")
+                        for (generic in generics) {
+                            addStatement("is ${genericsToClassNames[generic]} -> ${generic.toLowerCase()}(this.${generic.toLowerCase()})")
+                        }
+                        endControlFlow()
+                    }
+                    .build()
+    )
+}
+
+private fun List<String>.toTypeParameters() = map { TypeVariableName(it) }
+
+private fun parameterizedCoproductNClassName(generics: List<String>): ParameterizedTypeName =
+        ClassName("", "Coproduct${generics.size}")
+                .parameterizedBy(*generics.map { TypeVariableName(it) }.toTypedArray())
+
+private fun additionalParameterSuppressAnnotation(count: Int): List<AnnotationSpec> =
+        if (count > 0) {
+            listOf(
+                    AnnotationSpec.builder(Suppress::class)
+                            .addMember("\"UNUSED_PARAMETER\"")
+                            .build()
+            )
+        } else {
+            emptyList()
+        }
+
+private fun additionalParameterSpecs(count: Int): List<ParameterSpec> = List(count) {
+    ParameterSpec.builder("dummy$it", Unit::class)
+            .defaultValue("Unit")
+            .build()
+}

modules/core/arrow-annotations-processor/src/main/java/arrow/generic/CoproductProcessor.kt

@@ -0,0 +1,24 @@
+package arrow.generic
+
+import com.google.auto.service.AutoService
+import arrow.common.utils.AbstractProcessor
+import arrow.coproduct
+import java.io.File
+import javax.annotation.processing.Processor
+import javax.annotation.processing.RoundEnvironment
+import javax.lang.model.SourceVersion
+import javax.lang.model.element.TypeElement
+
+@AutoService(Processor::class)
+class CoproductProcessor : AbstractProcessor() {
+
+    override fun getSupportedSourceVersion(): SourceVersion = SourceVersion.latestSupported()
+
+    override fun getSupportedAnnotationTypes(): Set<String> = setOf(coproduct::class.java.canonicalName)
+
+    override fun onProcess(annotations: Set<TypeElement>, roundEnv: RoundEnvironment) {
+        val generatedDir = File(this.generatedDir!!, "").also { it.mkdirs() }
+
+        generateCoproducts(generatedDir)
+    }
+}

modules/core/arrow-annotations/src/main/java/arrow/coproduct.kt

@@ -0,0 +1,3 @@
+package arrow
+
+annotation class coproduct

modules/core/arrow-generic/src/main/kotlin/arrow/generic/Coproduct.kt

@@ -0,0 +1,9 @@
+package arrow.generic
+
+import arrow.coproduct
+
+/**
+ * This annotated class exists to trigger the code generation.
+ */
+@coproduct
+private object Coproduct

modules/core/arrow-generic/src/test/kotlin/arrow/generic/CoproductTest.kt

@@ -0,0 +1,84 @@
+package arrow.generic
+
+import arrow.core.None
+import arrow.core.Option
+import arrow.core.Some
+import arrow.core.some
+import arrow.generic.coproduct2.Coproduct2
+import arrow.generic.coproduct2.cop
+import arrow.generic.coproduct2.coproductOf
+import arrow.generic.coproduct2.fold
+import arrow.generic.coproduct2.select
+import arrow.generic.coproduct22.Coproduct22
+import arrow.generic.coproduct3.cop
+import arrow.generic.coproduct3.fold
+import arrow.generic.coproduct3.select
+import arrow.test.UnitSpec
+import io.kotlintest.KTestJUnitRunner
+import io.kotlintest.matchers.shouldBe
+import org.junit.runner.RunWith
+
+@RunWith(KTestJUnitRunner::class)
+class CoproductTest : UnitSpec() {
+    init {
+        "Coproducts should be generated up to 22" {
+            var two: Coproduct2<Unit, Unit>? = null
+            var twentytwo: Coproduct22<Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit, Unit>? = null
+        }
+
+        "select should return None if value isn't correct type" {
+            val coproduct2 = "String".cop<String, Long>()
+
+            coproduct2.select<Long>() shouldBe None
+        }
+
+        "select returns Some if value is correct type" {
+            val coproduct2 = "String".cop<String, Long>()
+
+            coproduct2.select<String>() shouldBe Some("String")
+        }
+
+        "coproductOf(A) should equal cop<A, B>()" {
+            "String".cop<String, Long>() shouldBe coproductOf<String, Long>("String")
+        }
+
+        "Coproduct2 fold" {
+            val coproduct2 = 100L.cop<Long, Int>()
+
+            coproduct2.fold(
+                    { "Long$it" },
+                    { "Int$it" }
+            ) shouldBe "Long100"
+        }
+
+        "Coproduct3 should handle multiple nullable types" {
+            val value: String? = null
+            val coproduct3 = value.cop<Long, Float?, String?>()
+
+            coproduct3.select<Long>() shouldBe None
+            coproduct3.select<Float?>() shouldBe None
+            coproduct3.select<String?>() shouldBe None
+
+            coproduct3.fold(
+                    { "First" },
+                    { "Second" },
+                    { "Third" }
+            ) shouldBe "Third"
+        }
+
+        "Coproduct3 should handle multiple types with generics" {
+            val value: Option<String> = "String".some()
+            val coproduct3 = value.cop<Option<Long>, Option<Float>, Option<String>>()
+
+            coproduct3.select<Option<Long>>() shouldBe None
+            coproduct3.select<Option<Float>>() shouldBe None
+            coproduct3.select<Option<String>>() shouldBe value.some()
+
+            coproduct3.fold(
+                    { "First" },
+                    { "Second" },
+                    { "Third" }
+            ) shouldBe "Third"
+        }
+    }
+}