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

module DataFrame.Internal.Expression where

import qualified Data.Map as M
import Data.Maybe (fromMaybe, isJust)
import Data.String
import qualified Data.Text as T
import Data.Type.Equality (TestEquality (testEquality), type (:~:) (Refl))
import qualified Data.Vector as V
import qualified Data.Vector.Generic as VG
import qualified Data.Vector.Unboxed as VU
import DataFrame.Errors
import DataFrame.Internal.Column
import DataFrame.Internal.DataFrame
import DataFrame.Internal.Types
import Type.Reflection (TypeRep, Typeable, typeOf, typeRep, pattern App)

data Expr a where
    Col :: (Columnable a) => T.Text -> Expr a
    Lit :: (Columnable a) => a -> Expr a
    If ::
        (Columnable a) =>
        Expr Bool ->
        Expr a ->
        Expr a ->
        Expr a
    UnaryOp ::
        ( Columnable a
        , Columnable b
        ) =>
        T.Text -> -- Operation name
        (b -> a) ->
        Expr b ->
        Expr a
    BinaryOp ::
        ( Columnable c
        , Columnable b
        , Columnable a
        ) =>
        T.Text -> -- operation name
        (c -> b -> a) ->
        Expr c ->
        Expr b ->
        Expr a
    AggVector ::
        ( VG.Vector v b
        , Typeable v
        , Columnable a
        , Columnable b
        ) =>
        Expr b ->
        T.Text -> -- Operation name
        (v b -> a) ->
        Expr a
    AggReduce ::
        (Columnable a) =>
        Expr a ->
        T.Text -> -- Operation name
        (forall a. (Columnable a) => a -> a -> a) ->
        Expr a
    AggNumericVector ::
        ( Columnable a
        , Columnable b
        , VU.Unbox a
        , VU.Unbox b
        , Num a
        , Num b
        ) =>
        Expr b ->
        T.Text -> -- Operation name
        (VU.Vector b -> a) ->
        Expr a
    AggFold ::
        forall a b.
        (Columnable a, Columnable b) =>
        Expr b ->
        T.Text -> -- Operation name
        a ->
        (a -> b -> a) ->
        Expr a

data UExpr where
    Wrap :: (Columnable a) => Expr a -> UExpr

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) =
    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 (Col Text
name) = case Text -> DataFrame -> Maybe Column
getColumn Text
name DataFrame
df of
    Maybe Column
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
$ 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 Column
col -> 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
col
interpret DataFrame
df expr :: Expr a
expr@(If Expr Bool
cond Expr a
l Expr a
r) = case forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @Bool DataFrame
df Expr Bool
cond of
    Left (TypeMismatchException TypeErrorContext a b
context) ->
        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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                ( TypeErrorContext a b
context
                    { callingFunctionName = Just "interpret"
                    , errorColumnName = Just (show cond)
                    }
                )
    Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
    Right (TColumn Column
conditions) -> case forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @a DataFrame
df Expr a
l of
        Left (TypeMismatchException TypeErrorContext a b
context) ->
            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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    (TypeErrorContext a b
context{callingFunctionName = Just "interpret", errorColumnName = Just (show l)})
        Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
        Right (TColumn Column
left) -> case forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @a DataFrame
df Expr a
r of
            Left (TypeMismatchException TypeErrorContext a b
context) ->
                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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                        (TypeErrorContext a b
context{callingFunctionName = Just "interpret", errorColumnName = Just (show r)})
            Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
            Right (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 (TypeMismatchException TypeErrorContext a b
context) ->
                    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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                            ( TypeErrorContext a b
context
                                { callingFunctionName = Just "interpret"
                                , errorColumnName = Just (show expr)
                                }
                            )
                Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
                Right Column
res -> 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
res
interpret DataFrame
df expr :: Expr a
expr@(UnaryOp Text
_ (b -> a
f :: c -> d) Expr b
value) = case forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @c DataFrame
df Expr b
value of
    Left (TypeMismatchException TypeErrorContext a b
context) ->
        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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                ( TypeErrorContext a b
context
                    { callingFunctionName = Just "interpret"
                    , errorColumnName = Just (show value)
                    }
                )
    Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
    Right (TColumn Column
value') -> 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
value' of
        Left (TypeMismatchException TypeErrorContext a b
context) ->
            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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpret"
                        , errorColumnName = Just (show expr)
                        }
                    )
        Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
        Right Column
res -> 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
res
interpret DataFrame
df expr :: Expr a
expr@(BinaryOp Text
_ (c -> b -> a
f :: c -> d -> e) (Lit c
left) (Lit b
right)) =
    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) (c -> b -> a
f c
left b
right)
interpret DataFrame
df expr :: Expr a
expr@(BinaryOp Text
_ (c -> b -> a
f :: c -> d -> e) (Lit c
left) Expr b
right) = case forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @d DataFrame
df Expr b
right of
    Left (TypeMismatchException TypeErrorContext a b
context) ->
        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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                ( TypeErrorContext a b
context
                    { callingFunctionName = Just "interpret"
                    , errorColumnName = Just (show right)
                    }
                )
    Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
    Right (TColumn Column
right') -> case (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
right' of
        Left (TypeMismatchException TypeErrorContext a b
context) ->
            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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpret"
                        , errorColumnName = Just (show expr)
                        }
                    )
        Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
        Right Column
res -> 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
res
interpret DataFrame
df expr :: Expr a
expr@(BinaryOp Text
_ (c -> b -> a
f :: c -> d -> e) Expr c
left (Lit b
right)) = case forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @c DataFrame
df Expr c
left of
    Left (TypeMismatchException TypeErrorContext a b
context) ->
        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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                ( TypeErrorContext a b
context
                    { callingFunctionName = Just "interpret"
                    , errorColumnName = Just (show left)
                    }
                )
    Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
    Right (TColumn Column
left') -> case (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
left' of
        Left (TypeMismatchException TypeErrorContext a b
context) ->
            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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpret"
                        , errorColumnName = Just (show expr)
                        }
                    )
        Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
        Right Column
res -> 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
res
interpret DataFrame
df expr :: Expr a
expr@(BinaryOp Text
_ (c -> b -> a
f :: c -> d -> e) Expr c
left Expr b
right) = case forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @c DataFrame
df Expr c
left of
    Left (TypeMismatchException TypeErrorContext a b
context) ->
        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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                ( TypeErrorContext a b
context
                    { callingFunctionName = Just "interpret"
                    , errorColumnName = Just (show left)
                    }
                )
    Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
    Right (TColumn Column
left') -> case forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @d DataFrame
df Expr b
right of
        Left (TypeMismatchException TypeErrorContext a b
context) ->
            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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpret"
                        , errorColumnName = Just (show right)
                        }
                    )
        Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
        Right (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 (TypeMismatchException TypeErrorContext a b
context) ->
                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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                        ( TypeErrorContext a b
context
                            { callingFunctionName = Just "interpret"
                            , errorColumnName = Just (show expr)
                            }
                        )
            Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
            Right Column
res -> 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
res
interpret DataFrame
df expression :: Expr a
expression@(AggVector Expr b
expr Text
op (v b -> a
f :: v b -> c)) = case forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @b DataFrame
df Expr b
expr of
    Left (TypeMismatchException TypeErrorContext a b
context) ->
        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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                ( TypeErrorContext a b
context
                    { callingFunctionName = Just "interpret"
                    , errorColumnName = Just (show expr)
                    }
                )
    Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
    Right (TColumn Column
column) -> case Column
column of
        (BoxedColumn Vector a
col) -> case TypeRep (v b) -> TypeRep (Vector a) -> Maybe (v b :~: Vector 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)) (Vector a -> TypeRep (Vector a)
forall a. Typeable a => a -> TypeRep a
typeOf Vector a
col) of
            Just v b :~: Vector a
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 v b
Vector a
col))
            Maybe (v b :~: Vector a)
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 (v b) (Vector a) -> 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 (Vector a))
expectedType = TypeRep (Vector a) -> Either String (TypeRep (Vector a))
forall a b. b -> Either a b
Right (Vector a -> TypeRep (Vector a)
forall a. Typeable a => a -> TypeRep a
typeOf Vector a
col)
                            , 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
                            }
                        )
        (OptionalColumn Vector (Maybe a)
col) -> case TypeRep (v b)
-> TypeRep (Vector (Maybe a)) -> Maybe (v b :~: Vector (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 @(v b)) (Vector (Maybe a) -> TypeRep (Vector (Maybe a))
forall a. Typeable a => a -> TypeRep a
typeOf Vector (Maybe a)
col) of
            Just v b :~: Vector (Maybe a)
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 v b
Vector (Maybe a)
col))
            Maybe (v b :~: Vector (Maybe a))
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 (v b) (Vector (Maybe a)) -> 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 (Vector (Maybe a)))
expectedType = TypeRep (Vector (Maybe a))
-> Either String (TypeRep (Vector (Maybe a)))
forall a b. b -> Either a b
Right (Vector (Maybe a) -> TypeRep (Vector (Maybe a))
forall a. Typeable a => a -> TypeRep a
typeOf Vector (Maybe a)
col)
                            , 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
                            }
                        )
        (UnboxedColumn (Vector a
col :: VU.Vector d)) -> case TypeRep (v b) -> TypeRep (Vector a) -> Maybe (v b :~: Vector 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)) (Vector a -> TypeRep (Vector a)
forall a. Typeable a => a -> TypeRep a
typeOf Vector a
col) of
            Just v b :~: Vector a
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 v b
Vector a
col))
            Maybe (v b :~: Vector a)
Nothing -> 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 =>
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 (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 (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 (v b) (Vector a) -> 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 (Vector a))
expectedType = TypeRep (Vector a) -> Either String (TypeRep (Vector a))
forall a b. b -> Either a b
Right (Vector a -> TypeRep (Vector a)
forall a. Typeable a => a -> TypeRep a
typeOf Vector a
col)
                                , 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
                                }
                            )
interpret DataFrame
df expression :: Expr a
expression@(AggReduce Expr a
expr Text
op (forall a. Columnable a => a -> a -> a
f :: forall a. (Columnable a) => a -> a -> a)) = case forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @a DataFrame
df Expr a
expr of
    Left (TypeMismatchException TypeErrorContext a b
context) ->
        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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                ( TypeErrorContext a b
context
                    { callingFunctionName = Just "interpret"
                    , errorColumnName = Just (show expr)
                    }
                )
    Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
    Right (TColumn Column
column) -> case forall a. Columnable a => Column -> Either DataFrameException a
headColumn @a Column
column of
        Left (TypeMismatchException TypeErrorContext a b
context) ->
            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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpret"
                        , errorColumnName = Just (show expr)
                        }
                    )
        Left (EmptyDataSetException Text
loc) -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left (Text -> DataFrameException
EmptyDataSetException (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
expr))
        Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
        Right a
h -> case (a -> Int -> a -> a) -> a -> Column -> Either DataFrameException a
forall a b.
(Columnable a, Columnable b) =>
(b -> Int -> a -> b) -> b -> Column -> Either DataFrameException b
ifoldlColumn (\a
acc Int
_ a
v -> a -> a -> a
forall a. Columnable a => a -> a -> a
f a
acc a
v) a
h Column
column of
            Left (TypeMismatchException TypeErrorContext a b
context) ->
                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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                        ( TypeErrorContext a b
context
                            { callingFunctionName = Just "interpret"
                            , errorColumnName = Just (show expression)
                            }
                        )
            Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
            Right a
value ->
                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)) = case forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @b DataFrame
df Expr b
expr of
    Left (TypeMismatchException TypeErrorContext a b
context) ->
        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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                ( TypeErrorContext a b
context
                    { callingFunctionName = Just "interpret"
                    , errorColumnName = Just (show expr)
                    }
                )
    Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
    Right (TColumn Column
column) -> 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
                        ( 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
"interpret"
                            , 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)
                            }
                        )
        (BoxedColumn (Vector a
v :: V.Vector d)) -> case TypeRep a -> TypeRep Integer -> Maybe (a :~: Integer)
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 @Integer) of
            Just a :~: Integer
Refl ->
                TypedColumn a -> Either DataFrameException (TypedColumn a)
forall a b. b -> Either a b
Right (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 b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
VU.convert (Vector b -> Vector b) -> Vector b -> Vector b
forall a b. (a -> b) -> a -> b
$ (Integer -> b) -> Vector Integer -> Vector b
forall a b. (a -> b) -> Vector a -> Vector b
V.map Integer -> b
forall a. Num a => Integer -> a
fromInteger Vector a
Vector Integer
v))
            Maybe (a :~: Integer)
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 Integer a -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                        ( MkTypeErrorContext
                            { userType :: Either String (TypeRep Integer)
userType = TypeRep Integer -> Either String (TypeRep Integer)
forall a b. b -> Either a b
Right (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @Integer)
                            , 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
"interpret"
                            , 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)
                            }
                        )
        (OptionalColumn (Vector (Maybe a)
v :: V.Vector (Maybe d))) -> case forall a. SBoolI (Numeric a) => SBool (Numeric a)
sNumeric @d of
            SBool (Numeric a)
STrue -> 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
                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
                            ( 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
"interpret"
                                , 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 :~: 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 b
forall (v :: * -> *) a (w :: * -> *).
(Vector v a, Vector w a) =>
v a -> w a
VU.convert (Vector b -> Vector b) -> Vector b -> Vector b
forall a b. (a -> b) -> a -> b
$ (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 b
forall a b. (a -> b) -> a -> b
$ (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)
v))
            SBool (Numeric a)
SFalse ->
                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 a b -> 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 @d)
                            , 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
"interpret"
                            , 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)
                            }
                        )
interpret DataFrame
df expression :: Expr a
expression@(AggFold Expr b
expr Text
op a
start (a -> b -> a
f :: (a -> b -> a))) = case forall a.
Columnable a =>
DataFrame -> Expr a -> Either DataFrameException (TypedColumn a)
interpret @b DataFrame
df Expr b
expr of
    Left (TypeMismatchException TypeErrorContext a b
context) ->
        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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                ( TypeErrorContext a b
context
                    { callingFunctionName = Just "interpret"
                    , errorColumnName = Just (show expr)
                    }
                )
    Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
    Right (TColumn Column
column) -> case (a -> Int -> b -> a) -> a -> Column -> Either DataFrameException a
forall a b.
(Columnable a, Columnable b) =>
(b -> Int -> a -> b) -> b -> Column -> Either DataFrameException b
ifoldlColumn (\a
acc Int
_ b
v -> a -> b -> a
f a
acc b
v) a
start Column
column of
        Left (TypeMismatchException TypeErrorContext a b
context) ->
            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 a b -> DataFrameException
forall a b.
(Typeable a, Typeable b) =>
TypeErrorContext a b -> DataFrameException
TypeMismatchException
                    ( TypeErrorContext a b
context
                        { callingFunctionName = Just "interpret"
                        , errorColumnName = Just (show expression)
                        }
                    )
        Left DataFrameException
e -> DataFrameException -> Either DataFrameException (TypedColumn a)
forall a b. a -> Either a b
Left DataFrameException
e
        Right a
value ->
            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)

mkUnaggregatedColumn ::
    forall v a.
    (VG.Vector v a, Columnable a) =>
    v a -> VU.Vector Int -> VU.Vector Int -> V.Vector (v a)
mkUnaggregatedColumn :: forall (v :: * -> *) a.
(Vector v a, Columnable a) =>
v a -> Vector Int -> Vector Int -> Vector (v a)
mkUnaggregatedColumn v a
col Vector Int
os Vector Int
indices =
    Int -> (Int -> v a) -> Vector (v 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 -> a) -> v a
forall (v :: * -> *) a. Vector v a => Int -> (Int -> a) -> v a
VG.generate
                (Vector Int
os Vector Int -> Int -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int -> a
`VG.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 (v :: * -> *) a. Vector v a => v a -> Int -> a
`VG.unsafeIndex` Int
i))
                ( \Int
j ->
                    v a
col v a -> Int -> a
forall (v :: * -> *) a. Vector v a => v a -> Int -> a
`VG.unsafeIndex` (Vector Int
indices Vector Int -> Int -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int -> a
`VG.unsafeIndex` (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (Vector Int
os Vector Int -> Int -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int -> a
`VG.unsafeIndex` Int
i)))
                )
        )

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
                }
            )

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 (v :: * -> *) a. Vector v a => v a -> Int
VG.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 (v :: * -> *) a.
(Vector v a, Columnable a) =>
v a -> Vector Int -> Vector Int -> Vector (v a)
mkUnaggregatedColumn 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 (v :: * -> *) a.
(Vector v a, Columnable a) =>
v a -> Vector Int -> Vector Int -> Vector (v a)
mkUnaggregatedColumn 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 (v :: * -> *) a.
(Vector v a, Columnable a) =>
v a -> Vector Int -> Vector Int -> Vector (v a)
mkUnaggregatedColumn 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 -> 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
                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
_ (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 @c of
                                SBool (Unboxable c)
STrue -> 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
                                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)
            (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 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 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 (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b) -> v a -> v b
VG.map ((Int -> b) -> Vector Int -> Vector b
forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b) -> v a -> v b
VG.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 Expr a
expr Text
op (forall a. Columnable a => a -> a -> a
f :: forall a. (Columnable a) => 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 (\Vector a
v -> (a -> a -> a) -> a -> Vector a -> a
forall b a. Unbox b => (a -> b -> a) -> a -> Vector b -> a
VU.foldl' a -> a -> a
forall a. Columnable a => a -> a -> a
f (Vector a -> a
forall (v :: * -> *) a. Vector v a => v a -> a
VG.head Vector a
v) (Int -> Vector a -> Vector a
forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
VG.drop Int
1 Vector a
v)) 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 (\Vector a
v -> (a -> a -> a) -> a -> Vector a -> a
forall (v :: * -> *) b a.
Vector v b =>
(a -> b -> a) -> a -> v b -> a
VG.foldl' a -> a -> a
forall a. Columnable a => a -> a -> a
f (Vector a -> a
forall (v :: * -> *) a. Vector v a => v a -> a
VG.head Vector a
v) (Int -> Vector a -> Vector a
forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
VG.drop Int
1 Vector a
v)) 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 forall a. Columnable a => Column -> Either DataFrameException a
headColumn @a Column
column of
            Left DataFrameException
e -> DataFrameException
-> Either DataFrameException (AggregationResult a)
forall a b. a -> Either a b
Left DataFrameException
e
            Right a
h -> case (a -> Int -> a -> a) -> a -> Column -> Either DataFrameException a
forall a b.
(Columnable a, Columnable b) =>
(b -> Int -> a -> b) -> b -> Column -> Either DataFrameException b
ifoldlColumn (\a
acc Int
_ a
v -> a -> a -> a
forall a. Columnable a => a -> a -> a
f a
acc a
v) a
h 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 -> Int -> b -> a) -> a -> Column -> Either DataFrameException a
forall a b.
(Columnable a, Columnable b) =>
(b -> Int -> a -> b) -> b -> Column -> Either DataFrameException b
ifoldlColumn (\a
acc Int
_ b
v -> a -> b -> a
f a
acc b
v) 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)

instance (Num a, Columnable a) => Num (Expr a) where
    (+) :: Expr a -> Expr a -> Expr a
    + :: Expr a -> Expr a -> Expr a
(+) (Lit a
x) (Lit a
y) = a -> Expr a
forall a. Columnable a => a -> Expr a
Lit (a
x a -> a -> a
forall a. Num a => a -> a -> a
+ a
y)
    (+) (Lit a
x) Expr a
expr = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp (Text
"add " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> (String -> Text
T.pack (String -> Text) -> (Expr a -> String) -> Expr a -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr a -> String
forall a. Show a => a -> String
show) (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit a
x)) (a -> a -> a
forall a. Num a => a -> a -> a
+ a
x) Expr a
expr
    (+) Expr a
expr (Lit a
x) = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp (Text
"add " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> (String -> Text
T.pack (String -> Text) -> (Expr a -> String) -> Expr a -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr a -> String
forall a. Show a => a -> String
show) (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit a
x)) (a -> a -> a
forall a. Num a => a -> a -> a
+ a
x) Expr a
expr
    (+) Expr a
e1 Expr a
e2
        | Expr a
e1 Expr a -> Expr a -> Bool
forall a. Eq a => a -> a -> Bool
== Expr a
e2 = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp (Text
"mult " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> (String -> Text
T.pack (String -> Text) -> (Expr a -> String) -> Expr a -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr a -> String
forall a. Show a => a -> String
show) (forall a. Columnable a => a -> Expr a
Lit @a a
2)) (a -> a -> a
forall a. Num a => a -> a -> a
* a
2) Expr a
e1
        | Bool
otherwise = Text -> (a -> a -> a) -> Expr a -> Expr a -> Expr a
forall b b a.
(Columnable b, Columnable b, Columnable a) =>
Text -> (b -> b -> a) -> Expr b -> Expr b -> Expr a
BinaryOp Text
"add" a -> a -> a
forall a. Num a => a -> a -> a
(+) Expr a
e1 Expr a
e2

    (-) :: Expr a -> Expr a -> Expr a
    (-) (Lit a
x) (Lit a
y) = a -> Expr a
forall a. Columnable a => a -> Expr a
Lit (a
x a -> a -> a
forall a. Num a => a -> a -> a
- a
y)
    (-) Expr a
e1 Expr a
e2 = Text -> (a -> a -> a) -> Expr a -> Expr a -> Expr a
forall b b a.
(Columnable b, Columnable b, Columnable a) =>
Text -> (b -> b -> a) -> Expr b -> Expr b -> Expr a
BinaryOp Text
"sub" (-) Expr a
e1 Expr a
e2

    (*) :: Expr a -> Expr a -> Expr a
    * :: Expr a -> Expr a -> Expr a
(*) (Lit a
0) Expr a
_ = a -> Expr a
forall a. Columnable a => a -> Expr a
Lit a
0
    (*) Expr a
_ (Lit a
0) = a -> Expr a
forall a. Columnable a => a -> Expr a
Lit a
0
    (*) (Lit a
1) Expr a
e = Expr a
e
    (*) Expr a
e (Lit a
1) = Expr a
e
    (*) (Lit a
x) (Lit a
y) = a -> Expr a
forall a. Columnable a => a -> Expr a
Lit (a
x a -> a -> a
forall a. Num a => a -> a -> a
* a
y)
    (*) (Lit a
x) Expr a
expr = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp (Text
"mult " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> (String -> Text
T.pack (String -> Text) -> (Expr a -> String) -> Expr a -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr a -> String
forall a. Show a => a -> String
show) (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit a
x)) (a -> a -> a
forall a. Num a => a -> a -> a
* a
x) Expr a
expr
    (*) Expr a
expr (Lit a
x) = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp (Text
"mult " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> (String -> Text
T.pack (String -> Text) -> (Expr a -> String) -> Expr a -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr a -> String
forall a. Show a => a -> String
show) (a -> Expr a
forall a. Columnable a => a -> Expr a
Lit a
x)) (a -> a -> a
forall a. Num a => a -> a -> a
* a
x) Expr a
expr
    (*) Expr a
e1 Expr a
e2
        | Expr a
e1 Expr a -> Expr a -> Bool
forall a. Eq a => a -> a -> Bool
== Expr a
e2 = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"pow 2" (a -> Integer -> a
forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
2) Expr a
e1
        | Bool
otherwise = Text -> (a -> a -> a) -> Expr a -> Expr a -> Expr a
forall b b a.
(Columnable b, Columnable b, Columnable a) =>
Text -> (b -> b -> a) -> Expr b -> Expr b -> Expr a
BinaryOp Text
"mult" a -> a -> a
forall a. Num a => a -> a -> a
(*) Expr a
e1 Expr a
e2

    fromInteger :: Integer -> Expr a
    fromInteger :: Integer -> Expr a
fromInteger = a -> Expr a
forall a. Columnable a => a -> Expr a
Lit (a -> Expr a) -> (Integer -> a) -> Integer -> Expr a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
forall a. Num a => Integer -> a
fromInteger

    negate :: Expr a -> Expr a
    negate :: Expr a -> Expr a
negate (Lit a
n) = a -> Expr a
forall a. Columnable a => a -> Expr a
Lit (a -> a
forall a. Num a => a -> a
negate a
n)
    negate Expr a
expr = case Expr a
expr of
        (UnaryOp Text
"negate" b -> a
negate Expr b
e) -> case TypeRep (Expr b) -> TypeRep (Expr a) -> Maybe (Expr b :~: Expr 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 (Expr b -> TypeRep (Expr b)
forall a. Typeable a => a -> TypeRep a
typeOf Expr b
e) (Expr a -> TypeRep (Expr a)
forall a. Typeable a => a -> TypeRep a
typeOf Expr a
expr) of
            Maybe (Expr b :~: Expr a)
Nothing -> Expr a
expr -- This case is impossible.
            Just Expr b :~: Expr a
Refl -> Expr a
Expr b
e
        Expr a
_ -> Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"negate" a -> a
forall a. Num a => a -> a
negate Expr a
expr

    abs :: (Num a) => Expr a -> Expr a
    abs :: Num a => Expr a -> Expr a
abs Expr a
expr = case Expr a
expr of
        (UnaryOp Text
"abs" b -> a
abs Expr b
e) -> case TypeRep (Expr b) -> TypeRep (Expr a) -> Maybe (Expr b :~: Expr 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 (Expr b -> TypeRep (Expr b)
forall a. Typeable a => a -> TypeRep a
typeOf Expr b
e) (Expr a -> TypeRep (Expr a)
forall a. Typeable a => a -> TypeRep a
typeOf Expr a
expr) of
            Maybe (Expr b :~: Expr a)
Nothing -> Expr a
expr -- This case is impossible.
            Just Expr b :~: Expr a
Refl -> Expr a
Expr b
e
        Expr a
_ -> Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"abs" a -> a
forall a. Num a => a -> a
abs Expr a
expr

    signum :: (Num a) => Expr a -> Expr a
    signum :: Num a => Expr a -> Expr a
signum (Lit a
n) = a -> Expr a
forall a. Columnable a => a -> Expr a
Lit (a -> a
forall a. Num a => a -> a
signum a
n)
    signum Expr a
expr = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"signum" a -> a
forall a. Num a => a -> a
signum Expr a
expr

add :: (Num a, Columnable a) => Expr a -> Expr a -> Expr a
add :: forall a. (Num a, Columnable a) => Expr a -> Expr a -> Expr a
add = Expr a -> Expr a -> Expr a
forall a. Num a => a -> a -> a
(+)

sub :: (Num a, Columnable a) => Expr a -> Expr a -> Expr a
sub :: forall a. (Num a, Columnable a) => Expr a -> Expr a -> Expr a
sub = (-)

mult :: (Num a, Columnable a) => Expr a -> Expr a -> Expr a
mult :: forall a. (Num a, Columnable a) => Expr a -> Expr a -> Expr a
mult = Expr a -> Expr a -> Expr a
forall a. Num a => a -> a -> a
(*)

instance (Fractional a, Columnable a) => Fractional (Expr a) where
    fromRational :: (Fractional a, Columnable a) => Rational -> Expr a
    fromRational :: (Fractional a, Columnable a) => Rational -> Expr a
fromRational = a -> Expr a
forall a. Columnable a => a -> Expr a
Lit (a -> Expr a) -> (Rational -> a) -> Rational -> Expr a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> a
forall a. Fractional a => Rational -> a
fromRational

    (/) :: (Fractional a, Columnable a) => Expr a -> Expr a -> Expr a
    / :: (Fractional a, Columnable a) => Expr a -> Expr a -> Expr a
(/) = Text -> (a -> a -> a) -> Expr a -> Expr a -> Expr a
forall b b a.
(Columnable b, Columnable b, Columnable a) =>
Text -> (b -> b -> a) -> Expr b -> Expr b -> Expr a
BinaryOp Text
"divide" a -> a -> a
forall a. Fractional a => a -> a -> a
(/)

divide :: (Fractional a, Columnable a) => Expr a -> Expr a -> Expr a
divide :: forall a.
(Fractional a, Columnable a) =>
Expr a -> Expr a -> Expr a
divide = Expr a -> Expr a -> Expr a
forall a. Fractional a => a -> a -> a
(/)

instance (IsString a, Columnable a) => IsString (Expr a) where
    fromString :: String -> Expr a
    fromString :: String -> Expr a
fromString String
s = a -> Expr a
forall a. Columnable a => a -> Expr a
Lit (String -> a
forall a. IsString a => String -> a
fromString String
s)

instance (Floating a, Columnable a) => Floating (Expr a) where
    pi :: (Floating a, Columnable a) => Expr a
    pi :: (Floating a, Columnable a) => Expr a
pi = a -> Expr a
forall a. Columnable a => a -> Expr a
Lit a
forall a. Floating a => a
pi
    exp :: (Floating a, Columnable a) => Expr a -> Expr a
    exp :: (Floating a, Columnable a) => Expr a -> Expr a
exp = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"exp" a -> a
forall a. Floating a => a -> a
exp
    log :: (Floating a, Columnable a) => Expr a -> Expr a
    log :: (Floating a, Columnable a) => Expr a -> Expr a
log = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"log" a -> a
forall a. Floating a => a -> a
log
    sin :: (Floating a, Columnable a) => Expr a -> Expr a
    sin :: (Floating a, Columnable a) => Expr a -> Expr a
sin = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"sin" a -> a
forall a. Floating a => a -> a
sin
    cos :: (Floating a, Columnable a) => Expr a -> Expr a
    cos :: (Floating a, Columnable a) => Expr a -> Expr a
cos = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"cos" a -> a
forall a. Floating a => a -> a
cos
    asin :: (Floating a, Columnable a) => Expr a -> Expr a
    asin :: (Floating a, Columnable a) => Expr a -> Expr a
asin = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"asin" a -> a
forall a. Floating a => a -> a
asin
    acos :: (Floating a, Columnable a) => Expr a -> Expr a
    acos :: (Floating a, Columnable a) => Expr a -> Expr a
acos = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"acos" a -> a
forall a. Floating a => a -> a
acos
    atan :: (Floating a, Columnable a) => Expr a -> Expr a
    atan :: (Floating a, Columnable a) => Expr a -> Expr a
atan = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"atan" a -> a
forall a. Floating a => a -> a
atan
    sinh :: (Floating a, Columnable a) => Expr a -> Expr a
    sinh :: (Floating a, Columnable a) => Expr a -> Expr a
sinh = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"sinh" a -> a
forall a. Floating a => a -> a
sinh
    cosh :: (Floating a, Columnable a) => Expr a -> Expr a
    cosh :: (Floating a, Columnable a) => Expr a -> Expr a
cosh = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"cosh" a -> a
forall a. Floating a => a -> a
cosh
    asinh :: (Floating a, Columnable a) => Expr a -> Expr a
    asinh :: (Floating a, Columnable a) => Expr a -> Expr a
asinh = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"asinh" a -> a
forall a. Floating a => a -> a
sinh
    acosh :: (Floating a, Columnable a) => Expr a -> Expr a
    acosh :: (Floating a, Columnable a) => Expr a -> Expr a
acosh = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"acosh" a -> a
forall a. Floating a => a -> a
acosh
    atanh :: (Floating a, Columnable a) => Expr a -> Expr a
    atanh :: (Floating a, Columnable a) => Expr a -> Expr a
atanh = Text -> (a -> a) -> Expr a -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
"atanh" a -> a
forall a. Floating a => a -> a
atanh

instance (Show a) => Show (Expr a) where
    show :: forall a. (Show a) => Expr a -> String
    show :: forall a. Show a => Expr a -> String
show (Col Text
name) = String
"(col @" String -> ShowS
forall a. [a] -> [a] -> [a]
++ 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) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
forall a. Show a => a -> String
show Text
name String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"
    show (Lit a
value) = String
"(lit (" String -> ShowS
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show a
value String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"))"
    show (If Expr Bool
cond Expr a
l Expr a
r) = String
"(ifThenElse " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr Bool -> String
forall a. Show a => a -> String
show Expr Bool
cond String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr a -> String
forall a. Show a => a -> String
show Expr a
l String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr a -> String
forall a. Show a => a -> String
show Expr a
r String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"
    show (UnaryOp Text
name b -> a
f Expr b
value) = String
"(" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
name String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr b -> String
forall a. Show a => a -> String
show Expr b
value String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"
    show (BinaryOp Text
name c -> b -> a
f Expr c
a Expr b
b) = String
"(" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
name String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr c -> String
forall a. Show a => a -> String
show Expr c
a String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr b -> String
forall a. Show a => a -> String
show Expr b
b String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"
    show (AggNumericVector Expr b
expr Text
op Vector b -> a
_) = String
"(" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
op String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr b -> String
forall a. Show a => a -> String
show Expr b
expr String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"
    show (AggVector Expr b
expr Text
op v b -> a
_) = String
"(" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
op String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr b -> String
forall a. Show a => a -> String
show Expr b
expr String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"
    show (AggReduce Expr a
expr Text
op forall a. Columnable a => a -> a -> a
_) = String
"(" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
op String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr a -> String
forall a. Show a => a -> String
show Expr a
expr String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"
    show (AggFold Expr b
expr Text
op a
_ a -> b -> a
_) = String
"(" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
op String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr b -> String
forall a. Show a => a -> String
show Expr b
expr String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"

normalize :: (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize :: forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr a
expr = case Expr a
expr of
    Col Text
name -> Text -> Expr a
forall a. Columnable a => Text -> Expr a
Col Text
name
    Lit a
val -> a -> Expr a
forall a. Columnable a => a -> Expr a
Lit a
val
    If Expr Bool
cond Expr a
th Expr a
el -> Expr Bool -> Expr a -> Expr a -> Expr a
forall a. Columnable a => Expr Bool -> Expr a -> Expr a -> Expr a
If (Expr Bool -> Expr Bool
forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr Bool
cond) (Expr a -> Expr a
forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr a
th) (Expr a -> Expr a
forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr a
el)
    UnaryOp Text
name b -> a
f Expr b
e -> Text -> (b -> a) -> Expr b -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
name b -> a
f (Expr b -> Expr b
forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr b
e)
    BinaryOp Text
name c -> b -> a
f Expr c
e1 Expr b
e2
        | Text -> Bool
isCommutative Text
name ->
            let n1 :: Expr c
n1 = Expr c -> Expr c
forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr c
e1
                n2 :: Expr b
n2 = Expr b -> Expr b
forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr b
e2
             in case TypeRep (Expr c) -> TypeRep (Expr b) -> Maybe (Expr c :~: Expr 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 (Expr c -> TypeRep (Expr c)
forall a. Typeable a => a -> TypeRep a
typeOf Expr c
n1) (Expr b -> TypeRep (Expr b)
forall a. Typeable a => a -> TypeRep a
typeOf Expr b
n2) of
                    Maybe (Expr c :~: Expr b)
Nothing -> Expr a
expr
                    Just Expr c :~: Expr b
Refl ->
                        if Expr c -> Expr c -> Ordering
forall a. Expr a -> Expr a -> Ordering
compareExpr Expr c
n1 Expr c
Expr b
n2 Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
GT
                            then Text -> (c -> b -> a) -> Expr c -> Expr b -> Expr a
forall b b a.
(Columnable b, Columnable b, Columnable a) =>
Text -> (b -> b -> a) -> Expr b -> Expr b -> Expr a
BinaryOp Text
name c -> b -> a
f Expr c
Expr b
n2 Expr c
Expr b
n1 -- Swap to canonical order
                            else Text -> (c -> b -> a) -> Expr c -> Expr b -> Expr a
forall b b a.
(Columnable b, Columnable b, Columnable a) =>
Text -> (b -> b -> a) -> Expr b -> Expr b -> Expr a
BinaryOp Text
name c -> b -> a
f Expr c
n1 Expr b
n2
        | Bool
otherwise -> Text -> (c -> b -> a) -> Expr c -> Expr b -> Expr a
forall b b a.
(Columnable b, Columnable b, Columnable a) =>
Text -> (b -> b -> a) -> Expr b -> Expr b -> Expr a
BinaryOp Text
name c -> b -> a
f (Expr c -> Expr c
forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr c
e1) (Expr b -> Expr b
forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr b
e2)
    AggVector Expr b
e Text
name v b -> a
f -> Expr b -> Text -> (v b -> a) -> Expr a
forall (b :: * -> *) b a.
(Vector b b, Typeable b, Columnable a, Columnable b) =>
Expr b -> Text -> (b b -> a) -> Expr a
AggVector (Expr b -> Expr b
forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr b
e) Text
name v b -> a
f
    AggReduce Expr a
e Text
name forall a. Columnable a => a -> a -> a
f -> Expr a -> Text -> (forall a. Columnable a => a -> a -> a) -> Expr a
forall a.
Columnable a =>
Expr a -> Text -> (forall a. Columnable a => a -> a -> a) -> Expr a
AggReduce (Expr a -> Expr a
forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr a
e) Text
name a -> a -> a
forall a. Columnable a => a -> a -> a
f
    AggNumericVector Expr b
e Text
name Vector b -> a
f -> Expr b -> Text -> (Vector b -> a) -> Expr a
forall a b.
(Columnable a, Columnable b, Unbox a, Unbox b, Num a, Num b) =>
Expr b -> Text -> (Vector b -> a) -> Expr a
AggNumericVector (Expr b -> Expr b
forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr b
e) Text
name Vector b -> a
f
    AggFold Expr b
e Text
name a
init a -> b -> a
f -> Expr b -> Text -> a -> (a -> b -> a) -> Expr a
forall a b.
(Columnable a, Columnable b) =>
Expr b -> Text -> a -> (a -> b -> a) -> Expr a
AggFold (Expr b -> Expr b
forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr b
e) Text
name a
init a -> b -> a
f

isCommutative :: T.Text -> Bool
isCommutative :: Text -> Bool
isCommutative Text
name =
    Text
name
        Text -> [Text] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [ Text
"add"
               , Text
"mult"
               , Text
"min"
               , Text
"max"
               , Text
"eq"
               , Text
"and"
               , Text
"or"
               ]

-- Compare expressions for ordering (used in normalization)
compareExpr :: Expr a -> Expr a -> Ordering
compareExpr :: forall a. Expr a -> Expr a -> Ordering
compareExpr Expr a
e1 Expr a
e2 = String -> String -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Expr a -> String
forall a. Expr a -> String
exprKey Expr a
e1) (Expr a -> String
forall a. Expr a -> String
exprKey Expr a
e2)
  where
    exprKey :: Expr a -> String
    exprKey :: forall a. Expr a -> String
exprKey (Col Text
name) = String
"0:" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
name
    exprKey (Lit a
val) = String
"1:" String -> ShowS
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show a
val
    exprKey (If Expr Bool
c Expr a
t Expr a
e) = String
"2:" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr Bool -> String
forall a. Expr a -> String
exprKey Expr Bool
c String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr a -> String
forall a. Expr a -> String
exprKey Expr a
t String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr a -> String
forall a. Expr a -> String
exprKey Expr a
e
    exprKey (UnaryOp Text
name b -> a
_ Expr b
e) = String
"3:" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
name String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr b -> String
forall a. Expr a -> String
exprKey Expr b
e
    exprKey (BinaryOp Text
name c -> b -> a
_ Expr c
e1 Expr b
e2) = String
"4:" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
name String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr c -> String
forall a. Expr a -> String
exprKey Expr c
e1 String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr b -> String
forall a. Expr a -> String
exprKey Expr b
e2
    exprKey (AggVector Expr b
e Text
name v b -> a
_) = String
"5:" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
name String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr b -> String
forall a. Expr a -> String
exprKey Expr b
e
    exprKey (AggReduce Expr a
e Text
name forall a. Columnable a => a -> a -> a
_) = String
"6:" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
name String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr a -> String
forall a. Expr a -> String
exprKey Expr a
e
    exprKey (AggNumericVector Expr b
e Text
name Vector b -> a
_) = String
"7:" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
name String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr b -> String
forall a. Expr a -> String
exprKey Expr b
e
    exprKey (AggFold Expr b
e Text
name a
_ a -> b -> a
_) = String
"8:" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
name String -> ShowS
forall a. [a] -> [a] -> [a]
++ Expr b -> String
forall a. Expr a -> String
exprKey Expr b
e

instance (Eq a, Columnable a) => Eq (Expr a) where
    == :: Expr a -> Expr a -> Bool
(==) Expr a
l Expr a
r = Expr a -> Expr a -> Bool
eqNormalized (Expr a -> Expr a
forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr a
l) (Expr a -> Expr a
forall a. (Eq a, Ord a, Show a, Typeable a) => Expr a -> Expr a
normalize Expr a
r)
      where
        exprEq :: (Columnable b, Columnable c) => Expr b -> Expr c -> Bool
        exprEq :: forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Bool
exprEq Expr b
e1 Expr c
e2 = case TypeRep (Expr b) -> TypeRep (Expr c) -> Maybe (Expr b :~: Expr 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 (Expr b -> TypeRep (Expr b)
forall a. Typeable a => a -> TypeRep a
typeOf Expr b
e1) (Expr c -> TypeRep (Expr c)
forall a. Typeable a => a -> TypeRep a
typeOf Expr c
e2) of
            Just Expr b :~: Expr c
Refl -> Expr b
e1 Expr b -> Expr b -> Bool
forall a. Eq a => a -> a -> Bool
== Expr b
Expr c
e2
            Maybe (Expr b :~: Expr c)
Nothing -> Bool
False
        eqNormalized :: Expr a -> Expr a -> Bool
        eqNormalized :: Expr a -> Expr a -> Bool
eqNormalized (Col Text
n1) (Col Text
n2) = Text
n1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
n2
        eqNormalized (Lit a
v1) (Lit a
v2) = a
v1 a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
v2
        eqNormalized (If Expr Bool
c1 Expr a
t1 Expr a
e1) (If Expr Bool
c2 Expr a
t2 Expr a
e2) =
            Expr Bool
c1 Expr Bool -> Expr Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Expr Bool
c2 Bool -> Bool -> Bool
&& Expr a
t1 Expr a -> Expr a -> Bool
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Bool
`exprEq` Expr a
t2 Bool -> Bool -> Bool
&& Expr a
e1 Expr a -> Expr a -> Bool
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Bool
`exprEq` Expr a
e2
        eqNormalized (UnaryOp Text
n1 b -> a
_ Expr b
e1) (UnaryOp Text
n2 b -> a
_ Expr b
e2) =
            Text
n1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
n2 Bool -> Bool -> Bool
&& Expr b
e1 Expr b -> Expr b -> Bool
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Bool
`exprEq` Expr b
e2
        eqNormalized (BinaryOp Text
n1 c -> b -> a
_ Expr c
e1a Expr b
e1b) (BinaryOp Text
n2 c -> b -> a
_ Expr c
e2a Expr b
e2b) =
            Text
n1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
n2 Bool -> Bool -> Bool
&& Expr c
e1a Expr c -> Expr c -> Bool
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Bool
`exprEq` Expr c
e2a Bool -> Bool -> Bool
&& Expr b
e1b Expr b -> Expr b -> Bool
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Bool
`exprEq` Expr b
e2b
        eqNormalized (AggVector Expr b
e1 Text
n1 v b -> a
_) (AggVector Expr b
e2 Text
n2 v b -> a
_) =
            Text
n1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
n2 Bool -> Bool -> Bool
&& Expr b
e1 Expr b -> Expr b -> Bool
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Bool
`exprEq` Expr b
e2
        eqNormalized (AggReduce Expr a
e1 Text
n1 forall a. Columnable a => a -> a -> a
_) (AggReduce Expr a
e2 Text
n2 forall a. Columnable a => a -> a -> a
_) =
            Text
n1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
n2 Bool -> Bool -> Bool
&& Expr a
e1 Expr a -> Expr a -> Bool
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Bool
`exprEq` Expr a
e2
        eqNormalized (AggNumericVector Expr b
e1 Text
n1 Vector b -> a
_) (AggNumericVector Expr b
e2 Text
n2 Vector b -> a
_) =
            Text
n1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
n2 Bool -> Bool -> Bool
&& Expr b
e1 Expr b -> Expr b -> Bool
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Bool
`exprEq` Expr b
e2
        eqNormalized (AggFold Expr b
e1 Text
n1 a
i1 a -> b -> a
_) (AggFold Expr b
e2 Text
n2 a
i2 a -> b -> a
_) =
            Text
n1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
n2 Bool -> Bool -> Bool
&& Expr b
e1 Expr b -> Expr b -> Bool
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Bool
`exprEq` Expr b
e2 Bool -> Bool -> Bool
&& a
i1 a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
i2
        eqNormalized Expr a
_ Expr a
_ = Bool
False

instance (Ord a, Columnable a) => Ord (Expr a) where
    compare :: Expr a -> Expr a -> Ordering
    compare :: Expr a -> Expr a -> Ordering
compare Expr a
e1 Expr a
e2 = case (Expr a
e1, Expr a
e2) of
        (Col Text
n1, Col Text
n2) -> Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
n1 Text
n2
        (Lit a
v1, Lit a
v2) -> a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare a
v1 a
v2
        (If Expr Bool
c1 Expr a
t1 Expr a
e1', If Expr Bool
c2 Expr a
t2 Expr a
e2') ->
            Expr Bool -> Expr Bool -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Expr Bool
c1 Expr Bool
c2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Expr a -> Expr a -> Ordering
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Ordering
exprComp Expr a
t1 Expr a
t2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Expr a -> Expr a -> Ordering
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Ordering
exprComp Expr a
e1' Expr a
e2'
        (UnaryOp Text
n1 b -> a
_ Expr b
e1', UnaryOp Text
n2 b -> a
_ Expr b
e2') ->
            Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
n1 Text
n2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Expr b -> Expr b -> Ordering
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Ordering
exprComp Expr b
e1' Expr b
e2'
        (BinaryOp Text
n1 c -> b -> a
_ Expr c
a1 Expr b
b1, BinaryOp Text
n2 c -> b -> a
_ Expr c
a2 Expr b
b2) ->
            Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
n1 Text
n2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Expr c -> Expr c -> Ordering
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Ordering
exprComp Expr c
a1 Expr c
a2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Expr b -> Expr b -> Ordering
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Ordering
exprComp Expr b
b1 Expr b
b2
        (AggVector Expr b
e1' Text
n1 v b -> a
_, AggVector Expr b
e2' Text
n2 v b -> a
_) ->
            Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
n1 Text
n2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Expr b -> Expr b -> Ordering
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Ordering
exprComp Expr b
e1' Expr b
e2'
        (AggReduce Expr a
e1' Text
n1 forall a. Columnable a => a -> a -> a
_, AggReduce Expr a
e2' Text
n2 forall a. Columnable a => a -> a -> a
_) ->
            Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
n1 Text
n2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Expr a -> Expr a -> Ordering
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Ordering
exprComp Expr a
e1' Expr a
e2'
        (AggNumericVector Expr b
e1' Text
n1 Vector b -> a
_, AggNumericVector Expr b
e2' Text
n2 Vector b -> a
_) ->
            Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
n1 Text
n2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Expr b -> Expr b -> Ordering
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Ordering
exprComp Expr b
e1' Expr b
e2'
        (AggFold Expr b
e1' Text
n1 a
i1 a -> b -> a
_, AggFold Expr b
e2' Text
n2 a
i2 a -> b -> a
_) ->
            Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
n1 Text
n2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Expr b -> Expr b -> Ordering
forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Ordering
exprComp Expr b
e1' Expr b
e2' Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare a
i1 a
i2
        -- Different constructors - compare by priority
        (Col Text
_, Expr a
_) -> Ordering
LT
        (Expr a
_, Col Text
_) -> Ordering
GT
        (Lit a
_, Expr a
_) -> Ordering
LT
        (Expr a
_, Lit a
_) -> Ordering
GT
        (UnaryOp{}, Expr a
_) -> Ordering
LT
        (Expr a
_, UnaryOp{}) -> Ordering
GT
        (BinaryOp{}, Expr a
_) -> Ordering
LT
        (Expr a
_, BinaryOp{}) -> Ordering
GT
        (If{}, Expr a
_) -> Ordering
LT
        (Expr a
_, If{}) -> Ordering
GT
        (AggVector{}, Expr a
_) -> Ordering
LT
        (Expr a
_, AggVector{}) -> Ordering
GT
        (AggReduce{}, Expr a
_) -> Ordering
LT
        (Expr a
_, AggReduce{}) -> Ordering
GT
        (AggNumericVector{}, Expr a
_) -> Ordering
LT
        (Expr a
_, AggNumericVector{}) -> Ordering
GT

exprComp :: (Columnable b, Columnable c) => Expr b -> Expr c -> Ordering
exprComp :: forall b c.
(Columnable b, Columnable c) =>
Expr b -> Expr c -> Ordering
exprComp Expr b
e1 Expr c
e2 = case TypeRep (Expr b) -> TypeRep (Expr c) -> Maybe (Expr b :~: Expr 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 (Expr b -> TypeRep (Expr b)
forall a. Typeable a => a -> TypeRep a
typeOf Expr b
e1) (Expr c -> TypeRep (Expr c)
forall a. Typeable a => a -> TypeRep a
typeOf Expr c
e2) of
    Just Expr b :~: Expr c
Refl -> Expr b
e1 Expr b -> Expr b -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` Expr b
Expr c
e2
    Maybe (Expr b :~: Expr c)
Nothing -> Ordering
LT

replaceExpr ::
    forall a b c.
    (Columnable a, Columnable b, Columnable c) =>
    Expr a -> Expr b -> Expr c -> Expr c
replaceExpr :: forall a b c.
(Columnable a, Columnable b, Columnable c) =>
Expr a -> Expr b -> Expr c -> Expr c
replaceExpr Expr a
new Expr b
old Expr c
expr = case TypeRep b -> TypeRep c -> Maybe (b :~: 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 @b) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @c) of
    Just b :~: c
Refl -> case TypeRep a -> TypeRep c -> Maybe (a :~: 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 @a) (forall a. Typeable a => TypeRep a
forall {k} (a :: k). Typeable a => TypeRep a
typeRep @c) of
        Just a :~: c
Refl -> if Expr b
old Expr b -> Expr b -> Bool
forall a. Eq a => a -> a -> Bool
== Expr b
Expr c
expr then Expr a
Expr c
new else Expr c
replace'
        Maybe (a :~: c)
Nothing -> Expr c
expr
    Maybe (b :~: c)
Nothing -> Expr c
replace'
  where
    replace' :: Expr c
replace' = case Expr c
expr of
        (Col Text
_) -> Expr c
expr
        (Lit c
_) -> Expr c
expr
        (If Expr Bool
cond Expr c
l Expr c
r) ->
            Expr Bool -> Expr c -> Expr c -> Expr c
forall a. Columnable a => Expr Bool -> Expr a -> Expr a -> Expr a
If (Expr a -> Expr b -> Expr Bool -> Expr Bool
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
Expr a -> Expr b -> Expr c -> Expr c
replaceExpr Expr a
new Expr b
old Expr Bool
cond) (Expr a -> Expr b -> Expr c -> Expr c
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
Expr a -> Expr b -> Expr c -> Expr c
replaceExpr Expr a
new Expr b
old Expr c
l) (Expr a -> Expr b -> Expr c -> Expr c
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
Expr a -> Expr b -> Expr c -> Expr c
replaceExpr Expr a
new Expr b
old Expr c
r)
        (UnaryOp Text
name b -> c
f Expr b
value) -> Text -> (b -> c) -> Expr b -> Expr c
forall a b.
(Columnable a, Columnable b) =>
Text -> (b -> a) -> Expr b -> Expr a
UnaryOp Text
name b -> c
f (Expr a -> Expr b -> Expr b -> Expr b
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
Expr a -> Expr b -> Expr c -> Expr c
replaceExpr Expr a
new Expr b
old Expr b
value)
        (BinaryOp Text
name c -> b -> c
f Expr c
l Expr b
r) -> Text -> (c -> b -> c) -> Expr c -> Expr b -> Expr c
forall b b a.
(Columnable b, Columnable b, Columnable a) =>
Text -> (b -> b -> a) -> Expr b -> Expr b -> Expr a
BinaryOp Text
name c -> b -> c
f (Expr a -> Expr b -> Expr c -> Expr c
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
Expr a -> Expr b -> Expr c -> Expr c
replaceExpr Expr a
new Expr b
old Expr c
l) (Expr a -> Expr b -> Expr b -> Expr b
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
Expr a -> Expr b -> Expr c -> Expr c
replaceExpr Expr a
new Expr b
old Expr b
r)
        (AggNumericVector Expr b
expr Text
op Vector b -> c
f) -> Expr b -> Text -> (Vector b -> c) -> Expr c
forall a b.
(Columnable a, Columnable b, Unbox a, Unbox b, Num a, Num b) =>
Expr b -> Text -> (Vector b -> a) -> Expr a
AggNumericVector (Expr a -> Expr b -> Expr b -> Expr b
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
Expr a -> Expr b -> Expr c -> Expr c
replaceExpr Expr a
new Expr b
old Expr b
expr) Text
op Vector b -> c
f
        (AggVector Expr b
expr Text
op v b -> c
f) -> Expr b -> Text -> (v b -> c) -> Expr c
forall (b :: * -> *) b a.
(Vector b b, Typeable b, Columnable a, Columnable b) =>
Expr b -> Text -> (b b -> a) -> Expr a
AggVector (Expr a -> Expr b -> Expr b -> Expr b
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
Expr a -> Expr b -> Expr c -> Expr c
replaceExpr Expr a
new Expr b
old Expr b
expr) Text
op v b -> c
f
        (AggReduce Expr c
expr Text
op forall a. Columnable a => a -> a -> a
f) -> Expr c -> Text -> (forall a. Columnable a => a -> a -> a) -> Expr c
forall a.
Columnable a =>
Expr a -> Text -> (forall a. Columnable a => a -> a -> a) -> Expr a
AggReduce (Expr a -> Expr b -> Expr c -> Expr c
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
Expr a -> Expr b -> Expr c -> Expr c
replaceExpr Expr a
new Expr b
old Expr c
expr) Text
op a -> a -> a
forall a. Columnable a => a -> a -> a
f
        (AggFold Expr b
expr Text
op c
acc c -> b -> c
f) -> Expr b -> Text -> c -> (c -> b -> c) -> Expr c
forall a b.
(Columnable a, Columnable b) =>
Expr b -> Text -> a -> (a -> b -> a) -> Expr a
AggFold (Expr a -> Expr b -> Expr b -> Expr b
forall a b c.
(Columnable a, Columnable b, Columnable c) =>
Expr a -> Expr b -> Expr c -> Expr c
replaceExpr Expr a
new Expr b
old Expr b
expr) Text
op c
acc c -> b -> c
f

eSize :: Expr a -> Int
eSize :: forall a. Expr a -> Int
eSize (Col Text
_) = Int
1
eSize (Lit a
_) = Int
1
eSize (If Expr Bool
c Expr a
l Expr a
r) = Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Expr Bool -> Int
forall a. Expr a -> Int
eSize Expr Bool
c Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Expr a -> Int
forall a. Expr a -> Int
eSize Expr a
l Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Expr a -> Int
forall a. Expr a -> Int
eSize Expr a
r
eSize (UnaryOp Text
_ b -> a
_ Expr b
e) = Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Expr b -> Int
forall a. Expr a -> Int
eSize Expr b
e
eSize (BinaryOp Text
_ c -> b -> a
_ Expr c
l Expr b
r) = Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Expr c -> Int
forall a. Expr a -> Int
eSize Expr c
l Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Expr b -> Int
forall a. Expr a -> Int
eSize Expr b
r
eSize (AggNumericVector Expr b
expr Text
op Vector b -> a
_) = Expr b -> Int
forall a. Expr a -> Int
eSize Expr b
expr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
eSize (AggVector Expr b
expr Text
op v b -> a
_) = Expr b -> Int
forall a. Expr a -> Int
eSize Expr b
expr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
eSize (AggReduce Expr a
expr Text
op forall a. Columnable a => a -> a -> a
_) = Expr a -> Int
forall a. Expr a -> Int
eSize Expr a
expr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
eSize (AggFold Expr b
expr Text
op a
_ a -> b -> a
_) = Expr b -> Int
forall a. Expr a -> Int
eSize Expr b
expr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1