Primus.LRHist

tracks one or more successes and optionally a failure

prefer the smart constructors to enforce correctness or use the apply methods

datatype

data LRHist as e a where

like Either but keeps track of history of all successes if there is a failure it wraps the previous successes and stops adding data to LRHist "e" the error type "as" is the typelevel list in reverse order that tracks all previous "a"s "a" is the latest success type

Constructors

LhSkip :: LRHist as e a' -> LRHist (a' ': as) e a

wraps an existing error

Lh :: e -> LRHist as e a' -> LRHist (a' ': as) e a

wraps previous nested successes with an error

Rhi :: a -> LRHist '[] e a

initial success value

Rh :: a -> LRHist as e a' -> LRHist (a' ': as) e a

subsequent success

Instances

Bifunctor (LRHist as)

Defined in Primus.LRHist

Methods

bimap :: (a -> b) -> (c -> d) -> LRHist as a c -> LRHist as b d

first :: (a -> b) -> LRHist as a c -> LRHist as b c

second :: (b -> c) -> LRHist as a b -> LRHist as a c

Bitraversable (LRHist as)

Defined in Primus.LRHist

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> LRHist as a b -> f (LRHist as c d)

Bifoldable (LRHist as)

Defined in Primus.LRHist

Methods

bifold :: Monoid m => LRHist as m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> LRHist as a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> LRHist as a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> LRHist as a b -> c

Functor (LRHist as e)

Defined in Primus.LRHist

Methods

fmap :: (a -> b) -> LRHist as e a -> LRHist as e b

(<$) :: a -> LRHist as e b -> LRHist as e a

Foldable (LRHist as e)

Defined in Primus.LRHist

Methods

fold :: Monoid m => LRHist as e m -> m

foldMap :: Monoid m => (a -> m) -> LRHist as e a -> m

foldMap' :: Monoid m => (a -> m) -> LRHist as e a -> m

foldr :: (a -> b -> b) -> b -> LRHist as e a -> b

foldr' :: (a -> b -> b) -> b -> LRHist as e a -> b

foldl :: (b -> a -> b) -> b -> LRHist as e a -> b

foldl' :: (b -> a -> b) -> b -> LRHist as e a -> b

foldr1 :: (a -> a -> a) -> LRHist as e a -> a

foldl1 :: (a -> a -> a) -> LRHist as e a -> a

toList :: LRHist as e a -> [a]

null :: LRHist as e a -> Bool

length :: LRHist as e a -> Int

elem :: Eq a => a -> LRHist as e a -> Bool

maximum :: Ord a => LRHist as e a -> a

minimum :: Ord a => LRHist as e a -> a

sum :: Num a => LRHist as e a -> a

product :: Num a => LRHist as e a -> a

Traversable (LRHist as e)

Defined in Primus.LRHist

Methods

traverse :: Applicative f => (a -> f b) -> LRHist as e a -> f (LRHist as e b)

sequenceA :: Applicative f => LRHist as e (f a) -> f (LRHist as e a)

mapM :: Monad m => (a -> m b) -> LRHist as e a -> m (LRHist as e b)

sequence :: Monad m => LRHist as e (m a) -> m (LRHist as e a)

(ApplyConstraints '[Eq] as, Eq e, Eq a) => Eq (LRHist as e a)

Defined in Primus.LRHist

Methods

(==) :: LRHist as e a -> LRHist as e a -> Bool

(/=) :: LRHist as e a -> LRHist as e a -> Bool

(ApplyConstraints '[Eq, Ord] as, Eq e, Ord e, Ord a) => Ord (LRHist as e a)

Defined in Primus.LRHist

Methods

compare :: LRHist as e a -> LRHist as e a -> Ordering

(<) :: LRHist as e a -> LRHist as e a -> Bool

(<=) :: LRHist as e a -> LRHist as e a -> Bool

(>) :: LRHist as e a -> LRHist as e a -> Bool

(>=) :: LRHist as e a -> LRHist as e a -> Bool

max :: LRHist as e a -> LRHist as e a -> LRHist as e a

min :: LRHist as e a -> LRHist as e a -> LRHist as e a

(Read a, Read e, Read a', Read (LRHist as e a'), ApplyConstraints '[Read] as) => Read (LRHist (a' ': as) e a)

successor case for LRHist Read instance (a' ': as) so supports Rh, Lh, LhSkip constructors

Defined in Primus.LRHist

Methods

readsPrec :: Int -> ReadS (LRHist (a' ': as) e a)

readList :: ReadS [LRHist (a' ': as) e a]

readPrec :: ReadPrec (LRHist (a' ': as) e a)

readListPrec :: ReadPrec [LRHist (a' ': as) e a]

(Read a, Read e) => Read (LRHist ('[] :: [Type]) e a)

base case for LRHist Read instance for '[] so only supports Rhi constructor

Defined in Primus.LRHist

Methods

readsPrec :: Int -> ReadS (LRHist '[] e a)

readList :: ReadS [LRHist '[] e a]

readPrec :: ReadPrec (LRHist '[] e a)

readListPrec :: ReadPrec [LRHist '[] e a]

(Show a, Show e, ApplyConstraints '[Show] as) => Show (LRHist as e a)

Defined in Primus.LRHist

Methods

showsPrec :: Int -> LRHist as e a -> ShowS

show :: LRHist as e a -> String

showList :: [LRHist as e a] -> ShowS

(Semigroup a, Semigroup e, ApplyConstraints '[Semigroup] as) => Semigroup (LRHist as e a)

Defined in Primus.LRHist

Methods

(<>) :: LRHist as e a -> LRHist as e a -> LRHist as e a

sconcat :: NonEmpty (LRHist as e a) -> LRHist as e a

stimes :: Integral b => b -> LRHist as e a -> LRHist as e a

(Monoid a, Monoid e, Monoid a', ApplyConstraints '[Semigroup, Monoid] as, Monoid (LRHist as e a')) => Monoid (LRHist (a' ': as) e a)

Defined in Primus.LRHist

Methods

mempty :: LRHist (a' ': as) e a

mappend :: LRHist (a' ': as) e a -> LRHist (a' ': as) e a -> LRHist (a' ': as) e a

mconcat :: [LRHist (a' ': as) e a] -> LRHist (a' ': as) e a

(Semigroup e, Monoid a) => Monoid (LRHist ('[] :: [Type]) e a)

Defined in Primus.LRHist

Methods

mempty :: LRHist '[] e a

mappend :: LRHist '[] e a -> LRHist '[] e a -> LRHist '[] e a

mconcat :: [LRHist '[] e a] -> LRHist '[] e a

smart constructors

rhi :: forall e a. a -> (Proxy 'True, LRHist '[] e a)

smart constructor for Rhi

rh :: forall e a a' as proxy. a -> (proxy 'True, LRHist as e a') -> (proxy 'True, LRHist (a' ': as) e a)

smart constructor for Rh

lh :: forall a e a' as proxy. e -> (proxy 'True, LRHist as e a') -> (Proxy 'False, LRHist (a' ': as) e a)

smart constructor for Lh

lhskip :: forall a e a' as proxy. (proxy 'False, LRHist as e a') -> (proxy 'False, LRHist (a' ': as) e a)

smart constructor for LhSkip

constructors with better type application order

rhi' :: forall e a. a -> LRHist '[] e a

constructor for Rhi with more convenient type application order

rh' :: forall e a a' as. a -> LRHist as e a' -> LRHist (a' ': as) e a

constructor for Rh with more convenient type application order

lh' :: forall a e a' as. e -> LRHist as e a' -> LRHist (a' ': as) e a

constructor for Lh with more convenient type application order

lhskip' :: forall a e a' as. LRHist as e a' -> LRHist (a' ': as) e a

constructor for LhSkip with more convenient type application order

converters

lhToEitherI :: forall e a as. RHistC as => LRHist as e a -> Either e (RHistT a as)

returns an inductive tuple on success and Either for failure

lhToEither :: forall e a as. LRHist as e a -> Either e a

convert LRHist to an Either

lhToEitherTuples :: forall e a as tp. (ITupleC tp, RHistC as, ToITupleT tp ~ RHistT a as) => LRHist as e a -> Either e tp

returns flattened n-tuple with all the history of successes on success and Either for failure

function application

lhBool :: forall e a a' as. (a ~ a', Monoid e) => (a' -> Bool) -> LRHist as e a' -> LRHist (a' ': as) e a

uses a boolean predicate to determine success or failure

lhMaybe :: forall e a a' as. Monoid e => (a' -> Maybe a) -> LRHist as e a' -> LRHist (a' ': as) e a

uses a maybe function to determine success or failure and also allow change of type "a"

lhMaybe' :: forall e a a' as. Monoid e => (a' -> Bool) -> (a' -> a) -> LRHist as e a' -> LRHist (a' ': as) e a

similar to lhMaybe leveraging boolMaybe

lhEither :: forall e a a' as. (a' -> Either e a) -> LRHist as e a' -> LRHist (a' ': as) e a

uses an either function to determine success or failure and also allow change of type "a"

lhEither' :: forall e a a' as. (a' -> Bool) -> (a' -> e) -> (a' -> a) -> LRHist as e a' -> LRHist (a' ': as) e a

similar to lhEither leveraging boolEither

appLR :: forall e a a' as x. ApTheseF e a' x a => (a' -> x) -> LRHist as e a' -> LRHist (a' ': as) e a

apply a function to LRHist using ApTheseF

appLRS :: forall e a' x a as z. ApTheseF e a' x a => (z -> a' -> (z, x)) -> z -> LRHist as e a' -> (z, LRHist (a' ': as) e a)

similar to appLR with state

appLRB :: forall e a a' as. (a' -> Bool) -> (a' -> e) -> (a' -> a) -> LRHist as e a' -> LRHist (a' ': as) e a

apply a function to a LRHist via boolEither

traversals

traverseLRHistB :: forall e a t a' as. Functor t => (a' -> Bool) -> (a' -> e) -> (a' -> a) -> t (LRHist as e a') -> t (LRHist (a' ': as) e a)

convenience method to apply appLRB to a container of LRHist

traverseLRHist :: forall e a t a' as z. Traversable t => (z -> a' -> (z, Either e a)) -> z -> t (LRHist as e a') -> (z, t (LRHist (a' ': as) e a))

convenience method to apply appLR to a container of LRHist with state

miscellaneous

eitherToLH :: Either e a -> LRHist '[()] e a

initialise LRHist with an Either by wrapping a unit

maybeToLH :: Monoid e => Maybe a -> LRHist '[()] e a

initialise LRHist with an Maybe by wrapping a unit

validateLRHist :: forall e a as. LRHist as e a -> Either String ()

validate that the composition of constructors for LRHist is valid