Safe Haskell	Safe-Inferred
Language	Haskell2010

PlutusTx.Maybe

Synopsis

data Maybe a
- = Nothing
- | Just a
isJust :: Maybe a -> Bool
isNothing :: Maybe a -> Bool
maybe :: b -> (a -> b) -> Maybe a -> b
fromMaybe :: a -> Maybe a -> a
mapMaybe :: (a -> Maybe b) -> [a] -> [b]

Documentation

data Maybe a #

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 PrettyBy config (Maybe a)

By default a [Maybe a] is converted to [a] first and only then pretty-printed.

>>> braces $ prettyBy () (Just True)
{True}
>>> braces $ prettyBy () (Nothing :: Maybe Bool)
{}
>>> prettyBy () [Just False, Nothing, Just True]
[False, True]
>>> prettyBy () [Nothing, Just 'a', Just 'b', Nothing, Just 'c']
abc

Instance details

Defined in CekMachineCostsBase Maybe -> Bool

 Algebra.Graph.Class
 Data a => Data (Maybe a)Since: base-4.0.0.0
Instance details
Defined in Data.Data
 Methods
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) #
gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) #
toConstr :: Maybe a -> Constr #
dataTypeOf :: Maybe a -> DataType #
dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) #
dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) #
gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a #
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r #
gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r #
gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] #
gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u #
gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) #
gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) #
gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) #
 Semigroup a => Monoid (Maybe a)Lift a semigroup into Maybe forming a Monoid according to
 http://en.wikipedia.org/wiki/Monoid: "Any semigroup S may be
 turned into a monoid simply by adjoining an element e not in S
 and defining e*e = e and e*s = s = s*e for all s ∈ S."
Since 4.11.0: constraint on inner a value generalised from
 Pretty (Maybe a)
Ignore Nothings, print Just contents.
>>> pretty (Just True)
True
>>> braces (pretty (Nothing :: Maybe Bool))
{}
>>> pretty [Just 1, Nothing, Just 3, Nothing]
[1, 3]
Instance details
Defined in DefaultUni ()) #

 type Failure Maybe Instance details
Defined in Basement.Monad
 type Failure Maybe = ()
 type Base (Maybe a) = Const (Maybe a) :: Type -> Type