{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE ExplicitNamespaces #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE UndecidableInstances #-}

module DataFrame.Internal.Interpreter where

import Control.Monad.ST (runST)
import Data.Bifunctor
import qualified Data.Map as M
import Data.Maybe (fromMaybe, isJust)
import qualified Data.Text as T
import Data.Type.Equality (TestEquality (testEquality), type (:~:) (Refl))
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as VM
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM
import DataFrame.Errors
import DataFrame.Internal.Column
import DataFrame.Internal.DataFrame
import DataFrame.Internal.Expression
import DataFrame.Internal.Types
import Type.Reflection (TypeRep, Typeable, typeOf, typeRep, pattern App)

interpret ::
    forall a.
    (Columnable a) =>
    DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret :: forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret DataFrame
df (Lit a
value) = case forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @a of
    -- Specialize the creation of unboxed columns to avoid an extra allocation.
    SBool (Unboxable a)
STrue -> TypedColumn a -> Either DataFrameException (TypedColumn a)
forall a. a -> Either DataFrameException a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypedColumn a -> Either DataFrameException (TypedColumn a))
-> TypedColumn a -> Either DataFrameException (TypedColumn a)
forall a b. (a -> b) -> a -> b
$ Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$ Vector a -> Column
forall a. (Columnable a, Unbox a) => Vector a -> Column
fromUnboxedVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$ Int -> a -> Vector a
forall a. Unbox a => Int -> a -> Vector a
VU.replicate (DataFrame -> Int
numRows DataFrame
df) a
value
    SBool (Unboxable a)
SFalse -> TypedColumn a -> Either DataFrameException (TypedColumn a)
forall a. a -> Either DataFrameException a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypedColumn a -> Either DataFrameException (TypedColumn a))
-> TypedColumn a -> Either DataFrameException (TypedColumn a)
forall a b. (a -> b) -> a -> b
$ Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$ Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$ Int -> a -> Vector a
forall a. Int -> a -> Vector a
V.replicate (DataFrame -> Int
numRows DataFrame
df) a
value
interpret DataFrame
df (Col Text
name) = Either DataFrameException (TypedColumn a)
-> (Column -> Either DataFrameException (TypedColumn a))
-> Maybe Column
-> Either DataFrameException (TypedColumn a)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Either DataFrameException (TypedColumn a)
columnNotFound (TypedColumn a -> Either DataFrameException (TypedColumn a)
forall a. a -> Either DataFrameException a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypedColumn a -> Either DataFrameException (TypedColumn a))
-> (Column -> TypedColumn a)
-> Column
-> Either DataFrameException (TypedColumn a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn) (Text -> DataFrame -> Maybe Column
getColumn Text
name DataFrame
df)
  where
    columnNotFound :: Either DataFrameException (TypedColumn a)
columnNotFound = DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left (DataFrameException -> Either DataFrameException (TypedColumn a))
-> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> [Text] -> DataFrameException
ColumnNotFoundException Text
name Text
"" (Map Text Int -> [Text]
forall k a. Map k a -> [k]
M.keys (Map Text Int -> [Text]) -> Map Text Int -> [Text]
forall a b. (a -> b) -> a -> b
$ DataFrame -> Map Text Int
columnIndices DataFrame
df)
-- Unary operations.
interpret DataFrame
df expr :: Expr a
expr@(UnaryOp Text
_ (b -> a
f :: c -> d) Expr b
value) = (DataFrameException -> DataFrameException)
-> Either DataFrameException (TypedColumn a)
-> Either DataFrameException (TypedColumn a)
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (String -> DataFrameException -> DataFrameException
handleInterpretException (Expr a -> String
forall a. Show a => a -> String
show Expr a
expr)) (Either DataFrameException (TypedColumn a)
 -> Either DataFrameException (TypedColumn a))
-> Either DataFrameException (TypedColumn a)
-> Either DataFrameException (TypedColumn a)
forall a b. (a -> b) -> a -> b
$ do
    (TColumn Column
value') <- forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @c DataFrame
df Expr b
value
    (Column -> TypedColumn a)
-> Either DataFrameException Column
-> Either DataFrameException (TypedColumn a)
forall a b.
(a -> b)
-> Either DataFrameException a -> Either DataFrameException b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn ((b -> a) -> Column -> Either DataFrameException Column
forall b c.
(Columnable b, Columnable c, UnboxIf c) =>
(b -> c) -> Column -> Either DataFrameException Column
mapColumn b -> a
f Column
value')
-- Variations of binary operations.
interpret DataFrame
df expr :: Expr a
expr@(BinaryOp Text
_ (c -> b -> a
f :: c -> d -> e) Expr c
left Expr b
right) = (DataFrameException -> DataFrameException)
-> Either DataFrameException (TypedColumn a)
-> Either DataFrameException (TypedColumn a)
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (String -> DataFrameException -> DataFrameException
handleInterpretException (Expr a -> String
forall a. Show a => a -> String
show Expr a
expr)) (Either DataFrameException (TypedColumn a)
 -> Either DataFrameException (TypedColumn a))
-> Either DataFrameException (TypedColumn a)
-> Either DataFrameException (TypedColumn a)
forall a b. (a -> b) -> a -> b
$ case (Expr c
left, Expr b
right) of
    (Lit c
left, Lit b
right) -> DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret DataFrame
df (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit (c -> b -> a
f c
left b
right))
    (Lit c
left, Expr b
right) -> do
        -- If we have a literal then we don't have to materialise
        -- the column.
        (TColumn Column
value') <- forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @d DataFrame
df Expr b
right
        (Column -> TypedColumn a)
-> Either DataFrameException Column
-> Either DataFrameException (TypedColumn a)
forall a b.
(a -> b)
-> Either DataFrameException a -> Either DataFrameException b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn ((b -> a) -> Column -> Either DataFrameException Column
forall b c.
(Columnable b, Columnable c, UnboxIf c) =>
(b -> c) -> Column -> Either DataFrameException Column
mapColumn (c -> b -> a
f c
left) Column
value')
    (Expr c
left, Lit b
right) -> do
        -- Same as the above except the right side is the
        -- literl.
        (TColumn Column
value') <- forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @c DataFrame
df Expr c
left
        (Column -> TypedColumn a)
-> Either DataFrameException Column
-> Either DataFrameException (TypedColumn a)
forall a b.
(a -> b)
-> Either DataFrameException a -> Either DataFrameException b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn ((c -> a) -> Column -> Either DataFrameException Column
forall b c.
(Columnable b, Columnable c, UnboxIf c) =>
(b -> c) -> Column -> Either DataFrameException Column
mapColumn (c -> b -> a
`f` b
right) Column
value')
    (Expr c
_, Expr b
_) -> do
        -- In the general case we interpret and zip.
        (TColumn Column
left') <- forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @c DataFrame
df Expr c
left
        (TColumn Column
right') <- forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @d DataFrame
df Expr b
right
        (Column -> TypedColumn a)
-> Either DataFrameException Column
-> Either DataFrameException (TypedColumn a)
forall a b.
(a -> b)
-> Either DataFrameException a -> Either DataFrameException b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn ((c -> b -> a)
-> Column -> Column -> Either DataFrameException Column
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
(a -> b -> c)
-> Column -> Column -> Either DataFrameException Column
zipWithColumns c -> b -> a
f Column
left' Column
right')
-- Conditionals
interpret DataFrame
df expr :: Expr a
expr@(If Expr Bool
cond Expr a
l Expr a
r) = (DataFrameException -> DataFrameException)
-> Either DataFrameException (TypedColumn a)
-> Either DataFrameException (TypedColumn a)
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (String -> DataFrameException -> DataFrameException
handleInterpretException (Expr a -> String
forall a. Show a => a -> String
show Expr a
expr)) (Either DataFrameException (TypedColumn a)
 -> Either DataFrameException (TypedColumn a))
-> Either DataFrameException (TypedColumn a)
-> Either DataFrameException (TypedColumn a)
forall a b. (a -> b) -> a -> b
$ do
    (TColumn Column
conditions) <- forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @Bool DataFrame
df Expr Bool
cond
    (TColumn Column
left) <- forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @a DataFrame
df Expr a
l
    (TColumn Column
right) <- forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @a DataFrame
df Expr a
r
    let branch :: Bool -> (a, a) -> a
branch (Bool
c :: Bool) (a
l' :: a, a
r' :: a) = if Bool
c then a
l' else a
r'
    (Column -> TypedColumn a)
-> Either DataFrameException Column
-> Either DataFrameException (TypedColumn a)
forall a b.
(a -> b)
-> Either DataFrameException a -> Either DataFrameException b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn ((Bool -> (a, a) -> a)
-> Column -> Column -> Either DataFrameException Column
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
(a -> b -> c)
-> Column -> Column -> Either DataFrameException Column
zipWithColumns Bool -> (a, a) -> a
branch Column
conditions (Column -> Column -> Column
zipColumns Column
left Column
right))
interpret DataFrame
df expression :: Expr a
expression@(AggVector Expr b
expr Text
op (v b -> a
f :: v b -> c)) = do
    (TColumn Column
column) <- forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @b DataFrame
df Expr b
expr
    -- Helper for errors. Should probably find a way of throwing this
    -- without leaking the fact that we use `Vector` to users.
    let aggTypeError :: String -> DataFrameException
aggTypeError String
expected =
            TypeErrorContext (v b) () -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                ( MkTypeErrorContext
                    { userType :: Either String (TypeRep (v b))
userType = TypeRep (v b) -> Either String (TypeRep (v b))
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(v b))
                    , expectedType :: Either String (TypeRep ())
expectedType = String -> Either String (TypeRep ())
forall a b. a -> Either a b
Left String
expected :: Either String (TypeRep ())
                    , callingFunctionName :: Maybe String
callingFunctionName = String -> Maybe String
forall a. a -> Maybe a
Just String
"interpret"
                    , errorColumnName :: Maybe String
errorColumnName = Maybe String
forall a. Maybe a
Nothing
                    }
                )
    let processColumn ::
            (Columnable d) => d -> Either DataFrameException (TypedColumn a)
        processColumn :: forall d.
Columnable d =>
d -> Either DataFrameException (TypedColumn a)
processColumn d
col = case TypeRep (v b) -> TypeRep d -> Maybe (v b :~: d)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(v b)) (d -> TypeRep d
forall a. Typeable a => a -> TypeRep a
typeOf d
col) of
            Just v b :~: d
Refl -> forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @c DataFrame
df (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit (v b -> a
f d
v b
col))
            Maybe (v b :~: d)
Nothing -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left (DataFrameException -> Either DataFrameException (TypedColumn a))
-> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. (a -> b) -> a -> b
$ String -> DataFrameException
aggTypeError (TypeRep d -> String
forall a. Show a => a -> String
show (d -> TypeRep d
forall a. Typeable a => a -> TypeRep a
typeOf d
col))
    case Column
column of
        (BoxedColumn Vector a
col) -> Vector a -> Either DataFrameException (TypedColumn a)
forall d.
Columnable d =>
d -> Either DataFrameException (TypedColumn a)
processColumn Vector a
col
        (OptionalColumn Vector (Maybe a)
col) -> Vector (Maybe a) -> Either DataFrameException (TypedColumn a)
forall d.
Columnable d =>
d -> Either DataFrameException (TypedColumn a)
processColumn Vector (Maybe a)
col
        (UnboxedColumn Vector a
col) -> Vector a -> Either DataFrameException (TypedColumn a)
forall d.
Columnable d =>
d -> Either DataFrameException (TypedColumn a)
processColumn Vector a
col
interpret DataFrame
df expression :: Expr a
expression@(AggReduce Expr a
expr Text
op (a -> a -> a
f :: a -> a -> a)) = (DataFrameException -> DataFrameException)
-> Either DataFrameException (TypedColumn a)
-> Either DataFrameException (TypedColumn a)
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (String -> DataFrameException -> DataFrameException
handleInterpretException (Expr a -> String
forall a. Show a => a -> String
show Expr a
expr)) (Either DataFrameException (TypedColumn a)
 -> Either DataFrameException (TypedColumn a))
-> Either DataFrameException (TypedColumn a)
-> Either DataFrameException (TypedColumn a)
forall a b. (a -> b) -> a -> b
$ do
    (TColumn Column
column) <- forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @a DataFrame
df Expr a
expr
    a
value <- (a -> a -> a) -> Column -> Either DataFrameException a
forall a.
Columnable a =>
(a -> a -> a) -> Column -> Either DataFrameException a
foldl1Column a -> a -> a
f Column
column
    TypedColumn a -> Either DataFrameException (TypedColumn a)
forall a. a -> Either DataFrameException a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypedColumn a -> Either DataFrameException (TypedColumn a))
-> TypedColumn a -> Either DataFrameException (TypedColumn a)
forall a b. (a -> b) -> a -> b
$ Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$ Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$ Int -> a -> Vector a
forall a. Int -> a -> Vector a
V.replicate ((Int, Int) -> Int
forall a b. (a, b) -> a
fst ((Int, Int) -> Int) -> (Int, Int) -> Int
forall a b. (a -> b) -> a -> b
$ DataFrame -> (Int, Int)
dataframeDimensions DataFrame
df) a
value
interpret DataFrame
df expression :: Expr a
expression@(AggNumericVector Expr b
expr Text
op (Vector b -> a
f :: VU.Vector b -> c)) = (DataFrameException -> DataFrameException)
-> Either DataFrameException (TypedColumn a)
-> Either DataFrameException (TypedColumn a)
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (String -> DataFrameException -> DataFrameException
handleInterpretException (Expr a -> String
forall a. Show a => a -> String
show Expr a
expression)) (Either DataFrameException (TypedColumn a)
 -> Either DataFrameException (TypedColumn a))
-> Either DataFrameException (TypedColumn a)
-> Either DataFrameException (TypedColumn a)
forall a b. (a -> b) -> a -> b
$ do
    (TColumn Column
column) <- forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @b DataFrame
df Expr b
expr
    case Column
column of
        (UnboxedColumn (Vector a
v :: VU.Vector d)) -> case TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b) of
            Just a :~: b
Refl ->
                TypedColumn a -> Either DataFrameException (TypedColumn a)
forall a. a -> Either DataFrameException a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypedColumn a -> Either DataFrameException (TypedColumn a))
-> TypedColumn a -> Either DataFrameException (TypedColumn a)
forall a b. (a -> b) -> a -> b
$ Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$ Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$ Int -> a -> Vector a
forall a. Int -> a -> Vector a
V.replicate ((Int, Int) -> Int
forall a b. (a, b) -> a
fst ((Int, Int) -> Int) -> (Int, Int) -> Int
forall a b. (a -> b) -> a -> b
$ DataFrame -> (Int, Int)
dataframeDimensions DataFrame
df) (Vector b -> a
f Vector b
Vector a
v)
            Maybe (a :~: b)
Nothing ->
                DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left (DataFrameException -> Either DataFrameException (TypedColumn a))
-> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. (a -> b) -> a -> b
$
                    TypeErrorContext b a -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                        ( Either String (TypeRep b)
-> Either String (TypeRep a)
-> Maybe String
-> Maybe String
-> TypeErrorContext b a
forall a b.
Either String (TypeRep a)
-> Either String (TypeRep b)
-> Maybe String
-> Maybe String
-> TypeErrorContext a b
MkTypeErrorContext
                            (TypeRep b -> Either String (TypeRep b)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b))
                            (TypeRep a -> Either String (TypeRep a)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d))
                            (String -> Maybe String
forall a. a -> Maybe a
Just String
"interpret")
                            (String -> Maybe String
forall a. a -> Maybe a
Just (Expr a -> String
forall a. Show a => a -> String
show Expr a
expression))
                        )
        Column
_ -> String -> Either DataFrameException (TypedColumn a)
forall a. HasCallStack => String -> a
error String
"Trying to apply numeric computation to non-numeric column"
interpret DataFrame
df expression :: Expr a
expression@(AggFold Expr b
expr Text
op a
start (a -> b -> a
f :: (a -> b -> a))) = (DataFrameException -> DataFrameException)
-> Either DataFrameException (TypedColumn a)
-> Either DataFrameException (TypedColumn a)
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (String -> DataFrameException -> DataFrameException
handleInterpretException (Expr a -> String
forall a. Show a => a -> String
show Expr a
expression)) (Either DataFrameException (TypedColumn a)
 -> Either DataFrameException (TypedColumn a))
-> Either DataFrameException (TypedColumn a)
-> Either DataFrameException (TypedColumn a)
forall a b. (a -> b) -> a -> b
$ do
    (TColumn Column
column) <- forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @b DataFrame
df Expr b
expr
    a
value <- (a -> b -> a) -> a -> Column -> Either DataFrameException a
forall a b.
(Columnable a, Columnable b) =>
(b -> a -> b) -> b -> Column -> Either DataFrameException b
foldlColumn a -> b -> a
f a
start Column
column
    TypedColumn a -> Either DataFrameException (TypedColumn a)
forall a. a -> Either DataFrameException a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypedColumn a -> Either DataFrameException (TypedColumn a))
-> TypedColumn a -> Either DataFrameException (TypedColumn a)
forall a b. (a -> b) -> a -> b
$ Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$ Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$ Int -> a -> Vector a
forall a. Int -> a -> Vector a
V.replicate ((Int, Int) -> Int
forall a b. (a, b) -> a
fst ((Int, Int) -> Int) -> (Int, Int) -> Int
forall a b. (a -> b) -> a -> b
$ DataFrame -> (Int, Int)
dataframeDimensions DataFrame
df) a
value

data AggregationResult a
    = UnAggregated Column
    | Aggregated (TypedColumn a)

interpretAggregation ::
    forall a.
    (Columnable a) =>
    GroupedDataFrame -> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation :: forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation GroupedDataFrame
gdf (Lit a
value) =
    AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
        TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
            Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$
                Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$
                    Int -> a -> Vector a
forall a. Int -> a -> Vector a
V.replicate (Vector Int -> Int
forall a. Unbox a => Vector a -> Int
VU.length (GroupedDataFrame -> Vector Int
offsets GroupedDataFrame
gdf) Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) a
value
interpretAggregation gdf :: GroupedDataFrame
gdf@(Grouped DataFrame
df [Text]
names Vector Int
indices Vector Int
os) (Col Text
name) = case Text -> DataFrame -> Maybe Column
getColumn Text
name DataFrame
df of
    Maybe Column
Nothing -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> [Text] -> DataFrameException
ColumnNotFoundException Text
name Text
"" (Map Text Int -> [Text]
forall k a. Map k a -> [k]
M.keys (Map Text Int -> [Text]) -> Map Text Int -> [Text]
forall a b. (a -> b) -> a -> b
$ DataFrame -> Map Text Int
columnIndices DataFrame
df)
    Just (BoxedColumn Vector a
col) -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated (Column -> AggregationResult a) -> Column -> AggregationResult a
forall a b. (a -> b) -> a -> b
$ Vector (Vector a) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Vector a) -> Column) -> Vector (Vector a) -> Column
forall a b. (a -> b) -> a -> b
$ Vector a -> Vector Int -> Vector Int -> Vector (Vector a)
forall a.
Columnable a =>
Vector a -> Vector Int -> Vector Int -> Vector (Vector a)
mkUnaggregatedColumnBoxed Vector a
col Vector Int
os Vector Int
indices
    Just (OptionalColumn Vector (Maybe a)
col) -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated (Column -> AggregationResult a) -> Column -> AggregationResult a
forall a b. (a -> b) -> a -> b
$ Vector (Vector (Maybe a)) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Vector (Maybe a)) -> Column)
-> Vector (Vector (Maybe a)) -> Column
forall a b. (a -> b) -> a -> b
$ Vector (Maybe a)
-> Vector Int -> Vector Int -> Vector (Vector (Maybe a))
forall a.
Columnable a =>
Vector a -> Vector Int -> Vector Int -> Vector (Vector a)
mkUnaggregatedColumnBoxed Vector (Maybe a)
col Vector Int
os Vector Int
indices
    Just (UnboxedColumn Vector a
col) ->
        AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated (Column -> AggregationResult a) -> Column -> AggregationResult a
forall a b. (a -> b) -> a -> b
$ Vector (Vector a) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Vector a) -> Column) -> Vector (Vector a) -> Column
forall a b. (a -> b) -> a -> b
$ Vector a -> Vector Int -> Vector Int -> Vector (Vector a)
forall a.
(Columnable a, Unbox a) =>
Vector a -> Vector Int -> Vector Int -> Vector (Vector a)
mkUnaggregatedColumnUnboxed Vector a
col Vector Int
os Vector Int
indices
interpretAggregation GroupedDataFrame
gdf expression :: Expr a
expression@(UnaryOp Text
_ (b -> a
f :: c -> d) Expr b
expr) =
    case forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @c GroupedDataFrame
gdf Expr b
expr of
        Left (TypeMismatchException TypeErrorContext a b
context) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show expr)
                        }
                    )
        Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
        Right (UnAggregated Column
unaggregated) -> case Column
unaggregated of
            BoxedColumn (Vector a
col :: V.Vector b) -> case TypeRep a -> TypeRep (Vector b) -> Maybe (a :~: Vector b)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(V.Vector c)) of
                Just a :~: Vector b
Refl -> case forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @d of
                    SBool (Unboxable a)
SFalse -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated (Column -> AggregationResult a) -> Column -> AggregationResult a
forall a b. (a -> b) -> a -> b
$ Vector (Vector a) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Vector a) -> Column) -> Vector (Vector a) -> Column
forall a b. (a -> b) -> a -> b
$ (Vector b -> Vector a) -> Vector (Vector b) -> Vector (Vector a)
forall a b. (a -> b) -> Vector a -> Vector b
V.map ((b -> a) -> Vector b -> Vector a
forall a b. (a -> b) -> Vector a -> Vector b
V.map b -> a
f) Vector a
Vector (Vector b)
col
                    SBool (Unboxable a)
STrue ->
                        AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                            Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated (Column -> AggregationResult a) -> Column -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                                Vector (Vector a) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Vector a) -> Column) -> Vector (Vector a) -> Column
forall a b. (a -> b) -> a -> b
$
                                    (Vector b -> Vector a) -> Vector (Vector b) -> Vector (Vector a)
forall a b. (a -> b) -> Vector a -> Vector b
V.map (forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert @V.Vector @d @VU.Vector (Vector a -> Vector a)
-> (Vector b -> Vector a) -> Vector b -> Vector a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> a) -> Vector b -> Vector a
forall a b. (a -> b) -> Vector a -> Vector b
V.map b -> a
f) Vector a
Vector (Vector b)
col
                Maybe (a :~: Vector b)
Nothing -> case TypeRep a -> TypeRep (Vector b) -> Maybe (a :~: Vector b)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(VU.Vector c)) of
                    Maybe (a :~: Vector b)
Nothing -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ forall a b.
(Typeable a, Typeable b) =>
String -> DataFrameException
nestedTypeException @b @c (Expr a -> String
forall a. Show a => a -> String
show Expr a
expression)
                    Just a :~: Vector b
Refl -> case (forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @c, forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @a) of
                        (SBool (Unboxable b)
SFalse, SBool (Unboxable a)
_) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Boxed type inside an unboxed column"
                        (SBool (Unboxable b)
STrue, SBool (Unboxable a)
STrue) -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated (Column -> AggregationResult a) -> Column -> AggregationResult a
forall a b. (a -> b) -> a -> b
$ Vector (Vector a) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Vector a) -> Column) -> Vector (Vector a) -> Column
forall a b. (a -> b) -> a -> b
$ (Vector b -> Vector a) -> Vector (Vector b) -> Vector (Vector a)
forall a b. (a -> b) -> Vector a -> Vector b
V.map ((b -> a) -> Vector b -> Vector a
forall a b. (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
VU.map b -> a
f) Vector a
Vector (Vector b)
col
                        (SBool (Unboxable b)
STrue, SBool (Unboxable a)
_) -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated (Column -> AggregationResult a) -> Column -> AggregationResult a
forall a b. (a -> b) -> a -> b
$ Vector (Vector a) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Vector a) -> Column) -> Vector (Vector a) -> Column
forall a b. (a -> b) -> a -> b
$ (Vector b -> Vector a) -> Vector (Vector b) -> Vector (Vector a)
forall a b. (a -> b) -> Vector a -> Vector b
V.map ((b -> a) -> Vector b -> Vector a
forall a b. (a -> b) -> Vector a -> Vector b
V.map b -> a
f (Vector b -> Vector a)
-> (Vector b -> Vector b) -> Vector b -> Vector a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector b -> Vector b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
VU.convert) Vector a
Vector (Vector b)
col
            Column
_ -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Aggregated into a non-boxed column"
        Right (Aggregated (TColumn Column
aggregated)) -> case (b -> a) -> Column -> Either DataFrameException Column
forall b c.
(Columnable b, Columnable c, UnboxIf c) =>
(b -> c) -> Column -> Either DataFrameException Column
mapColumn b -> a
f Column
aggregated of
            Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
            Right Column
col -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$ Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn Column
col
interpretAggregation GroupedDataFrame
gdf expression :: Expr a
expression@(BinaryOp Text
name (c -> b -> a
f :: c -> d -> e) Expr c
left (Lit (b
right :: g))) = case TypeRep b -> TypeRep b -> Maybe (b :~: b)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @g) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
    Just b :~: b
Refl -> GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation GroupedDataFrame
gdf (Text -> (c -> a) -> Expr c -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
name (c -> b -> a
`f` b
right) Expr c
left)
    Maybe (b :~: b)
Nothing ->
        DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
            TypeErrorContext b b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                ( MkTypeErrorContext
                    { userType :: Either String (TypeRep b)
userType = TypeRep b -> Either String (TypeRep b)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @g)
                    , expectedType :: Either String (TypeRep b)
expectedType = TypeRep b -> Either String (TypeRep b)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d)
                    , callingFunctionName :: Maybe String
callingFunctionName = String -> Maybe String
forall a. a -> Maybe a
Just String
"interpretAggregation"
                    , errorColumnName :: Maybe String
errorColumnName = String -> Maybe String
forall a. a -> Maybe a
Just (Expr a -> String
forall a. Show a => a -> String
show Expr a
expression)
                    }
                )
interpretAggregation GroupedDataFrame
gdf expression :: Expr a
expression@(BinaryOp Text
name (c -> b -> a
f :: c -> d -> e) (Lit (c
left :: g)) Expr b
right) = case TypeRep c -> TypeRep c -> Maybe (c :~: c)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @g) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @c) of
    Just c :~: c
Refl -> GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation GroupedDataFrame
gdf (Text -> (b -> a) -> Expr b -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
name (c -> b -> a
f c
left) Expr b
right)
    Maybe (c :~: c)
Nothing ->
        DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
            TypeErrorContext c c -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                ( MkTypeErrorContext
                    { userType :: Either String (TypeRep c)
userType = TypeRep c -> Either String (TypeRep c)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @g)
                    , expectedType :: Either String (TypeRep c)
expectedType = TypeRep c -> Either String (TypeRep c)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @c)
                    , callingFunctionName :: Maybe String
callingFunctionName = String -> Maybe String
forall a. a -> Maybe a
Just String
"interpretAggregation"
                    , errorColumnName :: Maybe String
errorColumnName = String -> Maybe String
forall a. a -> Maybe a
Just (Expr a -> String
forall a. Show a => a -> String
show Expr a
expression)
                    }
                )
interpretAggregation GroupedDataFrame
gdf expression :: Expr a
expression@(BinaryOp Text
_ (c -> b -> a
f :: c -> d -> e) Expr c
left Expr b
right) =
    case (forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @c GroupedDataFrame
gdf Expr c
left, forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @d GroupedDataFrame
gdf Expr b
right) of
        (Right (Aggregated (TColumn Column
left')), Right (Aggregated (TColumn Column
right'))) -> case (c -> b -> a)
-> Column -> Column -> Either DataFrameException Column
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
(a -> b -> c)
-> Column -> Column -> Either DataFrameException Column
zipWithColumns c -> b -> a
f Column
left' Column
right' of
            Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
            Right Column
col -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$ Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn Column
col
        (Right (UnAggregated Column
left'), Right (UnAggregated Column
right')) -> case (Column
left', Column
right') of
            (BoxedColumn (Vector a
l :: V.Vector m), BoxedColumn (Vector a
r :: V.Vector n)) -> case TypeRep a -> TypeRep (Vector c) -> Maybe (a :~: Vector c)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @m) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(VU.Vector c)) of
                Just a :~: Vector c
Refl -> case TypeRep a -> TypeRep (Vector b) -> Maybe (a :~: Vector b)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @n) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(VU.Vector d)) of
                    Just a :~: Vector b
Refl -> case (forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @c, forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @d, forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @e) of
                        (SBool (Unboxable c)
STrue, SBool (Unboxable b)
STrue, SBool (Unboxable a)
STrue) ->
                            AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated (Column -> AggregationResult a) -> Column -> AggregationResult a
forall a b. (a -> b) -> a -> b
$ Vector (Vector a) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Vector a) -> Column) -> Vector (Vector a) -> Column
forall a b. (a -> b) -> a -> b
$ (Vector c -> Vector b -> Vector a)
-> Vector (Vector c) -> Vector (Vector b) -> Vector (Vector a)
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith ((c -> b -> a) -> Vector c -> Vector b -> Vector a
forall a b c.
(Unbox a, Unbox b, Unbox c) =>
(a -> b -> c) -> Vector a -> Vector b -> Vector c
VU.zipWith c -> b -> a
f) Vector a
Vector (Vector c)
l Vector a
Vector (Vector b)
r
                        (SBool (Unboxable c)
STrue, SBool (Unboxable b)
STrue, SBool (Unboxable a)
SFalse) ->
                            AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                                Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated (Column -> AggregationResult a) -> Column -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                                    Vector (Vector a) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Vector a) -> Column) -> Vector (Vector a) -> Column
forall a b. (a -> b) -> a -> b
$
                                        (Vector c -> Vector b -> Vector a)
-> Vector (Vector c) -> Vector (Vector b) -> Vector (Vector a)
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith (\Vector c
l' Vector b
r' -> (c -> b -> a) -> Vector c -> Vector b -> Vector a
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith c -> b -> a
f (Vector c -> Vector c
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert Vector c
l') (Vector b -> Vector b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert Vector b
r')) Vector a
Vector (Vector c)
l Vector a
Vector (Vector b)
r
                        (SBool (Unboxable c)
_, SBool (Unboxable b)
_, SBool (Unboxable a)
_) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Boxed vectors contain unboxed types"
                    Maybe (a :~: Vector b)
Nothing -> case TypeRep a -> TypeRep (Vector b) -> Maybe (a :~: Vector b)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @n) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(V.Vector d)) of
                        Just a :~: Vector b
Refl -> case forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @c of
                            SBool (Unboxable c)
STrue ->
                                AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                                    Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated (Column -> AggregationResult a) -> Column -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                                        Vector (Vector a) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Vector a) -> Column) -> Vector (Vector a) -> Column
forall a b. (a -> b) -> a -> b
$
                                            (Vector c -> Vector b -> Vector a)
-> Vector (Vector c) -> Vector (Vector b) -> Vector (Vector a)
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith ((c -> b -> a) -> Vector c -> Vector b -> Vector a
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith c -> b -> a
f (Vector c -> Vector b -> Vector a)
-> (Vector c -> Vector c) -> Vector c -> Vector b -> Vector a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector c -> Vector c
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert) Vector a
Vector (Vector c)
l Vector a
Vector (Vector b)
r
                            SBool (Unboxable c)
SFalse -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Unboxed vectors contain boxed types"
                        Maybe (a :~: Vector b)
Nothing -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ forall a b.
(Typeable a, Typeable b) =>
String -> DataFrameException
nestedTypeException @n @d (Expr b -> String
forall a. Show a => a -> String
show Expr b
right)
                Maybe (a :~: Vector c)
Nothing -> case TypeRep a -> TypeRep (Vector c) -> Maybe (a :~: Vector c)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @m) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(V.Vector c)) of
                    Maybe (a :~: Vector c)
Nothing -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ forall a b.
(Typeable a, Typeable b) =>
String -> DataFrameException
nestedTypeException @m @c (Expr c -> String
forall a. Show a => a -> String
show Expr c
left)
                    Just a :~: Vector c
Refl -> case TypeRep a -> TypeRep (Vector b) -> Maybe (a :~: Vector b)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @n) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(VU.Vector d)) of
                        Just a :~: Vector b
Refl -> case (forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @d, forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @e) of
                            (SBool (Unboxable b)
STrue, SBool (Unboxable a)
STrue) ->
                                AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                                    Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated (Column -> AggregationResult a) -> Column -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                                        Vector (Vector a) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Vector a) -> Column) -> Vector (Vector a) -> Column
forall a b. (a -> b) -> a -> b
$
                                            (Vector c -> Vector b -> Vector a)
-> Vector (Vector c) -> Vector (Vector b) -> Vector (Vector a)
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith
                                                (\Vector c
l' Vector b
r' -> forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert @V.Vector @e @VU.Vector (Vector a -> Vector a) -> Vector a -> Vector a
forall a b. (a -> b) -> a -> b
$ (c -> b -> a) -> Vector c -> Vector b -> Vector a
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith c -> b -> a
f Vector c
l' (Vector b -> Vector b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert Vector b
r'))
                                                Vector a
Vector (Vector c)
l
                                                Vector a
Vector (Vector b)
r
                            (SBool (Unboxable b)
STrue, SBool (Unboxable a)
SFalse) ->
                                AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                                    Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated (Column -> AggregationResult a) -> Column -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                                        Vector (Vector a) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Vector a) -> Column) -> Vector (Vector a) -> Column
forall a b. (a -> b) -> a -> b
$
                                            (Vector c -> Vector b -> Vector a)
-> Vector (Vector c) -> Vector (Vector b) -> Vector (Vector a)
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith (\Vector c
l' Vector b
r' -> (c -> b -> a) -> Vector c -> Vector b -> Vector a
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith c -> b -> a
f Vector c
l' (Vector b -> Vector b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert Vector b
r')) Vector a
Vector (Vector c)
l Vector a
Vector (Vector b)
r
                            (SBool (Unboxable b)
_, SBool (Unboxable a)
_) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Unboxed vectors contain boxed types"
                        Maybe (a :~: Vector b)
Nothing -> case TypeRep a -> TypeRep (Vector b) -> Maybe (a :~: Vector b)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @n) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(V.Vector d)) of
                            Just a :~: Vector b
Refl -> case forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @e of
                                SBool (Unboxable a)
SFalse ->
                                    AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                                        Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated (Column -> AggregationResult a) -> Column -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                                            Vector (Vector a) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Vector a) -> Column) -> Vector (Vector a) -> Column
forall a b. (a -> b) -> a -> b
$
                                                (Vector c -> Vector b -> Vector a)
-> Vector (Vector c) -> Vector (Vector b) -> Vector (Vector a)
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith ((c -> b -> a) -> Vector c -> Vector b -> Vector a
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith c -> b -> a
f (Vector c -> Vector b -> Vector a)
-> (Vector c -> Vector c) -> Vector c -> Vector b -> Vector a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector c -> Vector c
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert) Vector a
Vector (Vector c)
l Vector a
Vector (Vector b)
r
                                SBool (Unboxable a)
STrue ->
                                    AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                                        Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated (Column -> AggregationResult a) -> Column -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                                            Vector (Vector a) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Vector a) -> Column) -> Vector (Vector a) -> Column
forall a b. (a -> b) -> a -> b
$
                                                (Vector c -> Vector b -> Vector a)
-> Vector (Vector c) -> Vector (Vector b) -> Vector (Vector a)
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith (\Vector c
l' Vector b
r' -> forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert @V.Vector @e @VU.Vector (Vector a -> Vector a) -> Vector a -> Vector a
forall a b. (a -> b) -> a -> b
$ (c -> b -> a) -> Vector c -> Vector b -> Vector a
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith c -> b -> a
f Vector c
l' Vector b
r') Vector a
Vector (Vector c)
l Vector a
Vector (Vector b)
r
                            Maybe (a :~: Vector b)
Nothing -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ forall a b.
(Typeable a, Typeable b) =>
String -> DataFrameException
nestedTypeException @n @d (Expr b -> String
forall a. Show a => a -> String
show Expr b
right)
            (Column, Column)
_ -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Aggregated into a non-boxed column"
        (Right AggregationResult c
_, Right AggregationResult b
_) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                Text -> Text -> DataFrameException
AggregatedAndNonAggregatedException (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Expr c -> String
forall a. Show a => a -> String
show Expr c
left) (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Expr b -> String
forall a. Show a => a -> String
show Expr b
right)
        (Left (TypeMismatchException TypeErrorContext a b
context), Either DataFrameException (AggregationResult b)
_) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show left)
                        }
                    )
        (Left DataFrameException
e, Either DataFrameException (AggregationResult b)
_) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
        (Either DataFrameException (AggregationResult c)
_, Left (TypeMismatchException TypeErrorContext a b
context)) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show right)
                        }
                    )
        (Either DataFrameException (AggregationResult c)
_, Left DataFrameException
e) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
interpretAggregation GroupedDataFrame
gdf expression :: Expr a
expression@(If Expr Bool
cond (Lit a
l) (Lit a
r)) =
    case forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @Bool GroupedDataFrame
gdf Expr Bool
cond of
        Right (Aggregated (TColumn Column
conditions)) -> case (Bool -> a) -> Column -> Either DataFrameException Column
forall b c.
(Columnable b, Columnable c, UnboxIf c) =>
(b -> c) -> Column -> Either DataFrameException Column
mapColumn
            (\(Bool
c :: Bool) -> if Bool
c then a
l else a
r)
            Column
conditions of
            Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
            Right Column
v -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn Column
v)
        Right (UnAggregated Column
conditions) -> case forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @a of
            SBool (Unboxable a)
STrue -> case (Vector Bool -> Vector a)
-> Column -> Either DataFrameException Column
forall b c.
(Columnable b, Columnable c, UnboxIf c) =>
(b -> c) -> Column -> Either DataFrameException Column
mapColumn
                (\(Vector Bool
c :: VU.Vector Bool) -> (Bool -> a) -> Vector Bool -> Vector a
forall a b. (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
VU.map (\Bool
c' -> if Bool
c' then a
l else a
r) Vector Bool
c)
                Column
conditions of
                Left (TypeMismatchException TypeErrorContext a b
context) ->
                    DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                        TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                            ( TypeErrorContext a b
context
                                { callingFunctionName = Just "interpretAggregation"
                                , errorColumnName = Just (show expression)
                                }
                            )
                Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
                Right Column
v -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated Column
v
            SBool (Unboxable a)
SFalse -> case (Vector Bool -> Vector a)
-> Column -> Either DataFrameException Column
forall b c.
(Columnable b, Columnable c, UnboxIf c) =>
(b -> c) -> Column -> Either DataFrameException Column
mapColumn
                (\(Vector Bool
c :: VU.Vector Bool) -> (Bool -> a) -> Vector Bool -> Vector a
forall a b. (a -> b) -> Vector a -> Vector b
V.map (\Bool
c' -> if Bool
c' then a
l else a
r) (Vector Bool -> Vector Bool
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
VU.convert Vector Bool
c))
                Column
conditions of
                Left (TypeMismatchException TypeErrorContext a b
context) ->
                    DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                        TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                            ( TypeErrorContext a b
context
                                { callingFunctionName = Just "interpretAggregation"
                                , errorColumnName = Just (show expression)
                                }
                            )
                Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
                Right Column
v -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated Column
v
        Left (TypeMismatchException TypeErrorContext a b
context) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show cond)
                        }
                    )
        Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
interpretAggregation GroupedDataFrame
gdf expression :: Expr a
expression@(If Expr Bool
cond (Lit a
l) Expr a
r) =
    case ( forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @Bool GroupedDataFrame
gdf Expr Bool
cond
         , forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @a GroupedDataFrame
gdf Expr a
r
         ) of
        ( Right (Aggregated (TColumn Column
conditions))
            , Right (Aggregated (TColumn Column
right))
            ) -> case (Bool -> a -> a)
-> Column -> Column -> Either DataFrameException Column
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
(a -> b -> c)
-> Column -> Column -> Either DataFrameException Column
zipWithColumns
                (\(Bool
c :: Bool) (a
r' :: a) -> if Bool
c then a
l else a
r')
                Column
conditions
                Column
right of
                Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
                Right Column
v -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn Column
v)
        ( Right (UnAggregated Column
conditions)
            , Right (UnAggregated right :: Column
right@(BoxedColumn (Vector a
right' :: V.Vector c)))
            ) -> case TypeRep (Vector a) -> TypeRep a -> Maybe (Vector a :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(V.Vector a)) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @c) of
                Just Vector a :~: a
Refl -> case (Vector Bool -> Vector a -> Vector a)
-> Column -> Column -> Either DataFrameException Column
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
(a -> b -> c)
-> Column -> Column -> Either DataFrameException Column
zipWithColumns
                    ( \(Vector Bool
c :: VU.Vector Bool) (Vector a
r' :: V.Vector a) ->
                        (Bool -> a -> a) -> Vector Bool -> Vector a -> Vector a
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith
                            (\Bool
c' a
r'' -> if Bool
c' then a
l else a
r'')
                            (Vector Bool -> Vector Bool
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert Vector Bool
c)
                            Vector a
r'
                    )
                    Column
conditions
                    Column
right of
                    Left (TypeMismatchException TypeErrorContext a b
context) ->
                        DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                            TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                                ( TypeErrorContext a b
context
                                    { callingFunctionName = Just "interpretAggregation"
                                    , errorColumnName = Just (show expression)
                                    }
                                )
                    Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
                    Right Column
v -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated Column
v
                Maybe (Vector a :~: a)
Nothing -> case TypeRep (Vector a) -> TypeRep a -> Maybe (Vector a :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(VU.Vector a)) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @c) of
                    Maybe (Vector a :~: a)
Nothing -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ forall a b.
(Typeable a, Typeable b) =>
String -> DataFrameException
nestedTypeException @c @a (Expr a -> String
forall a. Show a => a -> String
show Expr a
expression)
                    Just Vector a :~: a
Refl -> case forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @a of
                        SBool (Unboxable a)
SFalse -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Boxed type in unboxed column"
                        SBool (Unboxable a)
STrue -> case (Vector Bool -> Vector a -> Vector a)
-> Column -> Column -> Either DataFrameException Column
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
(a -> b -> c)
-> Column -> Column -> Either DataFrameException Column
zipWithColumns
                            ( \(Vector Bool
c :: VU.Vector Bool) (Vector a
r' :: VU.Vector a) ->
                                (Bool -> a -> a) -> Vector Bool -> Vector a -> Vector a
forall a b c.
(Unbox a, Unbox b, Unbox c) =>
(a -> b -> c) -> Vector a -> Vector b -> Vector c
VU.zipWith
                                    (\Bool
c' a
r'' -> if Bool
c' then a
l else a
r'')
                                    Vector Bool
c
                                    Vector a
r'
                            )
                            Column
conditions
                            Column
right of
                            Left (TypeMismatchException TypeErrorContext a b
context) ->
                                DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                                    TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                                        ( TypeErrorContext a b
context
                                            { callingFunctionName = Just "interpretAggregation"
                                            , errorColumnName = Just (show expression)
                                            }
                                        )
                            Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
                            Right Column
v -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated Column
v
        (Right AggregationResult Bool
_, Right AggregationResult a
_) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                Text -> Text -> DataFrameException
AggregatedAndNonAggregatedException (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ a -> String
forall a. Show a => a -> String
show a
l) (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Expr a -> String
forall a. Show a => a -> String
show Expr a
r)
        (Left (TypeMismatchException TypeErrorContext a b
context), Either DataFrameException (AggregationResult a)
_) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show cond)
                        }
                    )
        (Left DataFrameException
e, Either DataFrameException (AggregationResult a)
_) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
        (Either DataFrameException (AggregationResult Bool)
_, Left (TypeMismatchException TypeErrorContext a b
context)) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show r)
                        }
                    )
        (Either DataFrameException (AggregationResult Bool)
_, Left DataFrameException
e) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
interpretAggregation GroupedDataFrame
gdf expression :: Expr a
expression@(If Expr Bool
cond Expr a
l (Lit a
r)) =
    case ( forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @Bool GroupedDataFrame
gdf Expr Bool
cond
         , forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @a GroupedDataFrame
gdf Expr a
l
         ) of
        ( Right (Aggregated (TColumn Column
conditions))
            , Right (Aggregated (TColumn Column
left))
            ) -> case (Bool -> a -> a)
-> Column -> Column -> Either DataFrameException Column
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
(a -> b -> c)
-> Column -> Column -> Either DataFrameException Column
zipWithColumns
                (\(Bool
c :: Bool) (a
l' :: a) -> if Bool
c then a
l' else a
r)
                Column
conditions
                Column
left of
                Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
                Right Column
v -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn Column
v)
        ( Right (UnAggregated Column
conditions)
            , Right (UnAggregated left :: Column
left@(BoxedColumn (Vector a
left' :: V.Vector c)))
            ) -> case TypeRep (Vector a) -> TypeRep a -> Maybe (Vector a :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(V.Vector a)) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @c) of
                Just Vector a :~: a
Refl -> case (Vector Bool -> Vector a -> Vector a)
-> Column -> Column -> Either DataFrameException Column
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
(a -> b -> c)
-> Column -> Column -> Either DataFrameException Column
zipWithColumns
                    ( \(Vector Bool
c :: VU.Vector Bool) (Vector a
l' :: V.Vector a) ->
                        (Bool -> a -> a) -> Vector Bool -> Vector a -> Vector a
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith
                            (\Bool
c' a
l'' -> if Bool
c' then a
l'' else a
r)
                            (Vector Bool -> Vector Bool
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert Vector Bool
c)
                            Vector a
l'
                    )
                    Column
conditions
                    Column
left of
                    Left (TypeMismatchException TypeErrorContext a b
context) ->
                        DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                            TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                                ( TypeErrorContext a b
context
                                    { callingFunctionName = Just "interpretAggregation"
                                    , errorColumnName = Just (show expression)
                                    }
                                )
                    Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
                    Right Column
v -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated Column
v
                Maybe (Vector a :~: a)
Nothing -> case TypeRep (Vector a) -> TypeRep a -> Maybe (Vector a :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(VU.Vector a)) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @c) of
                    Maybe (Vector a :~: a)
Nothing -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ forall a b.
(Typeable a, Typeable b) =>
String -> DataFrameException
nestedTypeException @c @a (Expr a -> String
forall a. Show a => a -> String
show Expr a
expression)
                    Just Vector a :~: a
Refl -> case forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @a of
                        SBool (Unboxable a)
SFalse -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Boxed type in unboxed column"
                        SBool (Unboxable a)
STrue -> case (Vector Bool -> Vector a -> Vector a)
-> Column -> Column -> Either DataFrameException Column
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
(a -> b -> c)
-> Column -> Column -> Either DataFrameException Column
zipWithColumns
                            ( \(Vector Bool
c :: VU.Vector Bool) (Vector a
l' :: VU.Vector a) ->
                                (Bool -> a -> a) -> Vector Bool -> Vector a -> Vector a
forall a b c.
(Unbox a, Unbox b, Unbox c) =>
(a -> b -> c) -> Vector a -> Vector b -> Vector c
VU.zipWith
                                    (\Bool
c' a
l'' -> if Bool
c' then a
l'' else a
r)
                                    Vector Bool
c
                                    Vector a
l'
                            )
                            Column
conditions
                            Column
left of
                            Left (TypeMismatchException TypeErrorContext a b
context) ->
                                DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                                    TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                                        ( TypeErrorContext a b
context
                                            { callingFunctionName = Just "interpretAggregation"
                                            , errorColumnName = Just (show expression)
                                            }
                                        )
                            Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
                            Right Column
v -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated Column
v
        (Right AggregationResult Bool
_, Right AggregationResult a
_) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                Text -> Text -> DataFrameException
AggregatedAndNonAggregatedException (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Expr a -> String
forall a. Show a => a -> String
show Expr a
l) (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ a -> String
forall a. Show a => a -> String
show a
r)
        (Left (TypeMismatchException TypeErrorContext a b
context), Either DataFrameException (AggregationResult a)
_) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show cond)
                        }
                    )
        (Left DataFrameException
e, Either DataFrameException (AggregationResult a)
_) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
        (Either DataFrameException (AggregationResult Bool)
_, Left (TypeMismatchException TypeErrorContext a b
context)) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show r)
                        }
                    )
        (Either DataFrameException (AggregationResult Bool)
_, Left DataFrameException
e) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
interpretAggregation GroupedDataFrame
gdf expression :: Expr a
expression@(If Expr Bool
cond Expr a
l Expr a
r) =
    case ( forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @Bool GroupedDataFrame
gdf Expr Bool
cond
         , forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @a GroupedDataFrame
gdf Expr a
l
         , forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @a GroupedDataFrame
gdf Expr a
r
         ) of
        ( Right (Aggregated (TColumn Column
conditions))
            , Right (Aggregated (TColumn Column
left))
            , Right (Aggregated (TColumn Column
right))
            ) -> case (Bool -> (a, a) -> a)
-> Column -> Column -> Either DataFrameException Column
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
(a -> b -> c)
-> Column -> Column -> Either DataFrameException Column
zipWithColumns
                (\(Bool
c :: Bool) (a
l' :: a, a
r' :: a) -> if Bool
c then a
l' else a
r')
                Column
conditions
                (Column -> Column -> Column
zipColumns Column
left Column
right) of
                Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
                Right Column
v -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn Column
v)
        ( Right (UnAggregated Column
conditions)
            , Right (UnAggregated left :: Column
left@(BoxedColumn (Vector a
left' :: V.Vector b)))
            , Right (UnAggregated right :: Column
right@(BoxedColumn (Vector a
right' :: V.Vector c)))
            ) -> case TypeRep a -> TypeRep a -> Maybe (a :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @c) of
                Maybe (a :~: a)
Nothing ->
                    DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                        TypeErrorContext a a -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                            ( MkTypeErrorContext
                                { userType :: Either String (TypeRep a)
userType = TypeRep a -> Either String (TypeRep a)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b)
                                , expectedType :: Either String (TypeRep a)
expectedType = TypeRep a -> Either String (TypeRep a)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @c)
                                , callingFunctionName :: Maybe String
callingFunctionName = String -> Maybe String
forall a. a -> Maybe a
Just String
"interpretAggregation"
                                , errorColumnName :: Maybe String
errorColumnName = String -> Maybe String
forall a. a -> Maybe a
Just (Expr a -> String
forall a. Show a => a -> String
show Expr a
expression)
                                }
                            )
                Just a :~: a
Refl -> case TypeRep (Vector a) -> TypeRep a -> Maybe (Vector a :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(V.Vector a)) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b) of
                    Just Vector a :~: a
Refl -> case (Vector Bool -> (Vector a, Vector a) -> Vector a)
-> Column -> Column -> Either DataFrameException Column
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
(a -> b -> c)
-> Column -> Column -> Either DataFrameException Column
zipWithColumns
                        ( \(Vector Bool
c :: VU.Vector Bool) (Vector a
l' :: V.Vector a, Vector a
r' :: V.Vector a) ->
                            (Bool -> (a, a) -> a) -> Vector Bool -> Vector (a, a) -> Vector a
forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
V.zipWith
                                (\Bool
c' (a
l'', a
r'') -> if Bool
c' then a
l'' else a
r'')
                                (Vector Bool -> Vector Bool
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert Vector Bool
c)
                                (Vector a -> Vector a -> Vector (a, a)
forall a b. Vector a -> Vector b -> Vector (a, b)
V.zip Vector a
l' Vector a
r')
                        )
                        Column
conditions
                        (Column -> Column -> Column
zipColumns Column
left Column
right) of
                        Left (TypeMismatchException TypeErrorContext a b
context) ->
                            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                                    ( TypeErrorContext a b
context
                                        { callingFunctionName = Just "interpretAggregation"
                                        , errorColumnName = Just (show expression)
                                        }
                                    )
                        Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
                        Right Column
v -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated Column
v
                    Maybe (Vector a :~: a)
Nothing -> case TypeRep (Vector a) -> TypeRep a -> Maybe (Vector a :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(VU.Vector a)) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b) of
                        Maybe (Vector a :~: a)
Nothing -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ forall a b.
(Typeable a, Typeable b) =>
String -> DataFrameException
nestedTypeException @b @a (Expr a -> String
forall a. Show a => a -> String
show Expr a
expression)
                        Just Vector a :~: a
Refl -> case forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @a of
                            SBool (Unboxable a)
SFalse -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Boxed type in unboxed column"
                            SBool (Unboxable a)
STrue -> case (Vector Bool -> (Vector a, Vector a) -> Vector a)
-> Column -> Column -> Either DataFrameException Column
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
(a -> b -> c)
-> Column -> Column -> Either DataFrameException Column
zipWithColumns
                                ( \(Vector Bool
c :: VU.Vector Bool) (Vector a
l' :: VU.Vector a, Vector a
r' :: VU.Vector a) ->
                                    (Bool -> (a, a) -> a) -> Vector Bool -> Vector (a, a) -> Vector a
forall a b c.
(Unbox a, Unbox b, Unbox c) =>
(a -> b -> c) -> Vector a -> Vector b -> Vector c
VU.zipWith
                                        (\Bool
c' (a
l'', a
r'') -> if Bool
c' then a
l'' else a
r'')
                                        Vector Bool
c
                                        (Vector a -> Vector a -> Vector (a, a)
forall a b.
(Unbox a, Unbox b) =>
Vector a -> Vector b -> Vector (a, b)
VU.zip Vector a
l' Vector a
r')
                                )
                                Column
conditions
                                (Column -> Column -> Column
zipColumns Column
left Column
right) of
                                Left (TypeMismatchException TypeErrorContext a b
context) ->
                                    DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                                        TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                                            ( TypeErrorContext a b
context
                                                { callingFunctionName = Just "interpretAggregation"
                                                , errorColumnName = Just (show expression)
                                                }
                                            )
                                Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
                                Right Column
v -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Column -> AggregationResult a
forall a. Column -> AggregationResult a
UnAggregated Column
v
        (Right AggregationResult Bool
_, Right AggregationResult a
_, Right AggregationResult a
_) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                Text -> Text -> DataFrameException
AggregatedAndNonAggregatedException (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Expr a -> String
forall a. Show a => a -> String
show Expr a
l) (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Expr a -> String
forall a. Show a => a -> String
show Expr a
r)
        (Left (TypeMismatchException TypeErrorContext a b
context), Either DataFrameException (AggregationResult a)
_, Either DataFrameException (AggregationResult a)
_) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show cond)
                        }
                    )
        (Left DataFrameException
e, Either DataFrameException (AggregationResult a)
_, Either DataFrameException (AggregationResult a)
_) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
        (Either DataFrameException (AggregationResult Bool)
_, Left (TypeMismatchException TypeErrorContext a b
context), Either DataFrameException (AggregationResult a)
_) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show l)
                        }
                    )
        (Either DataFrameException (AggregationResult Bool)
_, Left DataFrameException
e, Either DataFrameException (AggregationResult a)
_) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
        (Either DataFrameException (AggregationResult Bool)
_, Either DataFrameException (AggregationResult a)
_, Left (TypeMismatchException TypeErrorContext a b
context)) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show r)
                        }
                    )
        (Either DataFrameException (AggregationResult Bool)
_, Either DataFrameException (AggregationResult a)
_, Left DataFrameException
e) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
interpretAggregation gdf :: GroupedDataFrame
gdf@(Grouped DataFrame
df [Text]
names Vector Int
indices Vector Int
os) expression :: Expr a
expression@(AggVector Expr b
expr Text
op (v b -> a
f :: v b -> c)) =
    case forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @b GroupedDataFrame
gdf Expr b
expr of
        Right (UnAggregated (BoxedColumn (Vector a
col :: V.Vector d))) -> case TypeRep (v b) -> TypeRep a -> Maybe (v b :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(v b)) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
            Maybe (v b :~: a)
Nothing -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ forall a b.
(Typeable a, Typeable b) =>
String -> DataFrameException
nestedTypeException @d @b (Expr b -> String
forall a. Show a => a -> String
show Expr b
expr)
            Just v b :~: a
Refl -> case TypeRep v -> TypeRep Vector -> Maybe (v :~: Vector)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
forall (a :: * -> *) (b :: * -> *).
TypeRep a -> TypeRep b -> Maybe (a :~: b)
testEquality (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: * -> *). Typeable a => TypeRep a
typeRep @v) (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: * -> *). Typeable a => TypeRep a
typeRep @V.Vector) of
                Maybe (v :~: Vector)
Nothing -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$ Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$ Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$ (v b -> a) -> Vector (v b) -> Vector a
forall a b. (a -> b) -> Vector a -> Vector b
V.map (v b -> a
f (v b -> a) -> (v b -> v b) -> v b -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v b -> v b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert) Vector a
Vector (v b)
col
                Just v :~: Vector
Refl -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$ Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$ Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$ (v b -> a) -> Vector (v b) -> Vector a
forall a b. (a -> b) -> Vector a -> Vector b
V.map v b -> a
f Vector a
Vector (v b)
col
        Right (UnAggregated Column
_) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Aggregated into non-boxed column"
        Right (Aggregated (TColumn (BoxedColumn (Vector a
col :: V.Vector d)))) -> case TypeRep b -> TypeRep a -> Maybe (b :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
            Just b :~: a
Refl -> case TypeRep v -> TypeRep Vector -> Maybe (v :~: Vector)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
forall (a :: * -> *) (b :: * -> *).
TypeRep a -> TypeRep b -> Maybe (a :~: b)
testEquality (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: * -> *). Typeable a => TypeRep a
typeRep @v) (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: * -> *). Typeable a => TypeRep a
typeRep @V.Vector) of
                Just v :~: Vector
Refl -> forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @c GroupedDataFrame
gdf (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit (v b -> a
f v b
Vector a
col))
                Maybe (v :~: Vector)
Nothing -> forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @c GroupedDataFrame
gdf (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit ((v b -> a
f (v b -> a) -> (Vector b -> v b) -> Vector b -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector b -> v b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert) Vector b
Vector a
col))
            Maybe (b :~: a)
Nothing ->
                DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                    TypeErrorContext b a -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                        ( MkTypeErrorContext
                            { userType :: Either String (TypeRep b)
userType = TypeRep b -> Either String (TypeRep b)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b)
                            , expectedType :: Either String (TypeRep a)
expectedType = TypeRep a -> Either String (TypeRep a)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d)
                            , callingFunctionName :: Maybe String
callingFunctionName = String -> Maybe String
forall a. a -> Maybe a
Just String
"interpretAggregation"
                            , errorColumnName :: Maybe String
errorColumnName = String -> Maybe String
forall a. a -> Maybe a
Just (Expr b -> String
forall a. Show a => a -> String
show Expr b
expr)
                            }
                        )
        Right (Aggregated (TColumn (UnboxedColumn (Vector a
col :: VU.Vector d)))) -> case TypeRep b -> TypeRep a -> Maybe (b :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
            Just b :~: a
Refl -> case TypeRep v -> TypeRep Vector -> Maybe (v :~: Vector)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
forall (a :: * -> *) (b :: * -> *).
TypeRep a -> TypeRep b -> Maybe (a :~: b)
testEquality (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: * -> *). Typeable a => TypeRep a
typeRep @v) (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: * -> *). Typeable a => TypeRep a
typeRep @VU.Vector) of
                Just v :~: Vector
Refl -> forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @c GroupedDataFrame
gdf (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit (v b -> a
f v b
Vector a
col))
                Maybe (v :~: Vector)
Nothing -> forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @c GroupedDataFrame
gdf (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit ((v b -> a
f (v b -> a) -> (Vector b -> v b) -> Vector b -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector b -> v b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
VU.convert) Vector b
Vector a
col))
            Maybe (b :~: a)
Nothing ->
                DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                    TypeErrorContext b a -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                        ( MkTypeErrorContext
                            { userType :: Either String (TypeRep b)
userType = TypeRep b -> Either String (TypeRep b)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b)
                            , expectedType :: Either String (TypeRep a)
expectedType = TypeRep a -> Either String (TypeRep a)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d)
                            , callingFunctionName :: Maybe String
callingFunctionName = String -> Maybe String
forall a. a -> Maybe a
Just String
"interpretAggregation"
                            , errorColumnName :: Maybe String
errorColumnName = String -> Maybe String
forall a. a -> Maybe a
Just (Expr b -> String
forall a. Show a => a -> String
show Expr b
expr)
                            }
                        )
        Right (Aggregated (TColumn (OptionalColumn (Vector (Maybe a)
col :: V.Vector d)))) -> case TypeRep b -> TypeRep (Maybe a) -> Maybe (b :~: Maybe a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
            Just b :~: Maybe a
Refl -> case TypeRep v -> TypeRep Vector -> Maybe (v :~: Vector)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
forall (a :: * -> *) (b :: * -> *).
TypeRep a -> TypeRep b -> Maybe (a :~: b)
testEquality (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: * -> *). Typeable a => TypeRep a
typeRep @v) (forall {k} (a :: k). Typeable a => TypeRep a
forall (a :: * -> *). Typeable a => TypeRep a
typeRep @V.Vector) of
                Just v :~: Vector
Refl -> forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @c GroupedDataFrame
gdf (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit (v b -> a
f v b
Vector (Maybe a)
col))
                Maybe (v :~: Vector)
Nothing -> forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @c GroupedDataFrame
gdf (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit ((v b -> a
f (v b -> a) -> (Vector b -> v b) -> Vector b -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector b -> v b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert) Vector b
Vector (Maybe a)
col))
            Maybe (b :~: Maybe a)
Nothing ->
                DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                    TypeErrorContext b (Maybe a) -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                        ( MkTypeErrorContext
                            { userType :: Either String (TypeRep b)
userType = TypeRep b -> Either String (TypeRep b)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b)
                            , expectedType :: Either String (TypeRep (Maybe a))
expectedType = TypeRep (Maybe a) -> Either String (TypeRep (Maybe a))
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d)
                            , callingFunctionName :: Maybe String
callingFunctionName = String -> Maybe String
forall a. a -> Maybe a
Just String
"interpretAggregation"
                            , errorColumnName :: Maybe String
errorColumnName = String -> Maybe String
forall a. a -> Maybe a
Just (Expr b -> String
forall a. Show a => a -> String
show Expr b
expr)
                            }
                        )
        (Left (TypeMismatchException TypeErrorContext a b
context)) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show expression)
                        }
                    )
        (Left DataFrameException
e) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
interpretAggregation gdf :: GroupedDataFrame
gdf@(Grouped DataFrame
df [Text]
names Vector Int
indices Vector Int
os) expression :: Expr a
expression@(AggNumericVector (Col Text
name) Text
op (Vector b -> a
f :: VU.Vector b -> c)) =
    case Text -> DataFrame -> Maybe Column
getColumn Text
name DataFrame
df of
        -- TODO(mchavinda): Fix the compedium of type errors here
        -- This is mostly done help with the benchmarking.
        Maybe Column
Nothing -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> [Text] -> DataFrameException
ColumnNotFoundException Text
name Text
"" (Map Text Int -> [Text]
forall k a. Map k a -> [k]
M.keys (Map Text Int -> [Text]) -> Map Text Int -> [Text]
forall a b. (a -> b) -> a -> b
$ DataFrame -> Map Text Int
columnIndices DataFrame
df)
        Just (BoxedColumn Vector a
col) -> String -> Either DataFrameException (AggregationResult a)
forall a. HasCallStack => String -> a
error String
"Type mismatch."
        Just (OptionalColumn Vector (Maybe a)
col) -> String -> Either DataFrameException (AggregationResult a)
forall a. HasCallStack => String -> a
error String
"Type mismatch."
        Just (UnboxedColumn (Vector a
col :: VU.Vector d)) -> case TypeRep b -> TypeRep a -> Maybe (b :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
            Just b :~: a
Refl -> case TypeRep a -> TypeRep a -> Maybe (a :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @c) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @a) of
                Just a :~: a
Refl ->
                    AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                        TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                            Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$
                                Vector a -> Column
forall a. (Columnable a, Unbox a) => Vector a -> Column
fromUnboxedVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$
                                    Vector a -> Vector Int -> Vector Int -> (Vector a -> a) -> Vector a
forall a b.
(Columnable a, Unbox a, Columnable b, Unbox b) =>
Vector a -> Vector Int -> Vector Int -> (Vector a -> b) -> Vector b
mkAggregatedColumnUnboxed Vector a
col Vector Int
os Vector Int
indices Vector b -> a
Vector a -> a
f
                Maybe (a :~: a)
Nothing -> String -> Either DataFrameException (AggregationResult a)
forall a. HasCallStack => String -> a
error String
"Type mismatch"
            Maybe (b :~: a)
Nothing -> String -> Either DataFrameException (AggregationResult a)
forall a. HasCallStack => String -> a
error String
"Type mismatch"
interpretAggregation gdf :: GroupedDataFrame
gdf@(Grouped DataFrame
df [Text]
names Vector Int
indices Vector Int
os) expression :: Expr a
expression@(AggNumericVector Expr b
expr Text
op (Vector b -> a
f :: VU.Vector b -> c)) =
    case forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @b GroupedDataFrame
gdf Expr b
expr of
        (Left (TypeMismatchException TypeErrorContext a b
context)) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show expression)
                        }
                    )
        (Left DataFrameException
e) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
        Right (UnAggregated (BoxedColumn (Vector a
col :: V.Vector d))) -> case TypeRep (Vector b) -> TypeRep a -> Maybe (Vector b :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(VU.Vector b)) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
            Maybe (Vector b :~: a)
Nothing -> case TypeRep (Vector Int) -> TypeRep a -> Maybe (Vector Int :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(VU.Vector Int)) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
                Maybe (Vector Int :~: a)
Nothing -> case TypeRep (Vector Integer)
-> TypeRep a -> Maybe (Vector Integer :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(V.Vector Integer)) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
                    Maybe (Vector Integer :~: a)
Nothing -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ forall a b.
(Typeable a, Typeable b) =>
String -> DataFrameException
nestedTypeException @d @b (Expr b -> String
forall a. Show a => a -> String
show Expr b
expr)
                    Just Vector Integer :~: a
Refl ->
                        AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                            TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                                Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$
                                    Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$
                                        (Vector Integer -> a) -> Vector (Vector Integer) -> Vector a
forall a b. (a -> b) -> Vector a -> Vector b
V.map (Vector b -> a
f (Vector b -> a)
-> (Vector Integer -> Vector b) -> Vector Integer -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector b -> Vector b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
VU.convert (Vector b -> Vector b)
-> (Vector Integer -> Vector b) -> Vector Integer -> Vector b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Integer -> b) -> Vector Integer -> Vector b
forall a b. (a -> b) -> Vector a -> Vector b
V.map Integer -> b
forall a b. (Integral a, Num b) => a -> b
fromIntegral) Vector a
Vector (Vector Integer)
col
                Just Vector Int :~: a
Refl ->
                    AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                        TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                            Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$
                                Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$
                                    (Vector b -> a) -> Vector (Vector b) -> Vector a
forall a b. (a -> b) -> Vector a -> Vector b
V.map Vector b -> a
f ((Vector Int -> Vector b)
-> Vector (Vector Int) -> Vector (Vector b)
forall a b. (a -> b) -> Vector a -> Vector b
V.map ((Int -> b) -> Vector Int -> Vector b
forall a b. (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
VU.map Int -> b
forall a b. (Integral a, Num b) => a -> b
fromIntegral) Vector a
Vector (Vector Int)
col)
            Just Vector b :~: a
Refl -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$ Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$ Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$ (Vector b -> a) -> Vector (Vector b) -> Vector a
forall a b. (a -> b) -> Vector a -> Vector b
V.map Vector b -> a
f Vector a
Vector (Vector b)
col
        Right (UnAggregated Column
_) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Aggregated into non-boxed column"
        Right (Aggregated (TColumn (BoxedColumn (Vector a
col :: V.Vector d)))) -> case TypeRep Integer -> TypeRep a -> Maybe (Integer :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Integer) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
            Just Integer :~: a
Refl -> forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @c GroupedDataFrame
gdf (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit ((Vector b -> a
f (Vector b -> a) -> (Vector a -> Vector b) -> Vector a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector b -> Vector b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert (Vector b -> Vector b)
-> (Vector a -> Vector b) -> Vector a -> Vector b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> Vector a -> Vector b
forall a b. (a -> b) -> Vector a -> Vector b
V.map a -> b
forall a b. (Integral a, Num b) => a -> b
fromIntegral) Vector a
col))
            Maybe (Integer :~: a)
Nothing ->
                DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                    TypeErrorContext b a -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                        ( MkTypeErrorContext
                            { userType :: Either String (TypeRep b)
userType = TypeRep b -> Either String (TypeRep b)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b)
                            , expectedType :: Either String (TypeRep a)
expectedType = TypeRep a -> Either String (TypeRep a)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d)
                            , callingFunctionName :: Maybe String
callingFunctionName = String -> Maybe String
forall a. a -> Maybe a
Just String
"interpretAggregation"
                            , errorColumnName :: Maybe String
errorColumnName = String -> Maybe String
forall a. a -> Maybe a
Just (Expr b -> String
forall a. Show a => a -> String
show Expr b
expr)
                            }
                        )
        Right (Aggregated (TColumn (UnboxedColumn (Vector a
col :: VU.Vector d)))) -> case TypeRep b -> TypeRep a -> Maybe (b :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
            Just b :~: a
Refl -> forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @c GroupedDataFrame
gdf (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit (Vector b -> a
f Vector b
Vector a
col))
            Maybe (b :~: a)
Nothing ->
                DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                    TypeErrorContext b a -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                        ( MkTypeErrorContext
                            { userType :: Either String (TypeRep b)
userType = TypeRep b -> Either String (TypeRep b)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b)
                            , expectedType :: Either String (TypeRep a)
expectedType = TypeRep a -> Either String (TypeRep a)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d)
                            , callingFunctionName :: Maybe String
callingFunctionName = String -> Maybe String
forall a. a -> Maybe a
Just String
"interpretAggregation"
                            , errorColumnName :: Maybe String
errorColumnName = String -> Maybe String
forall a. a -> Maybe a
Just (Expr b -> String
forall a. Show a => a -> String
show Expr b
expr)
                            }
                        )
        Right (Aggregated (TColumn (OptionalColumn (Vector (Maybe a)
col :: V.Vector (Maybe d))))) -> case TypeRep b -> TypeRep a -> Maybe (b :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
            Just b :~: a
Refl ->
                forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @c
                    GroupedDataFrame
gdf
                    (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit ((Vector b -> a
f (Vector b -> a)
-> (Vector (Maybe b) -> Vector b) -> Vector (Maybe b) -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector b -> Vector b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert (Vector b -> Vector b)
-> (Vector (Maybe b) -> Vector b) -> Vector (Maybe b) -> Vector b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe b -> b) -> Vector (Maybe b) -> Vector b
forall a b. (a -> b) -> Vector a -> Vector b
V.map (b -> Maybe b -> b
forall a. a -> Maybe a -> a
fromMaybe b
0) (Vector (Maybe b) -> Vector b)
-> (Vector (Maybe b) -> Vector (Maybe b))
-> Vector (Maybe b)
-> Vector b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe b -> Bool) -> Vector (Maybe b) -> Vector (Maybe b)
forall a. (a -> Bool) -> Vector a -> Vector a
V.filter Maybe b -> Bool
forall a. Maybe a -> Bool
isJust) Vector (Maybe b)
Vector (Maybe a)
col))
            Maybe (b :~: a)
Nothing ->
                DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                    TypeErrorContext b a -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                        ( MkTypeErrorContext
                            { userType :: Either String (TypeRep b)
userType = TypeRep b -> Either String (TypeRep b)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b)
                            , expectedType :: Either String (TypeRep a)
expectedType = TypeRep a -> Either String (TypeRep a)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d)
                            , callingFunctionName :: Maybe String
callingFunctionName = String -> Maybe String
forall a. a -> Maybe a
Just String
"interpretAggregation"
                            , errorColumnName :: Maybe String
errorColumnName = String -> Maybe String
forall a. a -> Maybe a
Just (Expr b -> String
forall a. Show a => a -> String
show Expr b
expr)
                            }
                        )
interpretAggregation gdf :: GroupedDataFrame
gdf@(Grouped DataFrame
df [Text]
names Vector Int
indices Vector Int
os) expression :: Expr a
expression@(AggReduce (Col Text
name) Text
op (a -> a -> a
f :: a -> a -> a)) =
    case Text -> DataFrame -> Maybe Column
getColumn Text
name DataFrame
df of
        Maybe Column
Nothing -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> [Text] -> DataFrameException
ColumnNotFoundException Text
name Text
"" (Map Text Int -> [Text]
forall k a. Map k a -> [k]
M.keys (Map Text Int -> [Text]) -> Map Text Int -> [Text]
forall a b. (a -> b) -> a -> b
$ DataFrame -> Map Text Int
columnIndices DataFrame
df)
        Just (BoxedColumn (Vector a
col :: V.Vector d)) -> case TypeRep a -> TypeRep a -> Maybe (a :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @a) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
            Maybe (a :~: a)
Nothing -> String -> Either DataFrameException (AggregationResult a)
forall a. HasCallStack => String -> a
error String
"Type mismatch"
            Just a :~: a
Refl ->
                AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                    TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                        Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$
                            Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$
                                Vector a -> Vector Int -> Vector Int -> (a -> a -> a) -> Vector a
forall a.
Vector a -> Vector Int -> Vector Int -> (a -> a -> a) -> Vector a
mkReducedColumnBoxed Vector a
col Vector Int
os Vector Int
indices a -> a -> a
a -> a -> a
f
        Just (OptionalColumn (Vector (Maybe a)
col :: V.Vector d)) -> case TypeRep a -> TypeRep (Maybe a) -> Maybe (a :~: Maybe a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @a) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
            Maybe (a :~: Maybe a)
Nothing -> String -> Either DataFrameException (AggregationResult a)
forall a. HasCallStack => String -> a
error String
"Type mismatch"
            Just a :~: Maybe a
Refl ->
                AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                    TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                        Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$
                            Vector (Maybe a) -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector (Maybe a) -> Column) -> Vector (Maybe a) -> Column
forall a b. (a -> b) -> a -> b
$
                                Vector (Maybe a)
-> Vector Int
-> Vector Int
-> (Maybe a -> Maybe a -> Maybe a)
-> Vector (Maybe a)
forall a.
Vector a -> Vector Int -> Vector Int -> (a -> a -> a) -> Vector a
mkReducedColumnBoxed Vector (Maybe a)
col Vector Int
os Vector Int
indices a -> a -> a
Maybe a -> Maybe a -> Maybe a
f
        Just (UnboxedColumn (Vector a
col :: VU.Vector d)) -> case TypeRep a -> TypeRep a -> Maybe (a :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @a) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
            Just a :~: a
Refl ->
                AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                    TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                        Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$
                            Vector a -> Column
forall a. (Columnable a, Unbox a) => Vector a -> Column
fromUnboxedVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$
                                Vector a -> Vector Int -> Vector Int -> (a -> a -> a) -> Vector a
forall a.
Unbox a =>
Vector a -> Vector Int -> Vector Int -> (a -> a -> a) -> Vector a
mkReducedColumnUnboxed Vector a
col Vector Int
os Vector Int
indices a -> a -> a
a -> a -> a
f
            Maybe (a :~: a)
Nothing -> String -> Either DataFrameException (AggregationResult a)
forall a. HasCallStack => String -> a
error String
"Type mismatch"
interpretAggregation gdf :: GroupedDataFrame
gdf@(Grouped DataFrame
df [Text]
names Vector Int
indices Vector Int
os) expression :: Expr a
expression@(AggReduce Expr a
expr Text
op (a -> a -> a
f :: a -> a -> a)) =
    case forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @a GroupedDataFrame
gdf Expr a
expr of
        (Left (TypeMismatchException TypeErrorContext a b
context)) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show expression)
                        }
                    )
        (Left DataFrameException
e) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
        Right (UnAggregated (BoxedColumn (Vector a
col :: V.Vector d))) -> case TypeRep (Vector a) -> TypeRep a -> Maybe (Vector a :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(V.Vector a)) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
            Maybe (Vector a :~: a)
Nothing -> case TypeRep (Vector a) -> TypeRep a -> Maybe (Vector a :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(VU.Vector a)) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
                Maybe (Vector a :~: a)
Nothing -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ forall a b.
(Typeable a, Typeable b) =>
String -> DataFrameException
nestedTypeException @d @a (Expr a -> String
forall a. Show a => a -> String
show Expr a
expr)
                Just Vector a :~: a
Refl -> case forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @a of
                    SBool (Unboxable a)
STrue ->
                        AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                            TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                                Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$
                                    Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$
                                        (Vector a -> a) -> Vector (Vector a) -> Vector a
forall a b. (a -> b) -> Vector a -> Vector b
V.map ((a -> a -> a) -> Vector a -> a
forall a. Unbox a => (a -> a -> a) -> Vector a -> a
VU.foldl1' a -> a -> a
f) Vector a
Vector (Vector a)
col
                    SBool (Unboxable a)
SFalse -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Boxed type inside an unboxed column"
            Just Vector a :~: a
Refl ->
                AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                    TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$
                        Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$
                            Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$
                                (Vector a -> a) -> Vector (Vector a) -> Vector a
forall a b. (a -> b) -> Vector a -> Vector b
V.map ((a -> a -> a) -> Vector a -> a
forall a. (a -> a -> a) -> Vector a -> a
V.foldl1' a -> a -> a
f) Vector a
Vector (Vector a)
col
        Right (UnAggregated Column
_) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Aggregated into non-boxed column"
        Right (Aggregated (TColumn Column
column)) -> case (a -> a -> a) -> Column -> Either DataFrameException a
forall a.
Columnable a =>
(a -> a -> a) -> Column -> Either DataFrameException a
foldl1Column a -> a -> a
f Column
column of
            Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
            Right a
value -> forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @a GroupedDataFrame
gdf (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit a
value)
interpretAggregation gdf :: GroupedDataFrame
gdf@(Grouped DataFrame
df [Text]
names Vector Int
indices Vector Int
os) expression :: Expr a
expression@(AggFold Expr b
expr Text
op a
s (a -> b -> a
f :: (a -> b -> a))) =
    case forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @b GroupedDataFrame
gdf Expr b
expr of
        (Left (TypeMismatchException TypeErrorContext a b
context)) ->
            DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$
                TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpretAggregation"
                        , errorColumnName = Just (show expression)
                        }
                    )
        (Left DataFrameException
e) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
        Right (UnAggregated (BoxedColumn (Vector a
col :: V.Vector d))) -> case TypeRep (Vector b) -> TypeRep a -> Maybe (Vector b :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(V.Vector b)) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
            Just Vector b :~: a
Refl -> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$ Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$ Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$ (Vector b -> a) -> Vector (Vector b) -> Vector a
forall a b. (a -> b) -> Vector a -> Vector b
V.map ((a -> b -> a) -> a -> Vector b -> a
forall a b. (a -> b -> a) -> a -> Vector b -> a
V.foldl' a -> b -> a
f a
s) Vector a
Vector (Vector b)
col
            Maybe (Vector b :~: a)
Nothing -> case TypeRep (Vector b) -> TypeRep a -> Maybe (Vector b :~: a)
forall a b. TypeRep a -> TypeRep b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(VU.Vector b)) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @d) of
                Just Vector b :~: a
Refl -> case forall a. SBoolI (Unboxable a) => SBool (Unboxable a)
sUnbox @b of
                    SBool (Unboxable b)
STrue ->
                        AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. b -> Either a b
Right (AggregationResult a
 -> Either DataFrameException (AggregationResult a))
-> AggregationResult a
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ TypedColumn a -> AggregationResult a
forall a. TypedColumn a -> AggregationResult a
Aggregated (TypedColumn a -> AggregationResult a)
-> TypedColumn a -> AggregationResult a
forall a b. (a -> b) -> a -> b
$ Column -> TypedColumn a
forall a. Columnable a => Column -> TypedColumn a
TColumn (Column -> TypedColumn a) -> Column -> TypedColumn a
forall a b. (a -> b) -> a -> b
$ Vector a -> Column
forall a.
(Columnable a, ColumnifyRep (KindOf a) a) =>
Vector a -> Column
fromVector (Vector a -> Column) -> Vector a -> Column
forall a b. (a -> b) -> a -> b
$ (Vector b -> a) -> Vector (Vector b) -> Vector a
forall a b. (a -> b) -> Vector a -> Vector b
V.map ((a -> b -> a) -> a -> Vector b -> a
forall b a. Unbox b => (a -> b -> a) -> a -> Vector b -> a
VU.foldl' a -> b -> a
f a
s) Vector a
Vector (Vector b)
col
                    SBool (Unboxable b)
SFalse -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Boxed type inside an unboxed column"
                Maybe (Vector b :~: a)
Nothing -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ forall a b.
(Typeable a, Typeable b) =>
String -> DataFrameException
nestedTypeException @d @b (Expr b -> String
forall a. Show a => a -> String
show Expr b
expr)
        Right (UnAggregated Column
_) -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left (DataFrameException
 -> Either DataFrameException (AggregationResult a))
-> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. (a -> b) -> a -> b
$ Text -> DataFrameException
InternalException Text
"Aggregated into non-boxed column"
        Right (Aggregated (TColumn Column
column)) -> case (a -> b -> a) -> a -> Column -> Either DataFrameException a
forall a b.
(Columnable a, Columnable b) =>
(b -> a -> b) -> b -> Column -> Either DataFrameException b
foldlColumn a -> b -> a
f a
s Column
column of
            Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
            Right a
value -> forall a.
Columnable a =>
GroupedDataFrame
-> Expr a -> Either DataFrameException (AggregationResult a)
interpretAggregation @a GroupedDataFrame
gdf (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit a
value)

handleInterpretException :: String -> DataFrameException -> DataFrameException
handleInterpretException :: String -> DataFrameException -> DataFrameException
handleInterpretException String
errorLocation (TypeMismatchException TypeErrorContext a b
context) = Maybe String
-> Maybe String -> TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
Maybe String
-> Maybe String -> TypeErrorContext a b -> DataFrameException
mkTypeMismatchException (String -> Maybe String
forall a. a -> Maybe a
Just String
"interpret") (String -> Maybe String
forall a. a -> Maybe a
Just String
errorLocation) TypeErrorContext a b
context
handleInterpretException String
_ DataFrameException
e = DataFrameException
e

numRows :: DataFrame -> Int
numRows :: DataFrame -> Int
numRows DataFrame
df = (Int, Int) -> Int
forall a b. (a, b) -> a
fst (DataFrame -> (Int, Int)
dataframeDimensions DataFrame
df)

mkUnaggregatedColumnBoxed ::
    forall a.
    (Columnable a) =>
    V.Vector a -> VU.Vector Int -> VU.Vector Int -> V.Vector (V.Vector a)
mkUnaggregatedColumnBoxed :: forall a.
Columnable a =>
Vector a -> Vector Int -> Vector Int -> Vector (Vector a)
mkUnaggregatedColumnBoxed Vector a
col Vector Int
os Vector Int
indices =
    let
        sorted :: Vector a
sorted = Vector a -> Vector Int -> Vector a
forall a. Vector a -> Vector Int -> Vector a
V.unsafeBackpermute Vector a
col (Vector Int -> Vector Int
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
V.convert Vector Int
indices)
        n :: Int -> Int
n Int
i = Vector Int
os Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
- (Vector Int
os Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` Int
i)
        start :: Int -> Int
start Int
i = Vector Int
os Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` Int
i
     in
        Int -> (Int -> Vector a) -> Vector (Vector a)
forall a. Int -> (Int -> a) -> Vector a
V.generate
            (Vector Int -> Int
forall a. Unbox a => Vector a -> Int
VU.length Vector Int
os Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
            ( \Int
i ->
                Int -> Int -> Vector a -> Vector a
forall a. Int -> Int -> Vector a -> Vector a
V.unsafeSlice (Int -> Int
start Int
i) (Int -> Int
n Int
i) Vector a
sorted
            )

mkUnaggregatedColumnUnboxed ::
    forall a.
    (Columnable a, VU.Unbox a) =>
    VU.Vector a -> VU.Vector Int -> VU.Vector Int -> V.Vector (VU.Vector a)
mkUnaggregatedColumnUnboxed :: forall a.
(Columnable a, Unbox a) =>
Vector a -> Vector Int -> Vector Int -> Vector (Vector a)
mkUnaggregatedColumnUnboxed Vector a
col Vector Int
os Vector Int
indices =
    let
        sorted :: Vector a
sorted = Vector a -> Vector Int -> Vector a
forall a. Unbox a => Vector a -> Vector Int -> Vector a
VU.unsafeBackpermute Vector a
col Vector Int
indices
        n :: Int -> Int
n Int
i = Vector Int
os Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
- (Vector Int
os Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` Int
i)
        start :: Int -> Int
start Int
i = Vector Int
os Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` Int
i
     in
        Int -> (Int -> Vector a) -> Vector (Vector a)
forall a. Int -> (Int -> a) -> Vector a
V.generate
            (Vector Int -> Int
forall a. Unbox a => Vector a -> Int
VU.length Vector Int
os Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
            ( \Int
i ->
                Int -> Int -> Vector a -> Vector a
forall a. Unbox a => Int -> Int -> Vector a -> Vector a
VU.unsafeSlice (Int -> Int
start Int
i) (Int -> Int
n Int
i) Vector a
sorted
            )

mkAggregatedColumnUnboxed ::
    forall a b.
    (Columnable a, VU.Unbox a, Columnable b, VU.Unbox b) =>
    VU.Vector a ->
    VU.Vector Int ->
    VU.Vector Int ->
    (VU.Vector a -> b) ->
    VU.Vector b
mkAggregatedColumnUnboxed :: forall a b.
(Columnable a, Unbox a, Columnable b, Unbox b) =>
Vector a -> Vector Int -> Vector Int -> (Vector a -> b) -> Vector b
mkAggregatedColumnUnboxed Vector a
col Vector Int
os Vector Int
indices Vector a -> b
f =
    let
        sorted :: Vector a
sorted = Vector a -> Vector Int -> Vector a
forall a. Unbox a => Vector a -> Vector Int -> Vector a
VU.unsafeBackpermute Vector a
col Vector Int
indices
        n :: Int -> Int
n Int
i = Vector Int
os Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
- (Vector Int
os Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` Int
i)
        start :: Int -> Int
start Int
i = Vector Int
os Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` Int
i
     in
        Int -> (Int -> b) -> Vector b
forall a. Unbox a => Int -> (Int -> a) -> Vector a
VU.generate
            (Vector Int -> Int
forall a. Unbox a => Vector a -> Int
VU.length Vector Int
os Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
            ( \Int
i ->
                Vector a -> b
f (Int -> Int -> Vector a -> Vector a
forall a. Unbox a => Int -> Int -> Vector a -> Vector a
VU.unsafeSlice (Int -> Int
start Int
i) (Int -> Int
n Int
i) Vector a
sorted)
            )

mkReducedColumnUnboxed ::
    forall a.
    (VU.Unbox a) =>
    VU.Vector a ->
    VU.Vector Int ->
    VU.Vector Int ->
    (a -> a -> a) ->
    VU.Vector a
mkReducedColumnUnboxed :: forall a.
Unbox a =>
Vector a -> Vector Int -> Vector Int -> (a -> a -> a) -> Vector a
mkReducedColumnUnboxed Vector a
col Vector Int
os Vector Int
indices a -> a -> a
f = (forall s. ST s (Vector a)) -> Vector a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (Vector a)) -> Vector a)
-> (forall s. ST s (Vector a)) -> Vector a
forall a b. (a -> b) -> a -> b
$ do
    let len :: Int
len = Vector Int -> Int
forall a. Unbox a => Vector a -> Int
VU.length Vector Int
os Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
    MVector s a
mvec <- Int -> ST s (MVector (PrimState (ST s)) a)
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
VUM.unsafeNew Int
len

    let loopOut :: Int -> ST s ()
loopOut Int
i
            | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
len = () -> ST s ()
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
            | Bool
otherwise = do
                let !start :: Int
start = Vector Int
os Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` Int
i
                let !end :: Int
end = Vector Int
os Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
                let !initVal :: a
initVal = Vector a
col Vector a -> Int -> a
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` (Vector Int
indices Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` Int
start)

                let loopIn :: a -> Int -> a
loopIn !a
acc !Int
idx
                        | Int
idx Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
end = a
acc
                        | Bool
otherwise =
                            let val :: a
val = Vector a
col Vector a -> Int -> a
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` (Vector Int
indices Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` Int
idx)
                             in a -> Int -> a
loopIn (a -> a -> a
f a
acc a
val) (Int
idx Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
                let !finalVal :: a
finalVal = a -> Int -> a
loopIn a
initVal (Int
start Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
                MVector (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
VUM.unsafeWrite MVector s a
MVector (PrimState (ST s)) a
mvec Int
i a
finalVal
                Int -> ST s ()
loopOut (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)

    Int -> ST s ()
loopOut Int
0
    MVector (PrimState (ST s)) a -> ST s (Vector a)
forall a (m :: * -> *).
(Unbox a, PrimMonad m) =>
MVector (PrimState m) a -> m (Vector a)
VU.unsafeFreeze MVector s a
MVector (PrimState (ST s)) a
mvec
{-# INLINE mkReducedColumnUnboxed #-}

mkReducedColumnBoxed ::
    V.Vector a ->
    VU.Vector Int ->
    VU.Vector Int ->
    (a -> a -> a) ->
    V.Vector a
mkReducedColumnBoxed :: forall a.
Vector a -> Vector Int -> Vector Int -> (a -> a -> a) -> Vector a
mkReducedColumnBoxed Vector a
col Vector Int
os Vector Int
indices a -> a -> a
f = (forall s. ST s (Vector a)) -> Vector a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (Vector a)) -> Vector a)
-> (forall s. ST s (Vector a)) -> Vector a
forall a b. (a -> b) -> a -> b
$ do
    let len :: Int
len = Vector Int -> Int
forall a. Unbox a => Vector a -> Int
VU.length Vector Int
os Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
    MVector s a
mvec <- Int -> ST s (MVector (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> m (MVector (PrimState m) a)
VM.unsafeNew Int
len

    let loopOut :: Int -> ST s ()
loopOut Int
i
            | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
len = () -> ST s ()
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
            | Bool
otherwise = do
                let start :: Int
start = Vector Int
os Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` Int
i
                let end :: Int
end = Vector Int
os Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
                let initVal :: a
initVal = Vector a
col Vector a -> Int -> a
forall a. Vector a -> Int -> a
`V.unsafeIndex` (Vector Int
indices Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` Int
start)

                let loopIn :: a -> Int -> a
loopIn !a
acc Int
idx
                        | Int
idx Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
end = a
acc
                        | Bool
otherwise =
                            let val :: a
val = Vector a
col Vector a -> Int -> a
forall a. Vector a -> Int -> a
`V.unsafeIndex` (Vector Int
indices Vector Int -> Int -> Int
forall a. Unbox a => Vector a -> Int -> a
`VU.unsafeIndex` Int
idx)
                             in a -> Int -> a
loopIn (a -> a -> a
f a
acc a
val) (Int
idx Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
                let !finalVal :: a
finalVal = a -> Int -> a
loopIn a
initVal (Int
start Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
                MVector (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> Int -> a -> m ()
VM.unsafeWrite MVector s a
MVector (PrimState (ST s)) a
mvec Int
i a
finalVal
                Int -> ST s ()
loopOut (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)

    Int -> ST s ()
loopOut Int
0
    MVector (PrimState (ST s)) a -> ST s (Vector a)
forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> m (Vector a)
V.unsafeFreeze MVector s a
MVector (PrimState (ST s)) a
mvec
{-# INLINE mkReducedColumnBoxed #-}

nestedTypeException ::
    forall a b. (Typeable a, Typeable b) => String -> DataFrameException
nestedTypeException :: forall a b.
(Typeable a, Typeable b) =>
String -> DataFrameException
nestedTypeException String
expression = case forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @a of
    App TypeRep a
t1 TypeRep b
t2 ->
        TypeErrorContext () () -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
            ( MkTypeErrorContext
                { userType :: Either String (TypeRep ())
userType = String -> Either String (TypeRep ())
forall a b. a -> Either a b
Left (TypeRep b -> String
forall a. Show a => a -> String
show (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b)) :: Either String (TypeRep ())
                , expectedType :: Either String (TypeRep ())
expectedType = String -> Either String (TypeRep ())
forall a b. a -> Either a b
Left (TypeRep a -> String
forall a. Show a => a -> String
show (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @a)) :: Either String (TypeRep ())
                , callingFunctionName :: Maybe String
callingFunctionName = String -> Maybe String
forall a. a -> Maybe a
Just String
"interpretAggregation"
                , errorColumnName :: Maybe String
errorColumnName = String -> Maybe String
forall a. a -> Maybe a
Just String
expression
                }
            )
    TypeRep a
t ->
        TypeErrorContext (Vector b) b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
            ( MkTypeErrorContext
                { userType :: Either String (TypeRep (Vector b))
userType = TypeRep (Vector b) -> Either String (TypeRep (Vector b))
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @(VU.Vector b))
                , expectedType :: Either String (TypeRep b)
expectedType = TypeRep b -> Either String (TypeRep b)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @b)
                , callingFunctionName :: Maybe String
callingFunctionName = String -> Maybe String
forall a. a -> Maybe a
Just String
"interpretAggregation"
                , errorColumnName :: Maybe String
errorColumnName = String -> Maybe String
forall a. a -> Maybe a
Just String
expression
                }
            )

mkTypeMismatchException ::
    (Typeable a, Typeable b) =>
    Maybe String -> Maybe String -> TypeErrorContext a b -> DataFrameException
mkTypeMismatchException :: forall a b.
(Typeable a, Typeable b) =>
Maybe String
-> Maybe String -> TypeErrorContext a b -> DataFrameException
mkTypeMismatchException Maybe String
callPoint Maybe String
errorLocation TypeErrorContext a b
context =
    TypeErrorContext a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
        ( TypeErrorContext a b
context
            { callingFunctionName = callPoint
            , errorColumnName = errorLocation
            }
        )