Introduce ColumnFuns

Author: Michał Pałka

src/main/CollectColumns.scala

@@ -28,8 +28,3 @@ object CollectColumns:
     new CollectColumns[H *: T]:
       type CollectedColumns = Tuple.Concat[collectHead.CollectedColumns, collectTail.CollectedColumns]
       def underlyingColumns(c: H *: T) = collectHead.underlyingColumns(c.head) ++ collectTail.underlyingColumns(c.tail)
-
-
-  // TODO Customize error message for different operations with an explanation
-  class CannotCollectColumns(typeName: String)
-    extends Exception(s"Could not find an instance of CollectColumns for ${typeName}")

src/main/Column.scala

@@ -1,58 +1,35 @@
 package org.virtuslab.iskra
 
-import scala.language.implicitConversions
-
 import scala.quoted.*
 
 import org.apache.spark.sql.{Column => UntypedColumn}
 import types.DataType
 import MacroHelpers.TupleSubtype
 
-class Column(val untyped: UntypedColumn):
-  inline def name(using v: ValueOf[Name]): Name = v.value
+sealed class Column(val untyped: UntypedColumn) extends ColumnOps
 
 object Column:
-  implicit transparent inline def columnToNamedColumn(inline col: Col[?]): NamedColumn[?, ?] =
-    ${ columnToNamedColumnImpl('col) }
-
-  private def columnToNamedColumnImpl(col: Expr[Col[?]])(using Quotes): Expr[NamedColumn[?, ?]] =
-    import quotes.reflect.*
-    col match
-      case '{ ($v: StructuralSchemaView).selectDynamic($nm: Name).$asInstanceOf$[Col[tp]] } =>
-        nm.asTerm.tpe.asType match
-          case '[Name.Subtype[n]] =>
-            '{ NamedColumn[n, tp](${ col }.untyped.as(${ nm })) }
-      case '{ $c: Col[tp] } =>
-        col.asTerm match
-          case Inlined(_, _, Ident(name)) =>
-            ConstantType(StringConstant(name)).asType match
-              case '[Name.Subtype[n]] =>
-                val alias = Literal(StringConstant(name)).asExprOf[Name]
-                '{ NamedColumn[n, tp](${ col }.untyped.as(${ alias })) }
+  def unsafeTyped[R <: ColumnOrError](untyped: UntypedColumn): R = new ColumnImpl(untyped).asInstanceOf[R]
 
   extension [T <: DataType](col: Col[T])
     inline def as[N <: Name](name: N): NamedColumn[N, T] =
       NamedColumn[N, T](col.untyped.as(name))
     inline def alias[N <: Name](name: N): NamedColumn[N, T] =
       NamedColumn[N, T](col.untyped.as(name))
 
-  extension [T1 <: DataType](col1: Col[T1])
-    inline def +[T2 <: DataType](col2: Col[T2])(using op: ColumnOp.Plus[T1, T2]): Col[op.Out] = op(col1, col2)
-    inline def -[T2 <: DataType](col2: Col[T2])(using op: ColumnOp.Minus[T1, T2]): Col[op.Out] = op(col1, col2)
-    inline def *[T2 <: DataType](col2: Col[T2])(using op: ColumnOp.Mult[T1, T2]): Col[op.Out] = op(col1, col2)
-    inline def /[T2 <: DataType](col2: Col[T2])(using op: ColumnOp.Div[T1, T2]): Col[op.Out] = op(col1, col2)
-    inline def ++[T2 <: DataType](col2: Col[T2])(using op: ColumnOp.PlusPlus[T1, T2]): Col[op.Out] = op(col1, col2)
-    inline def <[T2 <: DataType](col2: Col[T2])(using op: ColumnOp.Lt[T1, T2]): Col[op.Out] = op(col1, col2)
-    inline def <=[T2 <: DataType](col2: Col[T2])(using op: ColumnOp.Le[T1, T2]): Col[op.Out] = op(col1, col2)
-    inline def >[T2 <: DataType](col2: Col[T2])(using op: ColumnOp.Gt[T1, T2]): Col[op.Out] = op(col1, col2)
-    inline def >=[T2 <: DataType](col2: Col[T2])(using op: ColumnOp.Ge[T1, T2]): Col[op.Out] = op(col1, col2)
-    inline def ===[T2 <: DataType](col2: Col[T2])(using op: ColumnOp.Eq[T1, T2]): Col[op.Out] = op(col1, col2)
-    inline def =!=[T2 <: DataType](col2: Col[T2])(using op: ColumnOp.Ne[T1, T2]): Col[op.Out] = op(col1, col2)
-    inline def &&[T2 <: DataType](col2: Col[T2])(using op: ColumnOp.And[T1, T2]): Col[op.Out] = op(col1, col2)
-    inline def ||[T2 <: DataType](col2: Col[T2])(using op: ColumnOp.Or[T1, T2]): Col[op.Out] = op(col1, col2)
+  export ColumnOps.*
+  export ColumnOps.given
+
+final class DataColumn(untyped: UntypedColumn) extends Column(untyped)
+
+
+// TODO: Get rid of covariance?
+sealed class Col[+T <: DataType](untyped: UntypedColumn) extends Column(untyped)
 
+final class ColumnImpl(untyped: UntypedColumn) extends Col[Nothing](untyped)
 
-class Col[+T <: DataType](untyped: UntypedColumn) extends Column(untyped)
+object ColumnImpl:
+  def apply[R <: ColumnOrError](untyped: UntypedColumn): R = new ColumnImpl(untyped).asInstanceOf[R]
 
 
 object Columns:
@@ -72,23 +49,11 @@ object Columns:
                   ColumnsWithSchema[collectedCols](cols)
                 }
       case None =>
-        throw CollectColumns.CannotCollectColumns(Type.show[C])
-
-
-trait NamedColumnOrColumnsLike
-
-type NamedColumns = Repeated[NamedColumnOrColumnsLike]
-
-class NamedColumn[N <: Name, T <: DataType](val untyped: UntypedColumn)
-  extends NamedColumnOrColumnsLike
-
-class ColumnsWithSchema[Schema <: Tuple](val underlyingColumns: Seq[UntypedColumn]) extends NamedColumnOrColumnsLike
-
+        // TODO: What should be returned here for best error messages?
+        report.errorAndAbort("Cannot collect columns: " + Type.show[C])
 
-@annotation.showAsInfix
-trait :=[L <: ColumnLabel, T <: DataType]
+type ColumnOrError = Column | ColumnError
 
-@annotation.showAsInfix
-trait /[+Prefix <: Name, +Suffix <: Name]
+sealed trait ColumnError
 
-type ColumnLabel = Name | (Name / Name)
+object ColumnError extends ColumnError

src/main/ColumnFun.scala

@@ -0,0 +1,16 @@
+package org.virtuslab.iskra
+
+import org.virtuslab.iskra.types.DataType
+
+type AsColumnOrError[T] <: ColumnOrError = T match
+  case DataType => Col[T]
+  case _ => ColumnError
+
+type ColumnFun1[C1 <: Column,  F[_]] <: ColumnOrError = C1 match
+  case Col[t1] => AsColumnOrError[F[t1]]
+  case _ => ColumnError
+
+
+type ColumnFun2[C1 <: Column, C2 <: Column,  F[_, _]] <: ColumnOrError = (C1, C2) match
+  case (Col[t1], Col[t2]) => AsColumnOrError[F[t1, t2]]
+  case _ => ColumnError