Improve usage of match types

Author: prolativ

src/main/FrameSchema.scala

@@ -6,20 +6,30 @@ import types.{DataType, Encoder, StructEncoder}
 import MacroHelpers.TupleSubtype
 
 object FrameSchema:
-  type Merge[S1, S2] = S1 match
-    case TupleSubtype[s1] => S2 match
-      case TupleSubtype[s2] => Tuple.Concat[s1, s2]
-      case _ => Tuple.Concat[s1, S2 *: EmptyTuple]
-    case _ => S2 match
-      case TupleSubtype[s2] => S1 *: s2
-      case _ => S1 *: S2 *: EmptyTuple
+  type AsTuple[A] = A match
+    case Tuple => A
+    case Any => A *: EmptyTuple
+
+  type FromTuple[T] = T match
+    case h *: EmptyTuple => h
+    case Tuple => T
+
+  type Merge[S1, S2] = (S1, S2) match
+    case (Tuple, Tuple) =>
+      Tuple.Concat[S1, S2]
+    case (Any, Tuple) =>
+      S1 *: S2
+    case (Tuple, Any) =>
+      Tuple.Append[S1, S2]
+    case (Any, Any) =>
+      (S1, S2)
 
   type NullableLabeledDataType[T] = T match
     case label := tpe => label := DataType.Nullable[tpe]
 
   type NullableSchema[T] = T match
-    case TupleSubtype[s] => Tuple.Map[s, NullableLabeledDataType]
-    case _ => NullableLabeledDataType[T]
+    case Tuple => Tuple.Map[T, NullableLabeledDataType]
+    case Any => NullableLabeledDataType[T]
 
   def reownType[Owner <: Name : Type](schema: Type[?])(using Quotes): Type[?] =
     schema match

src/main/MacroHelpers.scala

@@ -11,7 +11,3 @@ private[iskra] object MacroHelpers:
     Position(file, start, end)
 
   type TupleSubtype[T <: Tuple] = T
-
-  type AsTuple[A] <: Tuple = A match
-    case TupleSubtype[t] => t
-    case _ => A *: EmptyTuple

src/main/SchemaView.scala

@@ -3,7 +3,7 @@ package org.virtuslab.iskra
 import scala.quoted.*
 import org.apache.spark.sql.functions.col
 import types.DataType
-import MacroHelpers.AsTuple
+import MacroHelpers.TupleSubtype
 
 inline def $(using view: SchemaView): view.type = view
 
@@ -79,7 +79,7 @@ object StructSchemaView:
     import quotes.reflect.*
     Type.of[DF] match
       case '[StructDataFrame[schema]] =>
-        val schemaType = Type.of[AsTuple[schema]]
+        val schemaType = Type.of[FrameSchema.AsTuple[schema]]
         val aliasViewsByName = frameAliasViewsByName(schemaType)
         val columns = unambiguousColumns(schemaType)    
         val frameAliasNames = Expr(aliasViewsByName.map(_._1))

src/main/Select.scala

@@ -37,13 +37,7 @@ object Select:
       case Some(collectColumns) =>
         collectColumns match
           case '{ $cc: CollectColumns[?] { type CollectedColumns = collectedColumns } } =>
-            Type.of[collectedColumns] match
-              case '[head *: EmptyTuple] =>
-                '{
-                  val cols = ${ cc }.underlyingColumns(${ columns }(using ${ select }.view))
-                  StructDataFrame[head](${ select }.underlying.select(cols*))
-                }
-
+            Type.of[FrameSchema.FromTuple[collectedColumns]] match
               case '[s] =>
                 '{
                   val cols = ${ cc }.underlyingColumns(${ columns }(using ${ select }.view))

src/main/StructDataFrame.scala

@@ -3,6 +3,7 @@ package org.virtuslab.iskra
 import scala.quoted.*
 
 import types.{DataType, Encoder, StructEncoder}
+import MacroHelpers.TupleSubtype
 
 
 class StructDataFrame[Schema](val untyped: UntypedDataFrame) extends DataFrame
@@ -20,7 +21,13 @@ object StructDataFrame:
     Expr.summon[Encoder[A]] match
       case Some(encoder) => encoder match
         case '{ $enc: StructEncoder[A] { type StructSchema = structSchema } } =>
-          Type.of[MacroHelpers.AsTuple[FrameSchema]] match
+          val frameSchemaTuple = Type.of[FrameSchema] match
+            case '[TupleSubtype[t]] =>
+              Type.of[t]
+            case '[t] =>
+              Type.of[t *: EmptyTuple]
+
+          frameSchemaTuple match
             case '[`structSchema`] =>
               '{ ClassDataFrame[A](${ df }.untyped) }
             case _ =>

src/main/types/DataType.scala

@@ -34,20 +34,20 @@ object DataType:
     case StructOptType[schema] => StructOptType[schema]
 
   type CommonNumericNullableType[T1 <: DataType, T2 <: DataType] <: NumericOptType = (T1, T2) match
-    case (DoubleOptType, _) | (_, DoubleOptType) => DoubleOptType
-    case (FloatOptType, _) | (_, FloatOptType) => FloatOptType
-    case (LongOptType, _) | (_, LongOptType) => LongOptType
-    case (IntegerOptType, _) | (_, IntegerOptType) => IntegerOptType
-    case (ShortOptType, _) | (_, ShortOptType) => ShortOptType
-    case (ByteOptType, _) | (_, ByteOptType) => ByteOptType
+    case (DoubleOptType, DataType) | (DataType, DoubleOptType) => DoubleOptType
+    case (FloatOptType, DataType) | (DataType, FloatOptType) => FloatOptType
+    case (LongOptType, DataType) | (DataType, LongOptType) => LongOptType
+    case (IntegerOptType, DataType) | (DataType, IntegerOptType) => IntegerOptType
+    case (ShortOptType, DataType) | (DataType, ShortOptType) => ShortOptType
+    case (ByteOptType, DataType) | (DataType, ByteOptType) => ByteOptType
 
   type CommonNumericNonNullableType[T1 <: DataType, T2 <: DataType] <: NumericOptType = (T1, T2) match
-    case (DoubleOptType, _) | (_, DoubleOptType) => DoubleType
-    case (FloatOptType, _) | (_, FloatOptType) => FloatType
-    case (LongOptType, _) | (_, LongOptType) => LongType
-    case (IntegerOptType, _) | (_, IntegerOptType) => IntegerType
-    case (ShortOptType, _) | (_, ShortOptType) => ShortType
-    case (ByteOptType, _) | (_, ByteOptType) => ByteType
+    case (DoubleOptType, DataType) | (DataType, DoubleOptType) => DoubleType
+    case (FloatOptType, DataType) | (DataType, FloatOptType) => FloatType
+    case (LongOptType, DataType) | (DataType, LongOptType) => LongType
+    case (IntegerOptType, DataType) | (DataType, IntegerOptType) => IntegerType
+    case (ShortOptType, DataType) | (DataType, ShortOptType) => ShortType
+    case (ByteOptType, DataType) | (DataType, ByteOptType) => ByteType
 
 import DataType.NotNull