Predicate.Data.Foldable

promoted foldable functions

Documentation

data Concat

similar to concat

>>> pz @Concat (Just "abc")
Val "abc"

>>> pz @Concat (Left 123)
Val []

>>> pz @Concat ["abc","D","eF","","G"]
Val "abcDeFG"

>>> pz @(Snd >> Concat) ('x',["abc","D","eF","","G"])
Val "abcDeFG"

Instances

Show Concat

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> Concat -> ShowS

show :: Concat -> String

showList :: [Concat] -> ShowS

(Show x, x ~ t [a], Show a, Foldable t) => P Concat x

Defined in Predicate.Data.Foldable

Associated Types

type PP Concat x

Methods

eval :: MonadEval m => proxy Concat -> POpts -> x -> m (TT (PP Concat x))

type PP Concat x

Defined in Predicate.Data.Foldable

type PP Concat x = ExtractAFromTA x

data ConcatMap p q

similar to concatMap

Instances

P (ConcatMapT p q) x => P (ConcatMap p q :: Type) x

Defined in Predicate.Data.Foldable

Associated Types

type PP (ConcatMap p q) x

Methods

eval :: MonadEval m => proxy (ConcatMap p q) -> POpts -> x -> m (TT (PP (ConcatMap p q) x))

Show (ConcatMap p q)

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> ConcatMap p q -> ShowS

show :: ConcatMap p q -> String

showList :: [ConcatMap p q] -> ShowS

type PP (ConcatMap p q :: Type) x

Defined in Predicate.Data.Foldable

type PP (ConcatMap p q :: Type) x

data Cycle n p

similar to cycle but for a fixed number n: for an empty list it just returns an empty list

>>> pz @(Cycle 5 Id) [1,2]
Val [1,2,1,2,1]

>>> pz @(Cycle 5 Id) []
Val []

Instances

(PP p x ~ t a, Show x, P p x, Integral (PP n x), P n x, Foldable t) => P (Cycle n p :: Type) x

Defined in Predicate.Data.Foldable

Associated Types

type PP (Cycle n p) x

Methods

eval :: MonadEval m => proxy (Cycle n p) -> POpts -> x -> m (TT (PP (Cycle n p) x))

Show (Cycle n p)

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> Cycle n p -> ShowS

show :: Cycle n p -> String

showList :: [Cycle n p] -> ShowS

type PP (Cycle n p :: Type) x

Defined in Predicate.Data.Foldable

type PP (Cycle n p :: Type) x = [ExtractAFromTA (PP p x)]

data FoldAla (t :: Type)

wraps each item in the foldable container and then unwraps the mconcatenated result: uses Wrapped

>>> pz @(FoldAla (SG.Sum _)) [44, 12, 3]
Val 59

>>> pz @(FoldAla (SG.Product _)) [44, 12, 3]
Val 1584

>>> type Ands' = FoldAla SG.All
>>> pz @Ands' [True,False,True,True]
Val False

>>> pz @Ands' [True,True,True]
Val True

>>> pz @Ands' []
Val True

>>> type Ors' = FoldAla SG.Any
>>> pz @Ors' [False,False,False]
Val False

>>> pz @Ors' []
Val False

>>> pz @Ors' [False,False,False,True]
Val True

>>> type AllPositive' = Map Positive >> FoldAla SG.All
>>> pz @AllPositive' [3,1,-5,10,2,3]
Val False

>>> type AllNegative' = Map Negative >> FoldAla SG.All
>>> pz @AllNegative' [-1,-5,-10,-2,-3]
Val True

>>> :set -XKindSignatures
>>> type Max' (t :: Type) = FoldAla (SG.Max t) -- requires t be Bounded for monoid instance
>>> pz @(Max' Int) [10,4,5,12,3,4]
Val 12

>>> pl @(FoldAla (SG.Sum _)) [14,8,17,13]
Present 52 ((>>) 52 | {getSum = 52})
Val 52

>>> pl @(FoldAla (SG.Max _)) [14 :: Int,8,17,13] -- allowed as the values are Bounded!
Present 17 ((>>) 17 | {getMax = 17})
Val 17

>>> pl @((Len >> (Elem Id '[4,7,1] || (Mod Id 3 >> Same 0))) || (FoldAla (SG.Sum _) >> Gt 200)) [1..20]
True (False || True)
Val True

>>> pl @((Len >> (Elem Id '[4,7,1] || (Mod Id 3 >> Same 0))) || (FoldAla (SG.Sum _) >> Gt 200)) [1..19]
False (False || False | ((>>) False | {1 == 0}) || ((>>) False | {190 > 200}))
Val False

>>> pl @((Len >> (Elem Id '[4,7,1] || (Mod Id 3 >> Same 0))) || (FoldAla (SG.Sum _) >> Gt 200)) []
True (True || False)
Val True

>>> pl @((Len >> (Elem Id '[4,7,1] || (Mod Id 3 >> Same 0))) &&& FoldAla (SG.Sum _)) [1..20]
Present (False,210) ('(False,210))
Val (False,210)

>>> pl @(FoldAla SG.Any) [False,False,True,False]
Present True ((>>) True | {getAny = True})
Val True

>>> pl @(FoldAla SG.All) [False,False,True,False]
Present False ((>>) False | {getAll = False})
Val False

>>> pl @(FoldAla (SG.Sum _)) (Just 13)
Present 13 ((>>) 13 | {getSum = 13})
Val 13

>>> pl @(FoldAla (SG.Sum _)) [1..10]
Present 55 ((>>) 55 | {getSum = 55})
Val 55

Instances

Show (FoldAla t)

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> FoldAla t -> ShowS

show :: FoldAla t -> String

showList :: [FoldAla t] -> ShowS

P (FoldAlaT t) x => P (FoldAla t :: Type) x

Defined in Predicate.Data.Foldable

Associated Types

type PP (FoldAla t) x

Methods

eval :: MonadEval m => proxy (FoldAla t) -> POpts -> x -> m (TT (PP (FoldAla t) x))

type PP (FoldAla t :: Type) x

Defined in Predicate.Data.Foldable

type PP (FoldAla t :: Type) x

data FoldMap p

similar to foldMap

>>> pl @(FoldMap (Wrap (SG.Sum _) Id)) (Left "x")
Present Sum {getSum = 0} (FoldMap <skipped>)
Val (Sum {getSum = 0})

>>> pz @(FoldMap (Wrap (SG.Sum _) Id)) [1..5]
Val (Sum {getSum = 15})

>>> pl @(FoldMap (Wrap (SG.Sum _) Id)) (Right 123)
Present Sum {getSum = 123} (FoldMap Wrap Sum {getSum = 123} | 123)
Val (Sum {getSum = 123})

>>> pl @(FoldMap (Map Len)) (Just ["abc","defg","h"])
Present [3,4,1] (FoldMap Map [3,4,1] | ["abc","defg","h"])
Val [3,4,1]

>>> pz @(FoldMap (Map Len)) (Just ["abc","defg","h"])
Val [3,4,1]

>>> pz @(FoldMap (Wrap (SG.Sum _) Len)) ["abc","defg","h"]
Val (Sum {getSum = 8})

>>> pz @(FoldMap (FoldMap (Wrap (SG.Sum _) Id))) (Just [1..10])
Val (Sum {getSum = 55})

Instances

(Traversable n, Monoid t, PP p a ~ t, P p a) => P (FoldMap p :: Type) (n a)

Defined in Predicate.Data.Foldable

Associated Types

type PP (FoldMap p) (n a)

Methods

eval :: MonadEval m => proxy (FoldMap p) -> POpts -> n a -> m (TT (PP (FoldMap p) (n a)))

Show (FoldMap p)

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> FoldMap p -> ShowS

show :: FoldMap p -> String

showList :: [FoldMap p] -> ShowS

type PP (FoldMap p :: Type) (n a)

Defined in Predicate.Data.Foldable

type PP (FoldMap p :: Type) (n a) = PP p a

data ToListExt

invokes toList

>>> pz @ToListExt (M.fromList [(1,'x'),(4,'y')])
Val [(1,'x'),(4,'y')]

>>> pz @ToListExt (T.pack "abc")
Val "abc"

Instances

Show ToListExt

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> ToListExt -> ShowS

show :: ToListExt -> String

showList :: [ToListExt] -> ShowS

(Show l, IsList l, Show (Item l)) => P ToListExt l

Defined in Predicate.Data.Foldable

Associated Types

type PP ToListExt l

Methods

eval :: MonadEval m => proxy ToListExt -> POpts -> l -> m (TT (PP ToListExt l))

type PP ToListExt l

Defined in Predicate.Data.Foldable

type PP ToListExt l = [Item l]

data FromList (t :: Type)

invokes fromList

>>> run @('OMsg "Fred" ':# 'OLite ':# 'OColorOff) @(FromList (Set.Set Int) << '[2,1,5,5,2,5,2]) ()
Fred >>> Present fromList [1,2,5] ((>>) fromList [1,2,5] | {FromList fromList [1,2,5]})
Val (fromList [1,2,5])

>>> pl @(FromList (M.Map _ _) >> Id !! C "y") [('x',True),('y',False)]
Present False ((>>) False | {IxL('y') False | p=fromList [('x',True),('y',False)] | q='y'})
Val False

>>> pl @(FromList (M.Map _ _) >> Id !! C "z") [('x',True),('y',False)]
Error (!!) index not found (IxL('z') | fromList [('x',True),('y',False)])
Fail "(!!) index not found"

>>> pl @(FromList (M.Map _ _)) [(4,"x"),(5,"dd")]
Present fromList [(4,"x"),(5,"dd")] (FromList fromList [(4,"x"),(5,"dd")])
Val (fromList [(4,"x"),(5,"dd")])

Instances

Show (FromList t)

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> FromList t -> ShowS

show :: FromList t -> String

showList :: [FromList t] -> ShowS

(a ~ Item t, Show t, IsList t, [a] ~ x) => P (FromList t :: Type) x

Defined in Predicate.Data.Foldable

Associated Types

type PP (FromList t) x

Methods

eval :: MonadEval m => proxy (FromList t) -> POpts -> x -> m (TT (PP (FromList t) x))

type PP (FromList t :: Type) x

Defined in Predicate.Data.Foldable

type PP (FromList t :: Type) x = t

data FromListExt (t :: Type)

invokes fromList

requires the OverloadedLists extension

>>> :set -XOverloadedLists
>>> pz @(FromListExt (M.Map _ _)) [(4,"x"),(5,"dd")]
Val (fromList [(4,"x"),(5,"dd")])

Instances

Show (FromListExt t)

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> FromListExt t -> ShowS

show :: FromListExt t -> String

showList :: [FromListExt t] -> ShowS

(Show l, IsList l, l ~ l') => P (FromListExt l' :: Type) l

Defined in Predicate.Data.Foldable

Associated Types

type PP (FromListExt l') l

Methods

eval :: MonadEval m => proxy (FromListExt l') -> POpts -> l -> m (TT (PP (FromListExt l') l))

type PP (FromListExt l' :: Type) l

Defined in Predicate.Data.Foldable

type PP (FromListExt l' :: Type) l = l'

data ToList

similar to toList

>>> pz @ToList "aBc"
Val "aBc"

>>> pz @ToList (Just 14)
Val [14]

>>> pz @ToList Nothing
Val []

>>> pz @ToList (Left "xx")
Val []

>>> pz @ToList (These 12 "xx")
Val ["xx"]

>>> pl @ToList (M.fromList $ zip [0..] "abcd")
Present "abcd" (ToList fromList [(0,'a'),(1,'b'),(2,'c'),(3,'d')])
Val "abcd"

>>> pl @ToList (Just 123)
Present [123] (ToList Just 123)
Val [123]

>>> pl @ToList (M.fromList (zip ['a'..] [9,2,7,4]))
Present [9,2,7,4] (ToList fromList [('a',9),('b',2),('c',7),('d',4)])
Val [9,2,7,4]

Instances

Show ToList

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> ToList -> ShowS

show :: ToList -> String

showList :: [ToList] -> ShowS

(Show (t a), Foldable t) => P ToList (t a)

Defined in Predicate.Data.Foldable

Associated Types

type PP ToList (t a)

Methods

eval :: MonadEval m => proxy ToList -> POpts -> t a -> m (TT (PP ToList (t a)))

type PP ToList (t a)

Defined in Predicate.Data.Foldable

type PP ToList (t a) = [a]

data IToList (t :: Type)

similar to itoList

>>> pz @(IToList _) ("aBc" :: String)
Val [(0,'a'),(1,'B'),(2,'c')]

>>> pl @(IToList _) ("abcd" :: String)
Present [(0,'a'),(1,'b'),(2,'c'),(3,'d')] (IToList(Int) [(0,'a'),(1,'b'),(2,'c'),(3,'d')] | "abcd")
Val [(0,'a'),(1,'b'),(2,'c'),(3,'d')]

>>> pl @(IToList _) (M.fromList $ itoList ("abcd" :: String))
Present [(0,'a'),(1,'b'),(2,'c'),(3,'d')] (IToList(Int) [(0,'a'),(1,'b'),(2,'c'),(3,'d')] | fromList [(0,'a'),(1,'b'),(2,'c'),(3,'d')])
Val [(0,'a'),(1,'b'),(2,'c'),(3,'d')]

>>> pl @(IToList _) [9,2,7,4]
Present [(0,9),(1,2),(2,7),(3,4)] (IToList(Int) [(0,9),(1,2),(2,7),(3,4)] | [9,2,7,4])
Val [(0,9),(1,2),(2,7),(3,4)]

>>> pl @(IToList _) (M.fromList (zip ['a'..] [9,2,7,4]))
Present [('a',9),('b',2),('c',7),('d',4)] (IToList(Char) [('a',9),('b',2),('c',7),('d',4)] | fromList [('a',9),('b',2),('c',7),('d',4)])
Val [('a',9),('b',2),('c',7),('d',4)]

>>> pl @(IToList _) (Just 234)
Present [((),234)] (IToList(()) [((),234)] | Just 234)
Val [((),234)]

>>> pl @(IToList _) (Nothing @Double)
Present [] (IToList(()) [] | Nothing)
Val []

>>> pl @(IToList _) [1..5]
Present [(0,1),(1,2),(2,3),(3,4),(4,5)] (IToList(Int) [(0,1),(1,2),(2,3),(3,4),(4,5)] | [1,2,3,4,5])
Val [(0,1),(1,2),(2,3),(3,4),(4,5)]

>>> pl @(IToList _) ['a','b','c']
Present [(0,'a'),(1,'b'),(2,'c')] (IToList(Int) [(0,'a'),(1,'b'),(2,'c')] | "abc")
Val [(0,'a'),(1,'b'),(2,'c')]

Instances

Show (IToList t)

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> IToList t -> ShowS

show :: IToList t -> String

showList :: [IToList t] -> ShowS

P (IToListT t) x => P (IToList t :: Type) x

Defined in Predicate.Data.Foldable

Associated Types

type PP (IToList t) x

Methods

eval :: MonadEval m => proxy (IToList t) -> POpts -> x -> m (TT (PP (IToList t) x))

type PP (IToList t :: Type) x

Defined in Predicate.Data.Foldable

type PP (IToList t :: Type) x

data IToList' t p

explicit version of IToList with an extra parameter p to point to the value

>>> pz @(IToList' (Hole _) Snd) (True,"aBc" :: String)
Val [(0,'a'),(1,'B'),(2,'c')]

Instances

(Typeable (PP t x), Show (PP t x), FoldableWithIndex (PP t x) f, PP p x ~ f a, P p x, Show x, Show a) => P (IToList' t p :: Type) x

Defined in Predicate.Data.Foldable

Associated Types

type PP (IToList' t p) x

Methods

eval :: MonadEval m => proxy (IToList' t p) -> POpts -> x -> m (TT (PP (IToList' t p) x))

Show (IToList' t p)

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> IToList' t p -> ShowS

show :: IToList' t p -> String

showList :: [IToList' t p] -> ShowS

type PP (IToList' t p :: Type) x

Defined in Predicate.Data.Foldable

type PP (IToList' t p :: Type) x = [(PP t x, ExtractAFromTA (PP p x))]

data ToNEList

create a NonEmpty list from a Foldable

>>> pz @ToNEList []
Fail "empty list"

>>> pz @ToNEList [1,2,3,4,5]
Val (1 :| [2,3,4,5])

Instances

Show ToNEList

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> ToNEList -> ShowS

show :: ToNEList -> String

showList :: [ToNEList] -> ShowS

(Show (t a), Foldable t) => P ToNEList (t a)

Defined in Predicate.Data.Foldable

Associated Types

type PP ToNEList (t a)

Methods

eval :: MonadEval m => proxy ToNEList -> POpts -> t a -> m (TT (PP ToNEList (t a)))

type PP ToNEList (t a)

Defined in Predicate.Data.Foldable

type PP ToNEList (t a) = NonEmpty a

data OneP

gets the singleton value from a foldable

>>> pl @OneP [10..15]
Error OneP:expected one element(6)
Fail "OneP:expected one element(6)"

>>> pl @OneP [10]
Present 10 (OneP)
Val 10

>>> pl @OneP []
Error OneP:expected one element(empty)
Fail "OneP:expected one element(empty)"

>>> pl @OneP (Just 10)
Present 10 (OneP)
Val 10

>>> pl @OneP Nothing
Error OneP:expected one element(empty)
Fail "OneP:expected one element(empty)"

Instances

Show OneP

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> OneP -> ShowS

show :: OneP -> String

showList :: [OneP] -> ShowS

(Foldable t, x ~ t a) => P OneP x

Defined in Predicate.Data.Foldable

Associated Types

type PP OneP x

Methods

eval :: MonadEval m => proxy OneP -> POpts -> x -> m (TT (PP OneP x))

type PP OneP x

Defined in Predicate.Data.Foldable

type PP OneP x = ExtractAFromTA x

data Null

similar to null using Foldable

>>> pz @Null [1,2,3,4]
Val False

>>> pz @Null []
Val True

>>> pz @Null Nothing
Val True

Instances

Show Null

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> Null -> ShowS

show :: Null -> String

showList :: [Null] -> ShowS

P NullT a => P Null a

Defined in Predicate.Data.Foldable

Associated Types

type PP Null a

Methods

eval :: MonadEval m => proxy Null -> POpts -> a -> m (TT (PP Null a))

type PP Null a

Defined in Predicate.Data.Foldable

type PP Null a = Bool

data Null' p

explicit version of Null with an extra parameter p to point to the value

Instances

(Show (t a), Foldable t, t a ~ PP p x, P p x) => P (Null' p :: Type) x

Defined in Predicate.Data.Foldable

Associated Types

type PP (Null' p) x

Methods

eval :: MonadEval m => proxy (Null' p) -> POpts -> x -> m (TT (PP (Null' p) x))

Show (Null' p)

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> Null' p -> ShowS

show :: Null' p -> String

showList :: [Null' p] -> ShowS

type PP (Null' p :: Type) x

Defined in Predicate.Data.Foldable

type PP (Null' p :: Type) x = Bool

data IsEmpty

similar to null using AsEmpty

>>> pz @IsEmpty [1,2,3,4]
Val False

>>> pz @IsEmpty []
Val True

>>> pz @IsEmpty LT
Val False

>>> pz @IsEmpty EQ
Val True

>>> pl @IsEmpty ("failed11" :: T.Text)
False (IsEmpty | "failed11")
Val False

>>> pl @IsEmpty ("" :: T.Text)
True (IsEmpty | "")
Val True

Instances

Show IsEmpty

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> IsEmpty -> ShowS

show :: IsEmpty -> String

showList :: [IsEmpty] -> ShowS

(Show as, AsEmpty as) => P IsEmpty as

Defined in Predicate.Data.Foldable

Associated Types

type PP IsEmpty as

Methods

eval :: MonadEval m => proxy IsEmpty -> POpts -> as -> m (TT (PP IsEmpty as))

type PP IsEmpty as

Defined in Predicate.Data.Foldable

type PP IsEmpty as = Bool

data Ands

similar to and

>>> pz @Ands [True,True,True]
Val True

>>> pl @Ands [True,True,True,False]
False (Ands(4) i=3 | [True,True,True,False])
Val False

>>> pz @Ands []
Val True

Instances

Show Ands

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> Ands -> ShowS

show :: Ands -> String

showList :: [Ands] -> ShowS

(x ~ t a, Foldable t, a ~ Bool) => P Ands x

Defined in Predicate.Data.Foldable

Associated Types

type PP Ands x

Methods

eval :: MonadEval m => proxy Ands -> POpts -> x -> m (TT (PP Ands x))

type PP Ands x

Defined in Predicate.Data.Foldable

type PP Ands x = Bool

data Ors

similar to or

>>> pz @Ors [False,False,False]
Val False

>>> pl @Ors [True,True,True,False]
True (Ors(4) i=0 | [True,True,True,False])
Val True

>>> pl @Ors []
False (Ors(0) | [])
Val False

Instances

Show Ors

Defined in Predicate.Data.Foldable

Methods

showsPrec :: Int -> Ors -> ShowS

show :: Ors -> String

showList :: [Ors] -> ShowS

(x ~ t a, Foldable t, a ~ Bool) => P Ors x

Defined in Predicate.Data.Foldable

Associated Types

type PP Ors x

Methods

eval :: MonadEval m => proxy Ors -> POpts -> x -> m (TT (PP Ors x))

type PP Ors x

Defined in Predicate.Data.Foldable

type PP Ors x = Bool