Hoogle Search

Within LTS Haskell 24.35 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. data Maybe a

    copilot-language Copilot.Language.Prelude

    The Maybe type encapsulates an optional value. A value of type Maybe a either contains a value of type a (represented as Just a), or it is empty (represented as Nothing). Using Maybe is a good way to deal with errors or exceptional cases without resorting to drastic measures such as error. The Maybe type is also a monad. It is a simple kind of error monad, where all errors are represented by Nothing. A richer error monad can be built using the Either type.

  2. data Maybe a

    quaalude Essentials

    The Maybe type encapsulates an optional value. A value of type Maybe a either contains a value of type a (represented as Just a), or it is empty (represented as Nothing). Using Maybe is a good way to deal with errors or exceptional cases without resorting to drastic measures such as error. The Maybe type is also a monad. It is a simple kind of error monad, where all errors are represented by Nothing. A richer error monad can be built using the Either type.

  3. data Maybe a

    strict-base-types Data.Maybe.Strict

    The type of strict optional values.

  4. data Maybe a

    verset Verset

    The Maybe type encapsulates an optional value. A value of type Maybe a either contains a value of type a (represented as Just a), or it is empty (represented as Nothing). Using Maybe is a good way to deal with errors or exceptional cases without resorting to drastic measures such as error. The Maybe type is also a monad. It is a simple kind of error monad, where all errors are represented by Nothing. A richer error monad can be built using the Either type.

  5. maybeToList :: Maybe a -> [a]

    base Data.Maybe

    The maybeToList function returns an empty list when given Nothing or a singleton list when given Just.

    Examples

    Basic usage: 
    >>> maybeToList (Just 7)
[7]

    >>> maybeToList Nothing
[]
    One can use maybeToList to avoid pattern matching when combined with a function that (safely) works on lists: 
    >>> import GHC.Internal.Text.Read ( readMaybe )

>>> sum $ maybeToList (readMaybe "3")
3

>>> sum $ maybeToList (readMaybe "")
0

  6. maybeNew :: (a -> IO (Ptr b)) -> Maybe a -> IO (Ptr b)

    base Foreign.Marshal.Utils

    Allocate storage and marshal a storable value wrapped into a Maybe

  7. maybePeek :: (Ptr a -> IO b) -> Ptr a -> IO (Maybe b)

    base Foreign.Marshal.Utils

    Convert a peek combinator into a one returning Nothing if applied to a nullPtr

  8. maybeWith :: (a -> (Ptr b -> IO c) -> IO c) -> Maybe a -> (Ptr b -> IO c) -> IO c

    base Foreign.Marshal.Utils

    Converts a withXXX combinator into one marshalling a value wrapped into a Maybe, using nullPtr to represent Nothing.

  9. maybeToExceptT :: forall (m :: Type -> Type) e a . Functor m => e -> MaybeT m a -> ExceptT e m a

    transformers Control.Monad.Trans.Maybe

    Convert a MaybeT computation to ExceptT, with a default exception value.

  10. maybeToListT :: Applicative m => m (Maybe a) -> ListT m a

    directory System.Directory.Internal

    No documentation available.

Page 13 of many | Previous | Next