Data.Tickle.RunGetResult

Data type

data RunGetResult e a

Instances

Bitraversable RunGetResult

>>> bitraverse (\n -> if even n then [n - 1] else [n * 2]) (\n -> if n `mod` 5 == 0 then [n + 1] else [n * 7]) (_RunGet # 8)
[RunGet 56]

>>> bitraverse (\n -> if even n then [n - 1] else [n * 2]) (\n -> if n `mod` 5 == 0 then [n + 1] else [n * 7]) (_RunGet # 9)
[RunGet 63]

>>> bitraverse (\n -> if even n then [n - 1] else [n * 2]) (\n -> if n `mod` 5 == 0 then [n + 1] else [n * 7]) (_RunGet # 10)
[RunGet 11]

λ> bitraverse (n -> if even n then [n - 1] else [n * 2]) (n -> if n mod 5 == 0 then [n + 1] else [n * 7]) (_RunGetFail # (8, 18)) [RunGetFail 8 17]

>>> bitraverse (\n -> if even n then [n - 1] else [n * 2]) (\n -> if n `mod` 5 == 0 then [n + 1] else [n * 7]) (_RunGetFail # (8, 19))
[RunGetFail 8 38]

>>> bitraverse (\n -> if even n then [n - 1] else [n * 2]) (\n -> if n `mod` 5 == 0 then [n + 1] else [n * 7]) (_RunGetFail # (8, 20))
[RunGetFail 8 19]

Bifunctor RunGetResult

>>> bimap (+10) (*2) (_RunGet # 12)
RunGet 24

>>> bimap (+10) (*2) (_RunGetFail # (2, 3))
RunGetFail 2 13

Bifoldable RunGetResult

>>> bifoldMap (++"abc") (++"def") (_RunGet # "hi")
"hidef"

>>> bifoldMap (++"abc") (++"def") (_RunGetFail # (12, "hi"))
"hiabc"

Monad (RunGetResult e)

>>> _RunGet # 8 >>= \g -> if even g then _RunGet # (g * 2) else _RunGetFail # (13, g * 14)
RunGet 16

>>> _RunGet # 9 >>= \g -> if even g then _RunGet # (g * 2) else _RunGetFail # (13, g * 14)
RunGetFail 13 126

>>> _RunGetFail # (10, 8) >>= \g -> if even g then _RunGet # (g * 2) else _RunGetFail # (13, g * 14)
RunGetFail 10 8

Functor (RunGetResult e)

>>> fmap (*2) (_RunGet # 8)
RunGet 16

>>> fmap (*2) (_RunGetFail # (9, 13))
RunGetFail 9 13

Applicative (RunGetResult e)

>>> pure 7 :: RunGetResult () Int
RunGet 7

>>> _RunGet # (*2) <*> _RunGet # 9
RunGet 18

>>> _RunGetFail # (10, 2) <*> _RunGet # 9
RunGetFail 10 2

>>> _RunGet # (*2) <*> _RunGetFail # (11, 3)
RunGetFail 11 3

>>> _RunGetFail # (10, 2) <*> _RunGetFail # (11, 3)
RunGetFail 10 2

Foldable (RunGetResult e)

>>> foldMap (++"abc") (_RunGet # "hi")
"hiabc"

>>> foldMap (++"abc") (_RunGetFail # (12, "hi"))
""

Traversable (RunGetResult e)

>>> traverse (\n -> if n `mod` 5 == 0 then [n + 1] else [n * 7]) (_RunGet # 8)
[RunGet 56]

>>> traverse (\n -> if n `mod` 5 == 0 then [n + 1] else [n * 7]) (_RunGet # 10)
[RunGet 11]

Alt (RunGetResult e)

>>> _RunGet # 8 <!> _RunGet # 9
RunGet 8

>>> _RunGet # 8 <!> _RunGetFail # (10, 9)
RunGet 8

>>> _RunGetFail # (10, 8) <!> _RunGet # 9
RunGet 9

>>> _RunGetFail # (10, 8) <!> _RunGet # (20, 9)
RunGet (20,9)

Apply (RunGetResult e)

>>> _RunGet # (*2) <.> _RunGet # 9
RunGet 18

>>> _RunGetFail # (10, 2) <.> _RunGet # 9
RunGetFail 10 2

>>> _RunGet # (*2) <.> _RunGetFail # (11, 3)
RunGetFail 11 3

>>> _RunGetFail # (10, 2) <.> _RunGetFail # (11, 3)
RunGetFail 10 2

Bind (RunGetResult e)

>>> return 7 :: RunGetResult () Int
RunGet 7

>>> _RunGet # 8 >>- \g -> if even g then _RunGet # (g * 2) else _RunGetFail # (13, g * 14)
RunGet 16

>>> _RunGet # 9 >>- \g -> if even g then _RunGet # (g * 2) else _RunGetFail # (13, g * 14)
RunGetFail 13 126

>>> _RunGetFail # (10, 8) >>- \g -> if even g then _RunGet # (g * 2) else _RunGetFail # (13, g * 14)
RunGetFail 10 8

Extend (RunGetResult e)

>>> duplicated (_RunGet # 8)
RunGet (RunGet 8)

>>> duplicated (_RunGetFail # (9, "abc"))
RunGetFail 9 "abc"

(Eq e, Eq a) => Eq (RunGetResult e a)

(Ord e, Ord a) => Ord (RunGetResult e a)

(Show e, Show a) => Show (RunGetResult e a)

Semigroup (RunGetResult e a)

>>> _RunGet # 8 <> _RunGet # 9
RunGet 8

>>> _RunGet # 8 <> _RunGetFail # (10, 9)
RunGet 8

>>> _RunGetFail # (10, 8) <> _RunGet # 9
RunGet 9

>>> _RunGetFail # (10, 8) <> _RunGet # (20, 9)
RunGet (20,9)

Reduction

runGetResult :: (Int64 -> e -> x) -> (a -> x) -> RunGetResult e a -> x

>>> runGetResult (+) (*2) (_RunGet # 12)
24

>>> runGetResult (+) (*2) (_RunGetFail # (23, 12))
35

Prisms

_RunGetFail :: Prism' (RunGetResult e a) (Int64, e)

>>> _RunGetFail # (10, "abc")
RunGetFail 10 "abc"

>>> (_RunGet # 8) ^? _RunGetFail
Nothing

>>> (_RunGetFail # (8, "abc")) ^? _RunGetFail
Just (8,"abc")

_RunGet :: Prism' (RunGetResult e a) a

>>> :t _RunGet # 8
_RunGet # 8 :: Num b => RunGetResult e b

>>> (_RunGet # 8) ^? _RunGet
Just 8

>>> (_RunGetFail # (8, "abc")) ^? _RunGet
Nothing

Isomorphisms

runGetResultEitherIso :: Iso (RunGetResult a b) (RunGetResult b d) (Either (Int64, a) b) (Either (Int64, b) d)

>>> runGetResultEitherIso # Right 99
RunGet 99

>>> runGetResultEitherIso # Left (12, "abc")
RunGetFail 12 "abc"

>>> from runGetResultEitherIso # _RunGet # 99
Right 99

>>> from runGetResultEitherIso # _RunGetFail # (12, "abc")
Left (12,"abc")

runGetResultValidationIso :: Iso (RunGetResult a b) (RunGetResult b d) (Validation (Int64, a) b) (Validation (Int64, b) d)

>>> runGetResultValidationIso # _Success # 99
RunGet 99

>>> runGetResultValidationIso # _Failure # (12, "abc")
RunGetFail 12 "abc"

>>> from runGetResultValidationIso # _RunGet # 99
Success 99

>>> from runGetResultValidationIso # _RunGetFail # (12, "abc")
Failure (12,"abc")

runGetResultValidation'Iso :: Iso (RunGetResult a b) (RunGetResult b d) (Validation' (Int64, a) b) (Validation' (Int64, b) d)

>>> runGetResultValidation'Iso . from _Validation' # _Right # 99
RunGet 99

>>> runGetResultValidation'Iso . from _Validation' # _Left # (12, "abc")
RunGetFail 12 "abc"

>>> from (runGetResultValidation'Iso . from _Validation') # _RunGet # 99 :: Validation (Int64, ()) Int
Success 99

>>> from (runGetResultValidation'Iso . from _Validation') # _RunGetFail # (12, "abc") :: Validation (Int64, String) ()
Failure (12,"abc")

runGetResultAccValidationIso :: Iso (RunGetResult a b) (RunGetResult b d) (AccValidation (Int64, a) b) (AccValidation (Int64, b) d)

>>> runGetResultAccValidationIso # _Success # 99
RunGet 99

>>> runGetResultAccValidationIso # _Failure # (12, "abc")
RunGetFail 12 "abc"

>>> from runGetResultAccValidationIso # _RunGet # 99
AccSuccess 99

>>> from runGetResultAccValidationIso # _RunGetFail # (12, "abc")
AccFailure (12,"abc")