Safe Haskell	Safe-Inferred
Language	Haskell2010

Ganeti.BasicTypes

Synopsis

data GenericResult a b
- = Bad a
- | Ok b
genericResult :: (a -> c) -> (b -> c) -> GenericResult a b -> c
type Result = GenericResult String
newtype ResultT a m b = ResultT {
- runResultT :: m (GenericResult a b)
}
mkResultT :: (Monad m, Error e) => m (Result a) -> ResultT e m a
withError :: MonadError e m => (e' -> e) -> GenericResult e' a -> m a
withErrorT :: (Monad m, Error e) => (e' -> e) -> ResultT e' m a -> ResultT e m a
toError :: MonadError e m => GenericResult e a -> m a
toErrorBase :: (MonadBase b m, MonadError e m) => ResultT e b a -> m a
toErrorStr :: (MonadError e m, Error e) => Result a -> m a
tryError :: MonadError e m => m a -> m (Either e a)
class Error e where
- strMsg :: String -> e
class Monad m => MonadIO (m :: Type -> Type) where
- liftIO :: IO a -> m a
isOk :: GenericResult a b -> Bool
isBad :: GenericResult a b -> Bool
justOk :: [GenericResult a b] -> [b]
justBad :: [GenericResult a b] -> [a]
eitherToResult :: Either a b -> GenericResult a b
isLeft :: Either a b -> Bool
isRight :: Either a b -> Bool
annotateResult :: (MonadError e m, Error e) => String -> Result a -> m a
annotateError :: (MonadError e m, Error e, Monoid e) => String -> m a -> m a
failError :: (MonadError e m, Error e) => String -> m a
catchErrorT :: (Monad m, Error e) => ResultT e' m a -> (e' -> ResultT e m a) -> ResultT e m a
handleErrorT :: (Monad m, Error e) => (e' -> ResultT e m a) -> ResultT e' m a -> ResultT e m a
orElse :: MonadError e m => m a -> m a -> m a
iterateOk :: (a -> GenericResult b a) -> a -> [a]
select :: a -> [(Bool, a)] -> a
runListHead :: a -> (b -> a) -> [b] -> a
data LookupResult = LookupResult {
- lrMatchPriority :: MatchPriority
- lrContent :: String
}
data MatchPriority
- = ExactMatch
- | MultipleMatch
- | PartialMatch
- | FailMatch
lookupName :: [String] -> String -> LookupResult
goodLookupResult :: LookupResult -> Bool
goodMatchPriority :: MatchPriority -> Bool
prefixMatch :: String -> String -> Bool
compareNameComponent :: String -> String -> LookupResult
newtype ListSet a = ListSet {
- unListSet :: Set a
}
emptyListSet :: ListSet a

Documentation

data GenericResult a b #

Generic monad for our error handling mechanisms.

Constructors

Bad a
Ok b

Instances

Instances details

Error a => MonadError a (GenericResult a) #
Instance details Defined in Ganeti.BasicTypes Methods throwError :: a -> GenericResult a a0 catchError :: GenericResult a a0 -> (a -> GenericResult a a0) -> GenericResult a a0
Error a => MonadFail (GenericResult a) #
Instance details Defined in Ganeti.BasicTypes Methods fail :: String -> GenericResult a a0
(Error a, Monoid a) => Alternative (GenericResult a) #
Instance details Defined in Ganeti.BasicTypes Methods empty :: GenericResult a a0 (<\|>) :: GenericResult a a0 -> GenericResult a a0 -> GenericResult a a0 some :: GenericResult a a0 -> GenericResult a [a0] many :: GenericResult a a0 -> GenericResult a [a0]
Applicative (GenericResult a) #
Instance details Defined in Ganeti.BasicTypes Methods pure :: a0 -> GenericResult a a0 (<>) :: GenericResult a (a0 -> b) -> GenericResult a a0 -> GenericResult a b liftA2 :: (a0 -> b -> c) -> GenericResult a a0 -> GenericResult a b -> GenericResult a c (>) :: GenericResult a a0 -> GenericResult a b -> GenericResult a b (<*) :: GenericResult a a0 -> GenericResult a b -> GenericResult a a0
Functor (GenericResult a) #
Instance details Defined in Ganeti.BasicTypes Methods fmap :: (a0 -> b) -> GenericResult a a0 -> GenericResult a b (<$) :: a0 -> GenericResult a b -> GenericResult a a0
Error a => Monad (GenericResult a) #	`Monad` instance for `GenericResult`.
Instance details Defined in Ganeti.BasicTypes Methods (>>=) :: GenericResult a a0 -> (a0 -> GenericResult a b) -> GenericResult a b (>>) :: GenericResult a a0 -> GenericResult a b -> GenericResult a b return :: a0 -> GenericResult a a0
(Error a, Monoid a) => MonadPlus (GenericResult a) #
Instance details Defined in Ganeti.BasicTypes Methods mzero :: GenericResult a a0 mplus :: GenericResult a a0 -> GenericResult a a0 -> GenericResult a a0
(Show a, Show b) => Show (GenericResult a b) #
Instance details Defined in Ganeti.BasicTypes Methods showsPrec :: Int -> GenericResult a b -> ShowS show :: GenericResult a b -> String showList :: [GenericResult a b] -> ShowS
(Eq a, Eq b) => Eq (GenericResult a b) #
Instance details Defined in Ganeti.BasicTypes Methods (==) :: GenericResult a b -> GenericResult a b -> Bool (/=) :: GenericResult a b -> GenericResult a b -> Bool

genericResult :: (a -> c) -> (b -> c) -> GenericResult a b -> c #

Sum type structure of GenericResult.

type Result = GenericResult String #

Type alias for a string Result.

newtype ResultT a m b #

This is a monad transformation for Result. It's implementation is based on the implementations of MaybeT and ErrorT.

ResultT is very similar to ErrorT, but with one subtle difference: If mplus combines two failing operations, errors of both of them are combined.

Constructors

ResultT
Fields runResultT :: m (GenericResult a b)

Instances

Instances details

(Error a, MonadBaseControl IO m) => MonadBaseControl IO (ResultT a m) #
Instance details Defined in Ganeti.BasicTypes Associated Types type StM (ResultT a m) a Methods liftBaseWith :: (RunInBase (ResultT a m) IO -> IO a0) -> ResultT a m a0 restoreM :: StM (ResultT a m) a0 -> ResultT a m a0
(Monad m, Error a) => MonadError a (ResultT a m) #
Instance details Defined in Ganeti.BasicTypes Methods throwError :: a -> ResultT a m a0 catchError :: ResultT a m a0 -> (a -> ResultT a m a0) -> ResultT a m a0
(MonadBase IO m, Error a) => MonadBase IO (ResultT a m) #
Instance details Defined in Ganeti.BasicTypes Methods liftBase :: IO α -> ResultT a m α
Error a => MonadTransControl (ResultT a) #
Instance details Defined in Ganeti.BasicTypes Associated Types type StT (ResultT a) a Methods liftWith :: Monad m => (Run (ResultT a) -> m a0) -> ResultT a m a0 restoreT :: Monad m => m (StT (ResultT a) a0) -> ResultT a m a0
Error a => MonadTrans (ResultT a) #
Instance details Defined in Ganeti.BasicTypes Methods lift :: Monad m => m a0 -> ResultT a m a0
(Monad m, Error a) => MonadFail (ResultT a m) #
Instance details Defined in Ganeti.BasicTypes Methods fail :: String -> ResultT a m a0
(MonadIO m, Error a) => MonadIO (ResultT a m) #	The instance catches any `IOError` using `tryIOError` and converts it into an error message using `strMsg`. This way, monadic code within `ResultT` that uses solely `liftIO` to include `IO` actions ensures that all IO exceptions are handled. Other exceptions (see instances of `Exception`) are not currently handled. This might be revised in the future.
Instance details Defined in Ganeti.BasicTypes Methods liftIO :: IO a0 -> ResultT a m a0 #
(Monad m, Error a, Monoid a) => Alternative (ResultT a m) #
Instance details Defined in Ganeti.BasicTypes Methods empty :: ResultT a m a0 (<\|>) :: ResultT a m a0 -> ResultT a m a0 -> ResultT a m a0 some :: ResultT a m a0 -> ResultT a m [a0] many :: ResultT a m a0 -> ResultT a m [a0]
(Applicative m, Monad m, Error a) => Applicative (ResultT a m) #
Instance details Defined in Ganeti.BasicTypes Methods pure :: a0 -> ResultT a m a0 (<>) :: ResultT a m (a0 -> b) -> ResultT a m a0 -> ResultT a m b liftA2 :: (a0 -> b -> c) -> ResultT a m a0 -> ResultT a m b -> ResultT a m c (>) :: ResultT a m a0 -> ResultT a m b -> ResultT a m b (<*) :: ResultT a m a0 -> ResultT a m b -> ResultT a m a0
Functor m => Functor (ResultT a m) #
Instance details Defined in Ganeti.BasicTypes Methods fmap :: (a0 -> b) -> ResultT a m a0 -> ResultT a m b (<$) :: a0 -> ResultT a m b -> ResultT a m a0
(Monad m, Error a) => Monad (ResultT a m) #
Instance details Defined in Ganeti.BasicTypes Methods (>>=) :: ResultT a m a0 -> (a0 -> ResultT a m b) -> ResultT a m b (>>) :: ResultT a m a0 -> ResultT a m b -> ResultT a m b return :: a0 -> ResultT a m a0
(Monad m, Error a, Monoid a) => MonadPlus (ResultT a m) #
Instance details Defined in Ganeti.BasicTypes Methods mzero :: ResultT a m a0 mplus :: ResultT a m a0 -> ResultT a m a0 -> ResultT a m a0
(MonadLog m, Error e) => MonadLog (ResultT e m) #
Instance details Defined in Ganeti.Logging Methods logAt :: Priority -> String -> ResultT e m () #
type StT (ResultT a) b #
Instance details Defined in Ganeti.BasicTypes type StT (ResultT a) b = GenericResult a b
type StM (ResultT a m) b #
Instance details Defined in Ganeti.BasicTypes type StM (ResultT a m) b = ComposeSt (ResultT a) m b

mkResultT :: (Monad m, Error e) => m (Result a) -> ResultT e m a #

Converts a monadic result with a String message into a ResultT with an arbitrary Error.

Expects that the given action has already taken care of any possible errors. In particular, if applied on IO (Result a), any exceptions should be handled by the given action.

Instances

Instances details

Error IOException #
Instance details Defined in Ganeti.BasicTypes Methods strMsg :: String -> IOException #
Error GanetiException #
Instance details Defined in Ganeti.Errors Methods strMsg :: String -> GanetiException #
Error FailMode #	`Error` instance for `FailMode` designed to catch unintended use as a general monad.
Instance details Defined in Ganeti.HTools.Types Methods strMsg :: String -> FailMode #
a ~ Char => Error [a] #
Instance details Defined in Ganeti.BasicTypes Methods strMsg :: String -> [a] #

class Monad m => MonadIO (m :: Type -> Type) where #

Methods

liftIO :: IO a -> m a #

Instances

Instances details

MonadIO MetadMonadInt #
Instance details Defined in Ganeti.Metad.ConfigCore Methods liftIO :: IO a -> MetadMonadInt a #
MonadIO RpcClientMonad #
Instance details Defined in Ganeti.THH.HsRPC Methods liftIO :: IO a -> RpcClientMonad a #
MonadIO WConfdMonadInt #
Instance details Defined in Ganeti.WConfd.Monad Methods liftIO :: IO a -> WConfdMonadInt a #
MonadIO IO
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a #
MonadIO Snap
Instance details Defined in Snap.Internal.Core Methods liftIO :: IO a -> Snap a #
MonadIO Q
Instance details Defined in Language.Haskell.TH.Syntax Methods liftIO :: IO a -> Q a #
MonadIO m => MonadIO (WriterLogT m) #
Instance details Defined in Ganeti.Logging.WriterLog Methods liftIO :: IO a -> WriterLogT m a #
MonadIO m => MonadIO (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftIO :: IO a -> MaybeT m a #
(Functor f, MonadIO m) => MonadIO (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods liftIO :: IO a -> FreeT f m a #
(MonadIO m, Error a) => MonadIO (ResultT a m) #	The instance catches any `IOError` using `tryIOError` and converts it into an error message using `strMsg`. This way, monadic code within `ResultT` that uses solely `liftIO` to include `IO` actions ensures that all IO exceptions are handled. Other exceptions (see instances of `Exception`) are not currently handled. This might be revised in the future.
Instance details Defined in Ganeti.BasicTypes Methods liftIO :: IO a0 -> ResultT a m a0 #
(Monoid w, Functor m, MonadIO m) => MonadIO (AccumT w m)
Instance details Defined in Control.Monad.Trans.Accum Methods liftIO :: IO a -> AccumT w m a #
MonadIO m => MonadIO (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftIO :: IO a -> ExceptT e m a #
MonadIO m => MonadIO (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods liftIO :: IO a -> IdentityT m a #
MonadIO m => MonadIO (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a #
MonadIO m => MonadIO (SelectT r m)
Instance details Defined in Control.Monad.Trans.Select Methods liftIO :: IO a -> SelectT r m a #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods liftIO :: IO a -> StateT s m a #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods liftIO :: IO a -> StateT s m a #
MonadIO m => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods liftIO :: IO a -> WriterT w m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods liftIO :: IO a -> WriterT w m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods liftIO :: IO a -> WriterT w m a #
MonadIO m => MonadIO (ContT r m)
Instance details Defined in Control.Monad.Trans.Cont Methods liftIO :: IO a -> ContT r m a #
MonadIO m => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods liftIO :: IO a -> RWST r w s m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods liftIO :: IO a -> RWST r w s m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods liftIO :: IO a -> RWST r w s m a #

isOk :: GenericResult a b -> Bool #

Simple checker for whether a GenericResult is OK.

isBad :: GenericResult a b -> Bool #

Simple checker for whether a GenericResult is a failure.

justOk :: [GenericResult a b] -> [b] #

Simple filter returning only OK values of GenericResult

justBad :: [GenericResult a b] -> [a] #

Simple filter returning only Bad values of GenericResult

eitherToResult :: Either a b -> GenericResult a b #

Converter from Either to GenericResult.

isLeft :: Either a b -> Bool #

Check if an either is Left. Equivalent to isLeft from Data.Either version 4.7.0.0 or higher.

isRight :: Either a b -> Bool #

Check if an either is Right. Equivalent to isRight from Data.Either version 4.7.0.0 or higher.

annotateResult :: (MonadError e m, Error e) => String -> Result a -> m a #

Annotate an error with an ownership information, lifting it to a MonadError. Since Result is an instance of MonadError itself, it's a generalization of type String -> Result a -> Result a. See also toErrorStr.

annotateError :: (MonadError e m, Error e, Monoid e) => String -> m a -> m a #

Annotate an error with an ownership information inside a MonadError. See also annotateResult.

failError :: (MonadError e m, Error e) => String -> m a #

Throws a String message as an error in a MonadError. This is a generalization of Bad. It's similar to fail, but works within a MonadError, avoiding the unsafe nature of fail.

catchErrorT :: (Monad m, Error e) => ResultT e' m a -> (e' -> ResultT e m a) -> ResultT e m a #

Catches an error in a ResultT value. This is similar to catchError, but in addition allows to change the error type.

handleErrorT :: (Monad m, Error e) => (e' -> ResultT e m a) -> ResultT e' m a -> ResultT e m a #

A synonym for flip catchErrorT.

orElse :: MonadError e m => m a -> m a -> m a #

If the first computation fails, run the second one. Unlike mplus instance for ResultT, this doesn't require the Monoid constrait.

iterateOk :: (a -> GenericResult b a) -> a -> [a] #

Iterate while Ok.

select #

Arguments

:: a	default result
-> [(Bool, a)]	list of "condition, result"
-> a	first result which has a True condition, or default

Return the first result with a True condition, or the default otherwise.

runListHead :: a -> (b -> a) -> [b] -> a #

Apply a function to the first element of a list, return the default value, if the list is empty. This is just a convenient combination of maybe and listToMaybe.

data LookupResult #

The result of a name lookup in a list.

Constructors

LookupResult
Fields lrMatchPriority :: MatchPriority The result type \| Matching value (for ExactMatch, PartialMatch), Lookup string otherwise lrContent :: String

Instances

Instances details

Show LookupResult #
Instance details Defined in Ganeti.BasicTypes Methods showsPrec :: Int -> LookupResult -> ShowS show :: LookupResult -> String showList :: [LookupResult] -> ShowS
Eq LookupResult #	Lookup results have an absolute preference ordering.
Instance details Defined in Ganeti.BasicTypes Methods (==) :: LookupResult -> LookupResult -> Bool (/=) :: LookupResult -> LookupResult -> Bool
Ord LookupResult #
Instance details Defined in Ganeti.BasicTypes Methods compare :: LookupResult -> LookupResult -> Ordering (<) :: LookupResult -> LookupResult -> Bool (<=) :: LookupResult -> LookupResult -> Bool (>) :: LookupResult -> LookupResult -> Bool (>=) :: LookupResult -> LookupResult -> Bool max :: LookupResult -> LookupResult -> LookupResult min :: LookupResult -> LookupResult -> LookupResult

data MatchPriority #

The priority of a match in a lookup result.

Constructors

ExactMatch
MultipleMatch
PartialMatch
FailMatch

Instances

Instances details

Enum MatchPriority #
Instance details Defined in Ganeti.BasicTypes Methods succ :: MatchPriority -> MatchPriority pred :: MatchPriority -> MatchPriority toEnum :: Int -> MatchPriority fromEnum :: MatchPriority -> Int enumFrom :: MatchPriority -> [MatchPriority] enumFromThen :: MatchPriority -> MatchPriority -> [MatchPriority] enumFromTo :: MatchPriority -> MatchPriority -> [MatchPriority] enumFromThenTo :: MatchPriority -> MatchPriority -> MatchPriority -> [MatchPriority]
Show MatchPriority #
Instance details Defined in Ganeti.BasicTypes Methods showsPrec :: Int -> MatchPriority -> ShowS show :: MatchPriority -> String showList :: [MatchPriority] -> ShowS
Eq MatchPriority #
Instance details Defined in Ganeti.BasicTypes Methods (==) :: MatchPriority -> MatchPriority -> Bool (/=) :: MatchPriority -> MatchPriority -> Bool
Ord MatchPriority #
Instance details Defined in Ganeti.BasicTypes Methods compare :: MatchPriority -> MatchPriority -> Ordering (<) :: MatchPriority -> MatchPriority -> Bool (<=) :: MatchPriority -> MatchPriority -> Bool (>) :: MatchPriority -> MatchPriority -> Bool (>=) :: MatchPriority -> MatchPriority -> Bool max :: MatchPriority -> MatchPriority -> MatchPriority min :: MatchPriority -> MatchPriority -> MatchPriority

lookupName #

Arguments

:: [String]	List of keys
-> String	Lookup string
-> LookupResult	Result of the lookup

Find the canonical name for a lookup string in a list of names.

goodLookupResult :: LookupResult -> Bool #

Is the lookup result an actual match?

goodMatchPriority :: MatchPriority -> Bool #

Is the lookup priority a "good" one?

prefixMatch #

Arguments

:: String	Lookup
-> String	Full name
-> Bool	Whether there is a prefix match

Check for prefix matches in names. Implemented in Ganeti core utils.text.MatchNameComponent as the regexp r"^%s(..*)?$" % re.escape(key)

compareNameComponent #

Arguments

:: String	Canonical (target) name
-> String	Partial (lookup) name
-> LookupResult	Result of the lookup

Compares a canonical name and a lookup string.

newtype ListSet a #

Wrapper for a Haskell Set

This type wraps a Set and it is used in the Haskell to Python opcode generation to transform a Haskell Set into a Python list without duplicate elements.

Constructors

ListSet
Fields unListSet :: Set a

Instances

Instances details

Show a => Show (ListSet a) #
Instance details Defined in Ganeti.BasicTypes Methods showsPrec :: Int -> ListSet a -> ShowS show :: ListSet a -> String showList :: [ListSet a] -> ShowS
PyValue a => PyValue (ListSet a) #
Instance details Defined in Ganeti.PyValue Methods showValue :: ListSet a -> String # showValueList :: [ListSet a] -> String #
Eq a => Eq (ListSet a) #
Instance details Defined in Ganeti.BasicTypes Methods (==) :: ListSet a -> ListSet a -> Bool (/=) :: ListSet a -> ListSet a -> Bool
Ord a => Ord (ListSet a) #
Instance details Defined in Ganeti.BasicTypes Methods compare :: ListSet a -> ListSet a -> Ordering (<) :: ListSet a -> ListSet a -> Bool (<=) :: ListSet a -> ListSet a -> Bool (>) :: ListSet a -> ListSet a -> Bool (>=) :: ListSet a -> ListSet a -> Bool max :: ListSet a -> ListSet a -> ListSet a min :: ListSet a -> ListSet a -> ListSet a
(Ord a, JSON a) => JSON (ListSet a) #
Instance details Defined in Ganeti.BasicTypes Methods readJSON :: JSValue -> Result (ListSet a) showJSON :: ListSet a -> JSValue readJSONs :: JSValue -> Result [ListSet a] showJSONs :: [ListSet a] -> JSValue

emptyListSet :: ListSet a #