Data.HappyTree

Documentation

type family RevAppend (a :: [a]) (a :: [a]) :: [a] where ...

Equations

RevAppend '[] x = x

RevAppend ((:) x xs) n = Apply (Apply RevAppendSym0 xs) (Apply (Apply (:$) x) n)

data RevAppendSym0 (l :: TyFun [a6989586621679075741] (TyFun [a6989586621679075741] [a6989586621679075741] -> Type))

Constructors

SameKind (Apply RevAppendSym0 arg) (RevAppendSym1 arg) => RevAppendSym0KindInference

Instances

SuppressUnusedWarnings (TyFun [a6989586621679075741] (TyFun [a6989586621679075741] [a6989586621679075741] -> Type) -> *) (RevAppendSym0 a6989586621679075741)

Methods

suppressUnusedWarnings :: Proxy (RevAppendSym0 a6989586621679075741) t -> ()

type Apply [a6989586621679075741] (TyFun [a6989586621679075741] [a6989586621679075741] -> Type) (RevAppendSym0 a6989586621679075741) l

type Apply [a6989586621679075741] (TyFun [a6989586621679075741] [a6989586621679075741] -> Type) (RevAppendSym0 a6989586621679075741) l = RevAppendSym1 a6989586621679075741 l

data RevAppendSym1 (l :: [a6989586621679075741]) (l :: TyFun [a6989586621679075741] [a6989586621679075741])

Constructors

SameKind (Apply (RevAppendSym1 l) arg) (RevAppendSym2 l arg) => RevAppendSym1KindInference

Instances

SuppressUnusedWarnings ([a6989586621679075741] -> TyFun [a6989586621679075741] [a6989586621679075741] -> *) (RevAppendSym1 a6989586621679075741)

Methods

suppressUnusedWarnings :: Proxy (RevAppendSym1 a6989586621679075741) t -> ()

type Apply [a] [a] (RevAppendSym1 a l1) l2

type Apply [a] [a] (RevAppendSym1 a l1) l2 = RevAppend a l1 l2

type RevAppendSym2 (t :: [a6989586621679075741]) (t :: [a6989586621679075741]) = RevAppend t t

type family SelElemAux (a :: [a]) (a :: [a]) :: [(a, [a])] where ...

Equations

SelElemAux l '[] = '[]

SelElemAux l ((:) r rs) = Apply (Apply (:$) (Apply (Apply Tuple2Sym0 r) (Apply (Apply RevAppendSym0 l) rs))) (Apply (Apply SelElemAuxSym0 (Apply (Apply (:$) r) l)) rs)

data SelElemAuxSym0 (l :: TyFun [a6989586621679075740] (TyFun [a6989586621679075740] [(a6989586621679075740, [a6989586621679075740])] -> Type))

Constructors

SameKind (Apply SelElemAuxSym0 arg) (SelElemAuxSym1 arg) => SelElemAuxSym0KindInference

Instances

SuppressUnusedWarnings (TyFun [a6989586621679075740] (TyFun [a6989586621679075740] [(a6989586621679075740, [a6989586621679075740])] -> Type) -> *) (SelElemAuxSym0 a6989586621679075740)

Methods

suppressUnusedWarnings :: Proxy (SelElemAuxSym0 a6989586621679075740) t -> ()

type Apply [a6989586621679075740] (TyFun [a6989586621679075740] [(a6989586621679075740, [a6989586621679075740])] -> Type) (SelElemAuxSym0 a6989586621679075740) l

type Apply [a6989586621679075740] (TyFun [a6989586621679075740] [(a6989586621679075740, [a6989586621679075740])] -> Type) (SelElemAuxSym0 a6989586621679075740) l = SelElemAuxSym1 a6989586621679075740 l

data SelElemAuxSym1 (l :: [a6989586621679075740]) (l :: TyFun [a6989586621679075740] [(a6989586621679075740, [a6989586621679075740])])

Constructors

SameKind (Apply (SelElemAuxSym1 l) arg) (SelElemAuxSym2 l arg) => SelElemAuxSym1KindInference

Instances

SuppressUnusedWarnings ([a6989586621679075740] -> TyFun [a6989586621679075740] [(a6989586621679075740, [a6989586621679075740])] -> *) (SelElemAuxSym1 a6989586621679075740)

Methods

suppressUnusedWarnings :: Proxy (SelElemAuxSym1 a6989586621679075740) t -> ()

type Apply [a] [(a, [a])] (SelElemAuxSym1 a l1) l2

type Apply [a] [(a, [a])] (SelElemAuxSym1 a l1) l2 = SelElemAux a l1 l2

type SelElemAuxSym2 (t :: [a6989586621679075740]) (t :: [a6989586621679075740]) = SelElemAux t t

type family SelElem (a :: [a]) :: [(a, [a])] where ...

Equations

SelElem a_6989586621679076669 = Apply (Apply SelElemAuxSym0 '[]) a_6989586621679076669

type SelElemSym1 (t :: [a6989586621679075739]) = SelElem t

data SelElemSym0 (l :: TyFun [a6989586621679075739] [(a6989586621679075739, [a6989586621679075739])])

Constructors

SameKind (Apply SelElemSym0 arg) (SelElemSym1 arg) => SelElemSym0KindInference

Instances

SuppressUnusedWarnings (TyFun [a6989586621679075739] [(a6989586621679075739, [a6989586621679075739])] -> *) (SelElemSym0 a6989586621679075739)

Methods

suppressUnusedWarnings :: Proxy (SelElemSym0 a6989586621679075739) t -> ()

type Apply [a] [(a, [a])] (SelElemSym0 a) l

type Apply [a] [(a, [a])] (SelElemSym0 a) l = SelElem a l

sSelElem :: forall (t :: [a]). Sing t -> Sing (Apply SelElemSym0 t :: [(a, [a])])

sSelElemAux :: forall (t :: [a]) (t :: [a]). Sing t -> Sing t -> Sing (Apply (Apply SelElemAuxSym0 t) t :: [(a, [a])])

sRevAppend :: forall (t :: [a]) (t :: [a]). Sing t -> Sing t -> Sing (Apply (Apply RevAppendSym0 t) t :: [a])

selElem :: [a] -> [(a, [a])]

selElemAux :: [a] -> [a] -> [(a, [a])]

revAppend :: [a] -> [a] -> [a]

takeElemAux :: [a] -> [a] -> [([a], a, [a])]

takeElem :: [a] -> [([a], a, [a])]

data SelElemTypeAux a

Constructors

SelElemTypeAux (Fst a) (NP I (Snd a))

type SelElemAuxType a b = NP SelElemTypeAux (SelElemAux a b)

type SelElemType a = SelElemAuxType '[] a

npRevAppend :: NP f a -> NP f b -> NP f (RevAppend a b)

npSelElemAux :: NP I a -> NP I b -> SelElemAuxType a b

npSelElem :: NP I a -> SelElemAuxType '[] a

dictSList :: SList a -> Dict (SListI a)

sListCons :: Proxy a -> SList b -> SList (a ': b)

npAppend :: NP f a -> NP f b -> NP f (a :++ b)

npToSList :: NP f a -> SList a

newtype SplitOnAux a b c

Constructors

SplitOnAux

Fields

• runSplitOnAux :: DecisionTree (c :++ a) b

data SplitOn (b :: *) (x :: (*, [*]))

Constructors

SListI c => SplitOn (Fst x -> SOP I c) (NP (SplitOnAux (Snd x) b) c)

data DecisionTree (a :: [*]) (b :: *)

Constructors

Leaf (NP I a -> b)

Split (NS (SplitOn b) (SelElem a))

eval :: DecisionTree a b -> NP I a -> b

entropy :: Ord a => [a] -> Double

data IndexAux (l :: k) (r :: k)

Constructors

(l ~ r) => IndexAux

newtype Index (l :: [k]) (x :: k)

Constructors

Index

Fields

• runIndex :: NS (IndexAux x) l

fromIndex :: SListI l => NP f l -> Index l x -> f x

class GetIndex l x where

Minimal complete definition

getIndex

Methods

getIndex :: Proxy l -> Proxy x -> Index l x

Instances

GetIndex k ((:) k l r) l

Methods

getIndex :: Proxy [(k ': l) r] l -> Proxy ((k ': l) r) x -> Index ((k ': l) r) l x

GetIndex k r x => GetIndex k ((:) k l r) x

Methods

getIndex :: Proxy [(k ': l) r] x -> Proxy ((k ': l) r) x -> Index ((k ': l) r) x x

newtype SplitFunAuxAux b d

Constructors

SplitFunAuxAux

Fields

• runSplitFunAuxAux :: [(NP I d, b)]

data SplitFun env a b

Constructors

(SListI2 c, All2 (GetIndex env) c) => SplitFun (a -> SOP I c) (NP (SplitFunAuxAux b) c)

unitSplitFun :: [b] -> SplitFun env a b

splitFunP :: (SListI2 c, All2 (GetIndex env) c) => Proxy c -> (a -> SOP I c) -> NP (SplitFunAuxAux b) c -> SplitFun env a b

data SplitStrat (env :: [*]) a

Constructors

SplitStrat (forall b. [(a, b)] -> [SplitFun env a b])

Instances

Monoid (SplitStrat env a)

Methods

mempty :: SplitStrat env a

mappend :: SplitStrat env a -> SplitStrat env a -> SplitStrat env a

mconcat :: [SplitStrat env a] -> SplitStrat env a

runSplitFun :: SplitStrat env a -> [(a, b)] -> [SplitFun env a b]

type SplitStrats cur env = NP (SplitStrat env) cur

splitStaticAux :: SplitStrat env a -> Proxy (GetIndex env)

splitStatic :: (SListI2 c, All2 (GetIndex env) c) => (a -> SOP I c) -> SplitStrat env a

splitOrd :: (Ord a, GetIndex env a) => SplitStrat env a

splitStructure :: (Generic a, SListI2 (Code a), All2 (GetIndex env) (Code a)) => SplitStrat env a

getIndex2 :: All (GetIndex l) r => SList r -> NP (Index l) r

mode :: Ord a => [a] -> a

nMinOnAux :: Ord b => (forall x. f x -> b) -> NP f a -> Maybe (b, NS f a)

nMinOn :: Ord b => (forall x. f x -> b) -> NP f a -> Maybe (NS f a)

data SelElemTypeAuxIndex env a

Constructors

SelElemTypeAuxIndex (Index env (Fst a)) (NP (Index env) (Snd a))

selElemTypeAuxIndex :: NP (Index env) a -> NP (Index env) b -> NP (SelElemTypeAuxIndex env) (SelElemAux a b)

fromSF :: SplitFun (env :: [*]) a b -> Proxy (All (GetIndex env))

newtype BuildAuxAux a b

Constructors

BuildAuxAux

Fields

• runBuildAuxAux :: [(a, Fst b, NP I (Snd b))]

data Score

Constructors

Destructing

Deciding Double

Instances

Eq Score

Methods

(==) :: Score -> Score -> Bool

(/=) :: Score -> Score -> Bool

Ord Score

Methods

compare :: Score -> Score -> Ordering

(<) :: Score -> Score -> Bool

(<=) :: Score -> Score -> Bool

(>) :: Score -> Score -> Bool

(>=) :: Score -> Score -> Bool

max :: Score -> Score -> Score

min :: Score -> Score -> Score

newtype WithScore b x

Constructors

WithScore

Fields

• runWithScore :: (Score, SplitOn b x)

buildTree :: (SListI env, Ord b) => SplitStrats env env -> NP (Index env) (Snd a1) -> b -> SplitFun env (Fst a1) (b, NP I (Snd a1)) -> (Score, SplitOn b a1)

buildAux :: (SListI env, Ord b) => NP (Index env) a -> SplitStrats env env -> [(NP I a, b)] -> b -> DecisionTree a b

build :: (All (GetIndex env) a, SListI env, Ord b) => SplitStrats env env -> [(NP I a, b)] -> b -> DecisionTree a b