Copyright	(c) Grant Weyburne 2019
License	BSD-3
Maintainer	gbwey9@gmail.com
Safe Haskell	None
Language	Haskell2010

UtilP

Description

Synopsis

data TT a = TT {
- _tBool :: BoolT a
- _tStrings :: [String]
- _tForest :: Forest PE
}
data BoolT a where
- FailT :: String -> BoolT a
- FalseT :: BoolT Bool
- TrueT :: BoolT Bool
- PresentT :: a -> BoolT a
tBool :: Lens (TT a) (TT b) (BoolT a) (BoolT b)
tStrings :: Lens' (TT a) [String]
tForest :: Lens' (TT a) (Forest PE)
pStrings :: Lens' PE [String]
boolT2P :: Lens' (BoolT a) BoolP
data BoolP
- = FailP String
- | FalseP
- | TrueP
- | PresentP
data PE = PE {
- _pBool :: BoolP
- _pStrings :: [String]
}
pBool :: Lens' PE BoolP
mkNode :: POpts -> BoolT a -> [String] -> [Holder] -> TT a
mkNodeB :: POpts -> Bool -> [String] -> [Holder] -> TT Bool
partitionTTs :: [TT a] -> ([TT x], [TT a])
getTTLR :: TT a -> Either (TT x) (TT a)
partitionTTExtended :: (w, TT a) -> ([((w, TT x), String)], [(w, TT a)])
getValLRFromTT :: TT a -> Either String a
getValLR :: BoolT a -> Either String a
shortTT :: BoolT Bool -> Either String String
fromTT :: TT a -> Tree PE
data Holder = Holder {
- unHolder :: TT w
}
fromTTH :: Holder -> Tree PE
hh :: TT w -> Holder
getValueLR :: POpts -> String -> TT a -> [Holder] -> Either (TT x) a
getValueLRHide :: POpts -> String -> TT a -> [Holder] -> Either (TT x) a
getValueLRImpl :: Bool -> POpts -> String -> TT a -> [Holder] -> Either (TT x) a
newtype PColor = PColor {
- unPColor :: BoolP -> String -> String
}
data POpts = POpts {
- oWidth :: Maybe Int
- oDebug :: !Int
- oDisp :: Disp
- oHide :: !Int
- oColor :: !(String, PColor)
- oLite :: !Bool
}
data Disp
- = NormalDisp
- | Unicode
defOpts :: POpts
ol :: POpts
olc :: POpts
o0 :: POpts
o2 :: POpts
o2n :: POpts
o3 :: POpts
ou :: POpts
oun :: POpts
setw :: Int -> POpts -> POpts
setd :: Int -> POpts -> POpts
setu :: POpts -> POpts
setc :: (String, PColor) -> POpts -> POpts
setc0 :: POpts -> POpts
setc1 :: POpts -> POpts
setc2 :: POpts -> POpts
setc3 :: POpts -> POpts
setc4 :: POpts -> POpts
color0 :: (String, PColor)
color1 :: (String, PColor)
color2 :: (String, PColor)
color3 :: (String, PColor)
color4 :: (String, PColor)
fixBoolT :: TT Bool -> TT Bool
show01 :: (Show a1, Show a2) => POpts -> String -> a1 -> a2 -> String
lit01 :: Show a1 => POpts -> String -> a1 -> String -> String
show01' :: (Show a1, Show a2) => POpts -> String -> a1 -> String -> a2 -> String
lit01' :: Show a1 => POpts -> String -> a1 -> String -> String -> String
showLit0 :: POpts -> String -> String -> String
showLit1 :: POpts -> String -> String -> String
showLitImpl :: POpts -> Int -> String -> String -> String
show0 :: Show a => POpts -> String -> a -> String
show3 :: Show a => POpts -> String -> a -> String
show1 :: Show a => POpts -> String -> a -> String
showAImpl :: Show a => POpts -> Int -> String -> a -> String
data ROpt
- = Anchored
- | Auto_callout
- | Caseless
- | Dollar_endonly
- | Dotall
- | Dupnames
- | Extended
- | Extra
- | Firstline
- | Multiline
- | Newline_cr
- | Newline_crlf
- | Newline_lf
- | No_auto_capture
- | Ungreedy
- | Utf8
- | No_utf8_check
compileRegex :: forall rs a. GetROpts rs => POpts -> String -> String -> [Holder] -> Either (TT a) Regex
class GetROpts (os :: [ROpt]) where
- getROpts :: [PCREOption]
class GetROpt (o :: ROpt) where
- getROpt :: PCREOption
data RR
- = RR String
- | RR1 (String -> [String] -> String)
- | RR2 (String -> String)
- | RR3 ([String] -> String)
splitAndAlign :: Show x => POpts -> [String] -> [((Int, x), TT a)] -> Either (TT w) ([a], [((Int, x), TT a)])
formatList :: forall x z. Show x => POpts -> [((Int, x), z)] -> String
valsFromTTs :: [TT a] -> [a]
isTrue :: BoolT Bool -> Bool
_boolT :: Prism' (BoolT Bool) Bool
groupErrors :: [String] -> String
_FailT :: Prism' (BoolT a) String
_PresentT :: Prism' (BoolT a) a
_FalseT :: Prism' (BoolT Bool) ()
_TrueT :: Prism' (BoolT Bool) ()
imply :: Bool -> Bool -> Bool
evalBinStrict :: POpts -> String -> (Bool -> Bool -> Bool) -> TT Bool -> TT Bool -> TT Bool
type family BetweenT (a :: Nat) (b :: Nat) (v :: Nat) :: Constraint where ...
type NotZeroT v = FailIfT (v == 0) (Text "found zero value")
type family NullT (x :: Symbol) :: Bool where ...
type family FailIfT (b :: Bool) (msg :: ErrorMessage) :: Constraint where ...
type family AndT (b :: Bool) (b1 :: Bool) :: Bool where ...
type family OrT (b :: Bool) (b1 :: Bool) :: Bool where ...
type family NotT (b :: Bool) :: Bool where ...
nat :: forall n a. (KnownNat n, Num a) => a
symb :: forall s. KnownSymbol s => String
class GetNats as where
- getNats :: [Int]
class GetSymbs ns where
- getSymbs :: [String]
getLen :: forall xs. GetLen xs => Int
class GetLen (xs :: [k]) where
- getLenP :: Proxy (xs :: [k]) -> Int
showThese :: These a b -> String
class GetThese (th :: These x y) where
- getThese :: Proxy th -> (String, These w v -> Bool)
class GetOrdering (cmp :: Ordering) where
- getOrdering :: Ordering
class GetBool (a :: Bool) where
- getBool :: Bool
data N
- = S N
- | Z
type family ToN (n :: Nat) :: N where ...
type family FromN (n :: N) :: Nat where ...
class GetNatN (n :: N) where
- getNatN :: Int
getN :: Typeable t => Proxy (t :: N) -> Int
data OrderingP
- = Cgt
- | Cge
- | Ceq
- | Cle
- | Clt
- | Cne
class GetOrd (k :: OrderingP) where
- getOrd :: Ord a => (String, a -> a -> Bool)
toNodeString :: POpts -> PE -> String
nullSpace :: String -> String
showBoolP :: POpts -> BoolP -> String
displayMessages :: [String] -> String
colorMe :: POpts -> BoolP -> String -> String
prtTTIO :: POpts -> IO (TT a) -> IO ()
prtTT :: POpts -> Identity (TT a) -> IO ()
prtTT' :: MonadEval m => POpts -> m (TT a) -> IO ()
prtTree :: POpts -> Tree PE -> IO ()
prtImpl :: POpts -> Tree String -> IO ()
fixLite :: forall a. Show a => POpts -> a -> Tree PE -> String
fixPresentP :: Show a => POpts -> BoolP -> a -> String
prtTreePure :: POpts -> Tree PE -> String
showImpl :: POpts -> Tree String -> String
lite :: POpts -> POpts
unicode :: POpts -> POpts
horizontal :: POpts -> POpts
prettyRational :: Rational -> String
fixit :: ((Int, x), TT a) -> TT a
prefixMsg :: String -> TT a -> TT a
showNat :: forall n. KnownNat n => String
showT :: forall (t :: Type). Typeable t => String
showTProxy :: forall p. Typeable (Proxy p) => String
prettyOrd :: Ordering -> String
type family RepeatT (n :: Nat) (p :: k) :: [k] where ...
type family IntersperseT (s :: Symbol) (xs :: [Symbol]) :: Symbol where ...
type family LenT (xs :: [k]) :: Nat where ...
type NEmptyT k = ('[] :| '[] :: NonEmpty [k])
isPrime :: Integer -> Bool
type family TupleListT (n :: N) a where ...
class TupleListD (n :: N) a where
- tupleListD :: Bool -> [a] -> Either String (TupleListT n a)
class ReverseTupleC x where
- type ReverseTupleP x
- reverseTupleC :: x -> ReverseTupleP x
type family ArrT (as :: Type) :: Type where ...
type family TupleLenT (t :: Type) :: Nat where ...
type family (p :: k -> k1) %% (q :: k) :: k1 where ...
type family (p :: k) %& (q :: k -> k1) :: k1 where ...
type family FlipT (d :: k1 -> k -> k2) (p :: k) (q :: k1) :: k2 where ...
type family IfT (b :: Bool) (t :: k) (f :: k) :: k where ...
type family SumT (ns :: [Nat]) :: Nat where ...
type family MapT (f :: k -> k1) (xs :: [k]) :: [k1] where ...
type family ConsT s where ...
class Monad m => MonadEval m where
- runIO :: IO a -> m (Maybe a)
- catchit :: Exception e => a -> m (Either String a)
- catchitNF :: (Exception e, NFData a) => a -> m (Either String a)
- liftEval :: m a -> IO a
removeAnsiForDocTest :: Show a => Either String a -> IO ()

Documentation

data TT a Source #

describes the evaluation tree for predicates

Constructors

TT	the child nodes
Fields _tBool :: BoolT a the value at this root node _tStrings :: [String] detailed information eg input and output and text _tForest :: Forest PE

Instances

Foldable TT Source #
Instance details Defined in UtilP Methods fold :: Monoid m => TT m -> m # foldMap :: Monoid m => (a -> m) -> TT a -> m # foldr :: (a -> b -> b) -> b -> TT a -> b # foldr' :: (a -> b -> b) -> b -> TT a -> b # foldl :: (b -> a -> b) -> b -> TT a -> b # foldl' :: (b -> a -> b) -> b -> TT a -> b # foldr1 :: (a -> a -> a) -> TT a -> a # foldl1 :: (a -> a -> a) -> TT a -> a # toList :: TT a -> [a] # null :: TT a -> Bool # length :: TT a -> Int # elem :: Eq a => a -> TT a -> Bool # maximum :: Ord a => TT a -> a # minimum :: Ord a => TT a -> a # sum :: Num a => TT a -> a # product :: Num a => TT a -> a #
Show a => Show (TT a) Source #
Instance details Defined in UtilP Methods showsPrec :: Int -> TT a -> ShowS # show :: TT a -> String # showList :: [TT a] -> ShowS #

data BoolT a where Source #

contains the typed result from evaluating the expression tree to this point

Constructors

FailT
Fields :: String -> BoolT a failure with string
FalseT
Fields :: BoolT Bool false predicate
TrueT
Fields :: BoolT Bool true predicate
PresentT
Fields :: a -> BoolT a non predicate value

Instances

Foldable BoolT Source #
Instance details Defined in UtilP Methods fold :: Monoid m => BoolT m -> m # foldMap :: Monoid m => (a -> m) -> BoolT a -> m # foldr :: (a -> b -> b) -> b -> BoolT a -> b # foldr' :: (a -> b -> b) -> b -> BoolT a -> b # foldl :: (b -> a -> b) -> b -> BoolT a -> b # foldl' :: (b -> a -> b) -> b -> BoolT a -> b # foldr1 :: (a -> a -> a) -> BoolT a -> a # foldl1 :: (a -> a -> a) -> BoolT a -> a # toList :: BoolT a -> [a] # null :: BoolT a -> Bool # length :: BoolT a -> Int # elem :: Eq a => a -> BoolT a -> Bool # maximum :: Ord a => BoolT a -> a # minimum :: Ord a => BoolT a -> a # sum :: Num a => BoolT a -> a # product :: Num a => BoolT a -> a #
Eq a => Eq (BoolT a) Source #
Instance details Defined in UtilP Methods (==) :: BoolT a -> BoolT a -> Bool # (/=) :: BoolT a -> BoolT a -> Bool #
Show a => Show (BoolT a) Source #
Instance details Defined in UtilP Methods showsPrec :: Int -> BoolT a -> ShowS # show :: BoolT a -> String # showList :: [BoolT a] -> ShowS #
Semigroup a => Semigroup (BoolT a) Source #
Instance details Defined in UtilP Methods (<>) :: BoolT a -> BoolT a -> BoolT a # sconcat :: NonEmpty (BoolT a) -> BoolT a # stimes :: Integral b => b -> BoolT a -> BoolT a #
Monoid a => Monoid (BoolT a) Source #
Instance details Defined in UtilP Methods mempty :: BoolT a # mappend :: BoolT a -> BoolT a -> BoolT a # mconcat :: [BoolT a] -> BoolT a #

tBool :: Lens (TT a) (TT b) (BoolT a) (BoolT b) Source #

tStrings :: Lens' (TT a) [String] Source #

tForest :: Lens' (TT a) (Forest PE) Source #

pStrings :: Lens' PE [String] Source #

boolT2P :: Lens' (BoolT a) BoolP Source #

a lens from typed BoolT to the untyped BoolP

data BoolP Source #

contains the untyped result from evaluating the expression tree to this point

Constructors

FailP String
FalseP
TrueP
PresentP

Instances

Eq BoolP Source #
Instance details Defined in UtilP Methods (==) :: BoolP -> BoolP -> Bool # (/=) :: BoolP -> BoolP -> Bool #
Show BoolP Source #
Instance details Defined in UtilP Methods showsPrec :: Int -> BoolP -> ShowS # show :: BoolP -> String # showList :: [BoolP] -> ShowS #

data PE Source #

Constructors

PE
Fields _pBool :: BoolP holds the result of running the predicate _pStrings :: [String] optional strings to include in the results

Instances

Show PE Source #
Instance details Defined in UtilP Methods showsPrec :: Int -> PE -> ShowS # show :: PE -> String # showList :: [PE] -> ShowS #

pBool :: Lens' PE BoolP Source #

mkNode :: POpts -> BoolT a -> [String] -> [Holder] -> TT a Source #

creates a Node for the evaluation tree

mkNodeB :: POpts -> Bool -> [String] -> [Holder] -> TT Bool Source #

creates a Boolean node for a predicate type

partitionTTs :: [TT a] -> ([TT x], [TT a]) Source #

partition a tree into failures and non failures

getTTLR :: TT a -> Either (TT x) (TT a) Source #

partitionTTExtended :: (w, TT a) -> ([((w, TT x), String)], [(w, TT a)]) Source #

getValLRFromTT :: TT a -> Either String a Source #

getValLR :: BoolT a -> Either String a Source #

get the value from BoolT or fail

shortTT :: BoolT Bool -> Either String String Source #

fromTT :: TT a -> Tree PE Source #

converts a typed tree to an untyped on for display

data Holder Source #

a monomorphic container of trees

Constructors

Holder
Fields unHolder :: TT w

fromTTH :: Holder -> Tree PE Source #

converts a typed tree into an untyped one

hh :: TT w -> Holder Source #

convenience method to wrap a typed tree

getValueLR :: POpts -> String -> TT a -> [Holder] -> Either (TT x) a Source #

see getValueLRImpl : add more detail to the tree if there are errors

getValueLRHide :: POpts -> String -> TT a -> [Holder] -> Either (TT x) a Source #

see getValueLRImpl : add less detail to the tree if there are errors

getValueLRImpl :: Bool -> POpts -> String -> TT a -> [Holder] -> Either (TT x) a Source #

a helper method to add extra context on failure to the tree or extract the value at the root of the tree

newtype PColor Source #

the color palette for displaying the expression tree

Constructors

PColor
Fields unPColor :: BoolP -> String -> String

data POpts Source #

customizable options

Constructors

POpts
Fields oWidth :: Maybe Int length of data to display for `showLitImpl` oDebug :: !Int debug level oDisp :: Disp display the tree using the normal tree or unicode oHide :: !Int hides one layer of a tree oColor :: !(String, PColor) color palette used oLite :: !Bool skip the tree entirely and display the end result

Instances

Show POpts Source #
Instance details Defined in UtilP Methods showsPrec :: Int -> POpts -> ShowS # show :: POpts -> String # showList :: [POpts] -> ShowS #

data Disp Source #

display format for the tree

Constructors

NormalDisp	draw horizontal tree
Unicode	use unicode

Instances

Eq Disp Source #
Instance details Defined in UtilP Methods (==) :: Disp -> Disp -> Bool # (/=) :: Disp -> Disp -> Bool #
Show Disp Source #
Instance details Defined in UtilP Methods showsPrec :: Int -> Disp -> ShowS # show :: Disp -> String # showList :: [Disp] -> ShowS #

defOpts :: POpts Source #

ol :: POpts Source #

skip colors and just return the summary

olc :: POpts Source #

skip the detail and just return the summary but keep the colors

o0 :: POpts Source #

displays the detailed evaluation tree without colors.

o2 :: POpts Source #

displays the detailed evaluation tree using colors.

o2n :: POpts Source #

same as o2 but for narrower display width

o3 :: POpts Source #

same as o2 but for larger display width

ou :: POpts Source #

displays the detailed evaluation tree using unicode and colors. (o2 works better on Windows)

oun :: POpts Source #

same as ou but for narrower display width

setw :: Int -> POpts -> POpts Source #

helper method to limit the width of the tree

setd :: Int -> POpts -> POpts Source #

helper method to set the debug level

setu :: POpts -> POpts Source #

set display to unicode and colors

setc :: (String, PColor) -> POpts -> POpts Source #

set a color palette

setc0 :: POpts -> POpts Source #

setc1 :: POpts -> POpts Source #

setc2 :: POpts -> POpts Source #

setc3 :: POpts -> POpts Source #

setc4 :: POpts -> POpts Source #

color0 :: (String, PColor) Source #

no colors are displayed

color palettes