Primus.AsMaybe

AsMaybe

class AsMaybe x b | x -> b where

converts to a Maybe for failure types

Methods

toMaybe :: x -> Maybe b

Instances

b1 ~ [b] => AsMaybe [b] b1

Defined in Primus.AsMaybe

Methods

toMaybe :: [b] -> Maybe b1

b ~ b1 => AsMaybe (Maybe b) b1

Defined in Primus.AsMaybe

Methods

toMaybe :: Maybe b -> Maybe b1

AsMaybe x z => AsMaybe (Identity x) z

Defined in Primus.AsMaybe

Methods

toMaybe :: Identity x -> Maybe z

b ~ b1 => AsMaybe (Either e b) b1

Defined in Primus.AsMaybe

Methods

toMaybe :: Either e b -> Maybe b1

(b ~ (b1, b2), AsMaybe x b1, AsMaybe y b2) => AsMaybe (x, y) b

Defined in Primus.AsMaybe

Methods

toMaybe :: (x, y) -> Maybe b

(z ~ Arg b1 y, AsMaybe x b1) => AsMaybe (Arg x y) z

Defined in Primus.AsMaybe

Methods

toMaybe :: Arg x y -> Maybe z

b ~ b1 => AsMaybe (These e b) b1

Defined in Primus.AsMaybe

Methods

toMaybe :: These e b -> Maybe b1

(b ~ (b1, b2, b3), AsMaybe x b1, AsMaybe y b2, AsMaybe z b3) => AsMaybe (x, y, z) b

Defined in Primus.AsMaybe

Methods

toMaybe :: (x, y, z) -> Maybe b

iterateT1 :: AsMaybe x a => (a -> x) -> a -> NonEmpty a

similar to iterate but terminate using AsMaybe

unfoldrT :: AsMaybe t t => (t -> (a, t)) -> t -> [a]

like unfoldr but terminate using AsMaybe

>>> unfoldrT (splitAt 2) [1..8]
[[1,2],[3,4],[5,6],[7,8]]

vs

>>> unfoldr (s -> if null s then Nothing else Just (splitAt 2 s)) [1..8]
[[1,2],[3,4],[5,6],[7,8]]

pairsT :: (x -> (a, x)) -> (y -> (b, y)) -> (x, y) -> ((a, b), (x, y))

run a functions against each side of a tuple and stitch them together for use with unfoldrT where "s" is a tuple and you want to stop as soon as the either terminates

ApThese

class ApThese e a x b | x e a -> b where

flexible "e" to use with eg partitionTheseT: Bool is also valid

Methods

apThese :: a -> x -> These e b

Instances

(e ~ a, b ~ a) => ApThese e a Bool b

Defined in Primus.AsMaybe

Methods

apThese :: a -> Bool -> These e b

ApThese e a x z => ApThese e a (Identity x) z

Defined in Primus.AsMaybe

Methods

apThese :: a -> Identity x -> These e z

(e ~ a, b1 ~ [b]) => ApThese e a [b] b1

Defined in Primus.AsMaybe

Methods

apThese :: a -> [b] -> These e b1

(e ~ a, b ~ b1) => ApThese e a (Maybe b) b1

Defined in Primus.AsMaybe

Methods

apThese :: a -> Maybe b -> These e b1

(Semigroup e, b ~ (b1, b2), ApThese e a x b1, ApThese e a y b2) => ApThese e a (x, y) b

Defined in Primus.AsMaybe

Methods

apThese :: a -> (x, y) -> These e b

(z ~ Arg b1 y, ApThese e a x b1) => ApThese e a (Arg x y) z

Defined in Primus.AsMaybe

Methods

apThese :: a -> Arg x y -> These e z

(e ~ e1, b ~ b1) => ApThese e1 a (Either e b) b1

Defined in Primus.AsMaybe

Methods

apThese :: a -> Either e b -> These e1 b1

(e ~ e1, b ~ b1) => ApThese e1 a (These e b) b1

Defined in Primus.AsMaybe

Methods

apThese :: a -> These e b -> These e1 b1

(Semigroup e, b ~ (b1, b2, b3), ApThese e a x b1, ApThese e a y b2, ApThese e a z b3) => ApThese e a (x, y, z) b

Defined in Primus.AsMaybe

Methods

apThese :: a -> (x, y, z) -> These e b

toTheseT :: forall e a x b. ApThese e a x b => (a -> x) -> [a] -> [These e b]

apply a function to a list and convert to a list of These

toTheseTS :: forall e a x b z. ApThese e a x b => (z -> a -> (z, x)) -> z -> [a] -> (z, [These e b])

like toTheseT with state

partitionEithersT :: forall e a b x. ApThese e a x b => (a -> x) -> [a] -> ([e], [b])

like toTheseT but use partitionHereThere on the results (swapped version of partition)

partitionTheseT :: forall e a b x. ApThese e a x b => (a -> x) -> [a] -> ([e], [b], [(e, b)])

like toTheseT but use partitionThese on the results

filterT :: forall e a b x. ApThese e a x b => (a -> x) -> [a] -> [b]

like partitionEithersT ignoring the second element of the result

spanT :: forall e a x b. ApThese e a x b => (a -> x) -> [a] -> ([b], [a])

similar to span using ApThese for failure (support Bool and These)

spanTAlt :: forall e a x b. ApThese e a x b => (a -> x) -> [a] -> ([b], [a])

like spanT but doesn't continue in the These case

spanTS :: forall e a x b z. ApThese e a x b => (z -> a -> (z, x)) -> z -> [a] -> (z, ([b], [a]))

like spanT with state

takeWhileT :: forall e a x b. ApThese e a x b => (a -> x) -> [a] -> [b]

like spanT but ignore the second element of the result

takeWhileTS :: forall e a x b z. ApThese e a x b => (z -> a -> (z, x)) -> z -> [a] -> (z, [b])

like takeWhileT with state

ApTheseF for use with LRHist

class ApTheseF e a x b | x e a -> b where

for use with LRHist using a fixed "e"

Methods

apTheseF :: a -> x -> These e b

Instances

(Monoid e, b ~ a) => ApTheseF e a Bool b

Defined in Primus.AsMaybe

Methods

apTheseF :: a -> Bool -> These e b

ApTheseF e a x z => ApTheseF e a (Identity x) z

Defined in Primus.AsMaybe

Methods

apTheseF :: a -> Identity x -> These e z

(Monoid e, b1 ~ [b]) => ApTheseF e a [b] b1

Defined in Primus.AsMaybe

Methods

apTheseF :: a -> [b] -> These e b1

(Monoid e, b ~ b1) => ApTheseF e a (Maybe b) b1

Defined in Primus.AsMaybe

Methods

apTheseF :: a -> Maybe b -> These e b1

(Semigroup e, b ~ (b1, b2), ApTheseF e a x b1, ApTheseF e a y b2) => ApTheseF e a (x, y) b

Defined in Primus.AsMaybe

Methods

apTheseF :: a -> (x, y) -> These e b

(z ~ Arg b1 y, ApTheseF e a x b1) => ApTheseF e a (Arg x y) z

Defined in Primus.AsMaybe

Methods

apTheseF :: a -> Arg x y -> These e z

(e ~ e1, b ~ b1) => ApTheseF e1 a (Either e b) b1

Defined in Primus.AsMaybe

Methods

apTheseF :: a -> Either e b -> These e1 b1

(e ~ e1, b ~ b1) => ApTheseF e1 a (These e b) b1

Defined in Primus.AsMaybe

Methods

apTheseF :: a -> These e b -> These e1 b1

(Semigroup e, b ~ (b1, b2, b3), ApTheseF e a x b1, ApTheseF e a y b2, ApTheseF e a z b3) => ApTheseF e a (x, y, z) b

Defined in Primus.AsMaybe

Methods

apTheseF :: a -> (x, y, z) -> These e b