{-# LANGUAGE Safe, FlexibleContexts #-}
module Cryptol.Utils.Misc where
import MonadLib
import Data.Maybe(fromMaybe)
import Prelude ()
import Prelude.Compat
anyJust :: Traversable t => (a -> Maybe a) -> t a -> Maybe (t a)
anyJust :: (a -> Maybe a) -> t a -> Maybe (t a)
anyJust f :: a -> Maybe a
f m :: t a
m = (t a, Bool) -> Maybe (t a)
forall a. (a, Bool) -> Maybe a
mk ((t a, Bool) -> Maybe (t a)) -> (t a, Bool) -> Maybe (t a)
forall a b. (a -> b) -> a -> b
$ Id (t a, Bool) -> (t a, Bool)
forall a. Id a -> a
runId (Id (t a, Bool) -> (t a, Bool)) -> Id (t a, Bool) -> (t a, Bool)
forall a b. (a -> b) -> a -> b
$ Bool -> StateT Bool Id (t a) -> Id (t a, Bool)
forall i (m :: * -> *) a. i -> StateT i m a -> m (a, i)
runStateT Bool
False (StateT Bool Id (t a) -> Id (t a, Bool))
-> StateT Bool Id (t a) -> Id (t a, Bool)
forall a b. (a -> b) -> a -> b
$ (a -> StateT Bool Id a) -> t a -> StateT Bool Id (t a)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse a -> StateT Bool Id a
forall (m :: * -> *). StateM m Bool => a -> m a
upd t a
m
where
mk :: (a, Bool) -> Maybe a
mk (a :: a
a,changes :: Bool
changes) = if Bool
changes then a -> Maybe a
forall a. a -> Maybe a
Just a
a else Maybe a
forall a. Maybe a
Nothing
upd :: a -> m a
upd x :: a
x = case a -> Maybe a
f a
x of
Just y :: a
y -> Bool -> m ()
forall (m :: * -> *) i. StateM m i => i -> m ()
set Bool
True m () -> m a -> m a
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
y
Nothing -> a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
x
anyJust2 :: (a -> Maybe a) -> (b -> Maybe b) -> (a,b) -> Maybe (a,b)
anyJust2 :: (a -> Maybe a) -> (b -> Maybe b) -> (a, b) -> Maybe (a, b)
anyJust2 f :: a -> Maybe a
f g :: b -> Maybe b
g (a :: a
a,b :: b
b) =
case (a -> Maybe a
f a
a, b -> Maybe b
g b
b) of
(Nothing, Nothing) -> Maybe (a, b)
forall a. Maybe a
Nothing
(x :: Maybe a
x,y :: Maybe b
y) -> (a, b) -> Maybe (a, b)
forall a. a -> Maybe a
Just (a -> Maybe a -> a
forall a. a -> Maybe a -> a
fromMaybe a
a Maybe a
x, b -> Maybe b -> b
forall a. a -> Maybe a -> a
fromMaybe b
b Maybe b
y)