Predicate.Data.Enum

promoted enum functions

constructors

data p ... q infix 7

similar to enumFromTo

>>> pz @(2 ... 5) ()
Val [2,3,4,5]

>>> pz @('LT ... 'GT) ()
Val [LT,EQ,GT]

>>> pz @('Just (MkDay '(2020, 1, 2)) ... 'Just (MkDay '(2020, 1, 7))) ()
Val [2020-01-02,2020-01-03,2020-01-04,2020-01-05,2020-01-06,2020-01-07]

Instances

P (EnumFromToT p q) x => P (p ... q :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (p ... q) x

Methods

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

Show (p ... q)

Defined in Predicate.Data.Enum

Methods

showsPrec :: Int -> (p ... q) -> ShowS

show :: (p ... q) -> String

showList :: [p ... q] -> ShowS

type PP (p ... q :: Type) x

Defined in Predicate.Data.Enum

type PP (p ... q :: Type) x

data EnumFromTo p q

similar to enumFromTo

>>> pz @(EnumFromTo 'GT 'LT) ()
Val []

>>> pz @(EnumFromTo Pred Succ) (SG.Max 10)
Val [Max {getMax = 9},Max {getMax = 10},Max {getMax = 11}]

>>> pz @(EnumFromTo 1 20 >> Map '(Id, (If (Id `Mod` 3 == 0) "Fizz" "" <> If (Id `Mod` 5 == 0) "Buzz" ""))) 123
Val [(1,""),(2,""),(3,"Fizz"),(4,""),(5,"Buzz"),(6,"Fizz"),(7,""),(8,""),(9,"Fizz"),(10,"Buzz"),(11,""),(12,"Fizz"),(13,""),(14,""),(15,"FizzBuzz"),(16,""),(17,""),(18,"Fizz"),(19,""),(20,"Buzz")]

>>> pl @(EnumFromTo (Pure SG.Min 9) (Pure _ 13)) ()
Present [Min {getMin = 9},Min {getMin = 10},Min {getMin = 11},Min {getMin = 12},Min {getMin = 13}] (Min {getMin = 9} ... Min {getMin = 13})
Val [Min {getMin = 9},Min {getMin = 10},Min {getMin = 11},Min {getMin = 12},Min {getMin = 13}]

>>> pl @(EnumFromTo (Wrap (SG.Min _) 9) (Wrap _ 13)) ()
Present [Min {getMin = 9},Min {getMin = 10},Min {getMin = 11},Min {getMin = 12},Min {getMin = 13}] (Min {getMin = 9} ... Min {getMin = 13})
Val [Min {getMin = 9},Min {getMin = 10},Min {getMin = 11},Min {getMin = 12},Min {getMin = 13}]

Instances

(P p x, P q x, PP p x ~ a, Show a, PP q x ~ a, Enum a) => P (EnumFromTo p q :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (EnumFromTo p q) x

Methods

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

Show (EnumFromTo p q)

Defined in Predicate.Data.Enum

Methods

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

show :: EnumFromTo p q -> String

showList :: [EnumFromTo p q] -> ShowS

type PP (EnumFromTo p q :: Type) x

Defined in Predicate.Data.Enum

type PP (EnumFromTo p q :: Type) x = [PP p x]

data EnumFromThenTo p q r

similar to enumFromThenTo

>>> pz @(EnumFromThenTo (10 >> ToEnum Day) (20 >> ToEnum Day) (70 >> ToEnum Day)) ()
Val [1858-11-27,1858-12-07,1858-12-17,1858-12-27,1859-01-06,1859-01-16,1859-01-26]

>>> pz @(EnumFromThenTo (ReadP Day "2020-01-12") (ReadP Day "2020-02-12") (ReadP Day "2020-08-12")) ()
Val [2020-01-12,2020-02-12,2020-03-14,2020-04-14,2020-05-15,2020-06-15,2020-07-16]

Instances

(P p x, P q x, P r x, PP p x ~ a, Show a, PP q x ~ a, PP r x ~ a, Enum a) => P (EnumFromThenTo p q r :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (EnumFromThenTo p q r) x

Methods

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

Show (EnumFromThenTo p q r)

Defined in Predicate.Data.Enum

Methods

showsPrec :: Int -> EnumFromThenTo p q r -> ShowS

show :: EnumFromThenTo p q r -> String

showList :: [EnumFromThenTo p q r] -> ShowS

type PP (EnumFromThenTo p q r :: Type) x

Defined in Predicate.Data.Enum

type PP (EnumFromThenTo p q r :: Type) x = [PP p x]

data FromEnum

fromEnum function

>>> pz @FromEnum 'x'
Val 120

Instances

Show FromEnum

Defined in Predicate.Data.Enum

Methods

showsPrec :: Int -> FromEnum -> ShowS

show :: FromEnum -> String

showList :: [FromEnum] -> ShowS

(Show x, Enum x) => P FromEnum x

Defined in Predicate.Data.Enum

Associated Types

type PP FromEnum x

Methods

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

type PP FromEnum x

Defined in Predicate.Data.Enum

type PP FromEnum x = Int

data FromEnum' p

fromEnum function

>>> pz @(FromEnum' Id) 'x'
Val 120

>>> pl @(FromEnum' ("aa" ==! Id) >> Same 1) "aaaa"
False ((>>) False | {0 == 1})
Val False

>>> pl @(FromEnum' ("aa" ==! Id) >> ToEnum OrderingP) "aaaa"
Present CGt ((>>) CGt | {ToEnum CGt | 0})
Val CGt

>>> pl @(Map (FromEnum' Id) >> Map (ToEnum Char)) "abcd"
Present "abcd" ((>>) "abcd" | {Map "abcd" | [97,98,99,100]})
Val "abcd"

Instances

(Show a, Enum a, PP p x ~ a, P p x) => P (FromEnum' p :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (FromEnum' p) x

Methods

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

Show (FromEnum' p)

Defined in Predicate.Data.Enum

Methods

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

show :: FromEnum' p -> String

showList :: [FromEnum' p] -> ShowS

type PP (FromEnum' p :: Type) x

Defined in Predicate.Data.Enum

type PP (FromEnum' p :: Type) x = Int

data Universe (t :: Type)

get universe of an enum of type t

>>> pz @(Universe Ordering) ()
Val [LT,EQ,GT]

Instances

Show (Universe t)

Defined in Predicate.Data.Enum

Methods

showsPrec :: Int -> Universe t -> ShowS

show :: Universe t -> String

showList :: [Universe t] -> ShowS

P (UniverseT t) x => P (Universe t :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (Universe t) x

Methods

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

type PP (Universe t :: Type) x

Defined in Predicate.Data.Enum

type PP (Universe t :: Type) x

data Universe' p

universe of enum using the type pointed to by p

>>> pl @(Universe' Id) LT
Present [LT,EQ,GT] (Universe [LT .. GT])
Val [LT,EQ,GT]

Instances

(PP p x ~ a, Show a, Enum a, Bounded a) => P (Universe' p :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (Universe' p) x

Methods

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

Show (Universe' p)

Defined in Predicate.Data.Enum

Methods

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

show :: Universe' p -> String

showList :: [Universe' p] -> ShowS

type PP (Universe' p :: Type) x

Defined in Predicate.Data.Enum

type PP (Universe' p :: Type) x = [PP p x]

bounded enums

data SuccB p q

bounded succ function

>>> pz @(SuccB 'LT Id) GT
Val LT

>>> pz @(SuccB 'LT 'GT) ()
Val LT

>>> pz @(SuccB 'GT 'LT) ()
Val EQ

>>> pl @(SuccB 'LT Id) GT
Present LT (SuccB out of range)
Val LT

Instances

(PP q x ~ a, P q x, P p (Proxy a), PP p (Proxy a) ~ a, Show a, Eq a, Bounded a, Enum a) => P (SuccB p q :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (SuccB p q) x

Methods

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

Show (SuccB p q)

Defined in Predicate.Data.Enum

Methods

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

show :: SuccB p q -> String

showList :: [SuccB p q] -> ShowS

type PP (SuccB p q :: Type) x

Defined in Predicate.Data.Enum

type PP (SuccB p q :: Type) x = PP q x

data SuccB' q

bounded succ function

>>> pz @(SuccB' Id) GT
Fail "Succ bounded"

>>> pz @(SuccB' Id) (13 :: Int)
Val 14

>>> pz @(SuccB' Id) LT
Val EQ

Instances

P (SuccBT' q) x => P (SuccB' q :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (SuccB' q) x

Methods

eval :: MonadEval m => proxy (SuccB' q) -> POpts -> x -> m (TT (PP (SuccB' q) x))

Show (SuccB' q)

Defined in Predicate.Data.Enum

Methods

showsPrec :: Int -> SuccB' q -> ShowS

show :: SuccB' q -> String

showList :: [SuccB' q] -> ShowS

type PP (SuccB' q :: Type) x

Defined in Predicate.Data.Enum

type PP (SuccB' q :: Type) x

data PredB p q

bounded pred function

>>> pl @(PredB 'GT Id) LT
Present GT (PredB out of range)
Val GT

>>> pl @(PredB 'LT Id) GT
Present EQ (PredB EQ | GT)
Val EQ

Instances

(PP q x ~ a, P q x, P p (Proxy a), PP p (Proxy a) ~ a, Show a, Eq a, Bounded a, Enum a) => P (PredB p q :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (PredB p q) x

Methods

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

Show (PredB p q)

Defined in Predicate.Data.Enum

Methods

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

show :: PredB p q -> String

showList :: [PredB p q] -> ShowS

type PP (PredB p q :: Type) x

Defined in Predicate.Data.Enum

type PP (PredB p q :: Type) x = PP q x

data PredB' q

bounded pred function

>>> pz @(PredB' Id) (13 :: Int)
Val 12

>>> pz @(PredB' Id) LT
Fail "Pred bounded"

>>> pl @(PredB' Id) GT
Present EQ (PredB EQ | GT)
Val EQ

>>> pl @(PredB' Id) LT
Error Pred bounded (PredB out of range)
Fail "Pred bounded"

Instances

P (PredBT' q) x => P (PredB' q :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (PredB' q) x

Methods

eval :: MonadEval m => proxy (PredB' q) -> POpts -> x -> m (TT (PP (PredB' q) x))

Show (PredB' q)

Defined in Predicate.Data.Enum

Methods

showsPrec :: Int -> PredB' q -> ShowS

show :: PredB' q -> String

showList :: [PredB' q] -> ShowS

type PP (PredB' q :: Type) x

Defined in Predicate.Data.Enum

type PP (PredB' q :: Type) x

data ToEnumBDef (t :: Type) def

bounded toEnum function

>>> pz @(ToEnumBDef Ordering LT) 2
Val GT

>>> pz @(ToEnumBDef Ordering LT) 6
Val LT

>>> pl @(ToEnumBDef Ordering 'LT) 123
Present LT (ToEnumBDef out of range)
Val LT

>>> pl @(ToEnumBDef Ordering 'GT) 1
Present EQ (ToEnumBDef EQ | 1)
Val EQ

Instances

P (ToEnumBDefT t def) x => P (ToEnumBDef t def :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (ToEnumBDef t def) x

Methods

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

Show (ToEnumBDef t def)

Defined in Predicate.Data.Enum

Methods

showsPrec :: Int -> ToEnumBDef t def -> ShowS

show :: ToEnumBDef t def -> String

showList :: [ToEnumBDef t def] -> ShowS

type PP (ToEnumBDef t def :: Type) x

Defined in Predicate.Data.Enum

type PP (ToEnumBDef t def :: Type) x

data ToEnumBDef' t def p

bounded toEnum function where t refers to location of the type and p the location of the input

Instances

(P def (Proxy (PP t a)), PP def (Proxy (PP t a)) ~ PP t a, Show (PP t a), Show a, Bounded (PP t a), Enum (PP t a), Integral (PP p a), P p a) => P (ToEnumBDef' t def p :: Type) a

Defined in Predicate.Data.Enum

Associated Types

type PP (ToEnumBDef' t def p) a

Methods

eval :: MonadEval m => proxy (ToEnumBDef' t def p) -> POpts -> a -> m (TT (PP (ToEnumBDef' t def p) a))

Show (ToEnumBDef' t def p)

Defined in Predicate.Data.Enum

Methods

showsPrec :: Int -> ToEnumBDef' t def p -> ShowS

show :: ToEnumBDef' t def p -> String

showList :: [ToEnumBDef' t def p] -> ShowS

type PP (ToEnumBDef' t def p :: Type) a

Defined in Predicate.Data.Enum

type PP (ToEnumBDef' t def p :: Type) a = PP t a

data ToEnumBFail (t :: Type)

bounded toEnum function

>>> pz @(ToEnumBFail Ordering) 6
Fail "ToEnum bounded"

>>> pl @(ToEnumBFail Ordering) 1
Present EQ (ToEnumBDef EQ | 1)
Val EQ

>>> pl @(ToEnumBFail Ordering) 44
Error ToEnum bounded (ToEnumBDef out of range)
Fail "ToEnum bounded"

Instances

Show (ToEnumBFail t)

Defined in Predicate.Data.Enum

Methods

showsPrec :: Int -> ToEnumBFail t -> ShowS

show :: ToEnumBFail t -> String

showList :: [ToEnumBFail t] -> ShowS

P (ToEnumBFailT t) x => P (ToEnumBFail t :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (ToEnumBFail t) x

Methods

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

type PP (ToEnumBFail t :: Type) x

Defined in Predicate.Data.Enum

type PP (ToEnumBFail t :: Type) x

unsafe enums

data Succ

unbounded succ function

>>> pz @Succ 13
Val 14

>>> pz @Succ LT
Val EQ

>>> pz @Succ GT
Fail "Succ IO e=Prelude.Enum.Ordering.succ: bad argument"

>>> pl @Succ 10
Present 11 (Succ 11 | 10)
Val 11

>>> pl @Succ True -- captures the exception
Error Succ IO e=Prelude.Enum.Bool.succ: bad argument (True)
Fail "Succ IO e=Prelude.Enum.Bool.succ: bad argument"

>>> pz @Succ (Proxy @44)
Fail "Succ IO e=Proxy.succ"

Instances

Show Succ

Defined in Predicate.Data.Enum

Methods

showsPrec :: Int -> Succ -> ShowS

show :: Succ -> String

showList :: [Succ] -> ShowS

(Show x, Enum x) => P Succ x

Defined in Predicate.Data.Enum

Associated Types

type PP Succ x

Methods

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

type PP Succ x

Defined in Predicate.Data.Enum

type PP Succ x = x

data SuccN n p

SuccN n p (unsafe) increments an enum p by the given integral n

>>> pz @(ReadP Day Id >> Id ... SuccN 5 Id) "2020-07-27"
Val [2020-07-27,2020-07-28,2020-07-29,2020-07-30,2020-07-31,2020-08-01]

>>> pz @(ReadP Day Id >> SuccN (Negate 5) Id) "2020-07-27"
Val 2020-07-22

>>> pl @(SuccN 3 'LT) ()
Error SuccN IO e=Prelude.Enum.Ordering.toEnum: bad argument (SuccN 3 LT)
Fail "SuccN IO e=Prelude.Enum.Ordering.toEnum: bad argument"

>>> pz @(SuccN 2 'LT) ()
Val GT

>>> pz @(SuccN (Negate 3) (C "x")) ()
Val 'u'

Instances

(Show a, Enum a, Integral (PP n x), P n x, PP p x ~ a, P p x) => P (SuccN n p :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (SuccN n p) x

Methods

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

Show (SuccN n p)

Defined in Predicate.Data.Enum

Methods

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

show :: SuccN n p -> String

showList :: [SuccN n p] -> ShowS

type PP (SuccN n p :: Type) x

Defined in Predicate.Data.Enum

type PP (SuccN n p :: Type) x = PP p x

data Pred

unbounded pred function

>>> pz @Pred 13
Val 12

>>> pz @Pred LT
Fail "Pred IO e=Prelude.Enum.Ordering.pred: bad argument"

Instances

Show Pred

Defined in Predicate.Data.Enum

Methods

showsPrec :: Int -> Pred -> ShowS

show :: Pred -> String

showList :: [Pred] -> ShowS

(Show x, Enum x) => P Pred x

Defined in Predicate.Data.Enum

Associated Types

type PP Pred x

Methods

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

type PP Pred x

Defined in Predicate.Data.Enum

type PP Pred x = x

data ToEnum (t :: Type)

unsafe toEnum function

>>> pz @(ToEnum Char) 120
Val 'x'

>>> pl @(Map FromEnum >> Map (Id - 97 >> ToEnum Ordering)) "abcde"
Error ToEnum IO e=Prelude.Enum.Ordering.toEnum: bad argument(2) (Map(i=3, a=100) excnt=2)
Fail "ToEnum IO e=Prelude.Enum.Ordering.toEnum: bad argument(2)"

>>> pl @((ToEnum Day *** ToEnum Day) >> EnumFromTo Fst Snd) (0,5)
Present [1858-11-17,1858-11-18,1858-11-19,1858-11-20,1858-11-21,1858-11-22] ((>>) [1858-11-17,1858-11-18,1858-11-19,1858-11-20,1858-11-21,1858-11-22] | {1858-11-17 ... 1858-11-22})
Val [1858-11-17,1858-11-18,1858-11-19,1858-11-20,1858-11-21,1858-11-22]

>>> pz @(ToEnum (Proxy ())) 0
Val Proxy

>>> pz @(ToEnum (Proxy ())) 1
Fail "ToEnum IO e=Proxy.toEnum: 0 expected"

>>> pz @(ToEnum (Proxy "sss") >> Pop0 Id ()) 0
Val "sss"

Instances

Show (ToEnum t)

Defined in Predicate.Data.Enum

Methods

showsPrec :: Int -> ToEnum t -> ShowS

show :: ToEnum t -> String

showList :: [ToEnum t] -> ShowS

P (ToEnumT t) x => P (ToEnum t :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (ToEnum t) x

Methods

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

type PP (ToEnum t :: Type) x

Defined in Predicate.Data.Enum

type PP (ToEnum t :: Type) x

data ToEnum' t p

unsafe toEnum function that allows you to specify the target p and a pointer to a type t

Instances

(PP p x ~ a, P p x, Enum (PP t x), Show (PP t x), Integral a) => P (ToEnum' t p :: Type) x

Defined in Predicate.Data.Enum

Associated Types

type PP (ToEnum' t p) x

Methods

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

Show (ToEnum' t p)

Defined in Predicate.Data.Enum

Methods

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

show :: ToEnum' t p -> String

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

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

Defined in Predicate.Data.Enum

type PP (ToEnum' t p :: Type) x = PP t x