Prolude.Maybe

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 Either type.

Constructors

Nothing

Just a

Instances

Arbitrary1 Maybe

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a -> Gen (Maybe a)

liftShrink :: (a -> [a]) -> Maybe a -> [Maybe a]

FromJSON1 Maybe

Defined in Data.Aeson.Types.FromJSON

Methods

liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Maybe a)

liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Maybe a]

ToJSON1 Maybe

Defined in Data.Aeson.Types.ToJSON

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> Maybe a -> Value

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Maybe a] -> Value

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Maybe a -> Encoding

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Maybe a] -> Encoding

MonadFail Maybe

Since: base-4.9.0.0

Defined in Control.Monad.Fail

Methods

fail :: String -> Maybe a

Foldable Maybe

Since: base-2.1

Defined in Data.Foldable

Methods

fold :: Monoid m => Maybe m -> m

foldMap :: Monoid m => (a -> m) -> Maybe a -> m

foldMap' :: Monoid m => (a -> m) -> Maybe a -> m

foldr :: (a -> b -> b) -> b -> Maybe a -> b

foldr' :: (a -> b -> b) -> b -> Maybe a -> b

foldl :: (b -> a -> b) -> b -> Maybe a -> b

foldl' :: (b -> a -> b) -> b -> Maybe a -> b

foldr1 :: (a -> a -> a) -> Maybe a -> a

foldl1 :: (a -> a -> a) -> Maybe a -> a

toList :: Maybe a -> [a]

null :: Maybe a -> Bool

length :: Maybe a -> Int

elem :: Eq a => a -> Maybe a -> Bool

maximum :: Ord a => Maybe a -> a

minimum :: Ord a => Maybe a -> a

sum :: Num a => Maybe a -> a

product :: Num a => Maybe a -> a

Traversable Maybe

Since: base-2.1

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b)

sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a)

mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b)

sequence :: Monad m => Maybe (m a) -> m (Maybe a)

Alternative Maybe

Since: base-2.1

Defined in GHC.Base

Methods

empty :: Maybe a

(<|>) :: Maybe a -> Maybe a -> Maybe a

some :: Maybe a -> Maybe [a]

many :: Maybe a -> Maybe [a]

Applicative Maybe

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> Maybe a

(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b

liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c

(*>) :: Maybe a -> Maybe b -> Maybe b

(<*) :: Maybe a -> Maybe b -> Maybe a

Functor Maybe

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a -> b) -> Maybe a -> Maybe b

(<$) :: a -> Maybe b -> Maybe a

Monad Maybe

Since: base-2.1

Defined in GHC.Base

Methods

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b

(>>) :: Maybe a -> Maybe b -> Maybe b

return :: a -> Maybe a

MonadPlus Maybe

Since: base-2.1

Defined in GHC.Base

Methods

mzero :: Maybe a

mplus :: Maybe a -> Maybe a -> Maybe a

MonadFailure Maybe

Defined in Basement.Monad

Associated Types

type Failure Maybe

Methods

mFail :: Failure Maybe -> Maybe ()

NFData1 Maybe

Since: deepseq-1.4.3.0

Defined in Control.DeepSeq

Methods

liftRnf :: (a -> ()) -> Maybe a -> ()

MonadThrow Maybe

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> Maybe a

Hashable1 Maybe

Defined in Data.Hashable.Class

Methods

liftHashWithSalt :: (Int -> a -> Int) -> Int -> Maybe a -> Int

Generic1 Maybe

Defined in GHC.Generics

Associated Types

type Rep1 Maybe :: k -> Type

Methods

from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a

to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a

MonadBaseControl Maybe Maybe

Defined in Control.Monad.Trans.Control

Associated Types

type StM Maybe a

Methods

liftBaseWith :: (RunInBase Maybe Maybe -> Maybe a) -> Maybe a

restoreM :: StM Maybe a -> Maybe a

(Selector s, GToJSON' enc arity (K1 i (Maybe a) :: TYPE LiftedRep -> Type), KeyValuePair enc pairs, Monoid pairs) => RecordToPairs enc pairs arity (S1 s (K1 i (Maybe a) :: TYPE LiftedRep -> Type))

Defined in Data.Aeson.Types.ToJSON

Methods

recordToPairs :: Options -> ToArgs enc arity a0 -> S1 s (K1 i (Maybe a)) a0 -> pairs

(PersistEntity rec, PersistField typ, SymbolToField sym rec typ) => HasField (sym :: Symbol) (SqlExpr (Maybe (Entity rec))) (SqlExpr (Value (Maybe typ)))

This instance allows you to use record.field notation with GC 9.2's OverloadedRecordDot extension.

Example:

-- persistent model:
Person
    name         Text

BlogPost
    title        Text
    authorId     PersonId

-- query:

select $ do
    (p :& bp) <- from $
        table Person
        leftJoin table BlogPost
        on do
            \(p :& bp) ->
                just p.id ==. bp.authorId
    pure (p.name, bp.title)

The following forms are all equivalent:

blogPost :: SqlExpr (Maybe (Entity BlogPost))

blogPost ?. BlogPostTitle
blogPost ?. #title
blogPost.title

Since: esqueleto-3.5.4.0

Defined in Database.Esqueleto.Internal.Internal

Methods

getField :: SqlExpr (Maybe (Entity rec)) -> SqlExpr (Value (Maybe typ))

(Selector s, FromHttpApiData c) => GFromForm (t :: k) (M1 S s (K1 i (Maybe c) :: Type -> Type))

Defined in Web.Internal.FormUrlEncoded

Methods

gFromForm :: Proxy t -> FormOptions -> Form -> Either Text (M1 S s (K1 i (Maybe c)) x)

(Selector s, ToHttpApiData c) => GToForm (t :: k) (M1 S s (K1 i (Maybe c) :: Type -> Type))

Defined in Web.Internal.FormUrlEncoded

Methods

gToForm :: Proxy t -> FormOptions -> M1 S s (K1 i (Maybe c)) x -> Form

HasAdditionalProperties Schema (Maybe AdditionalProperties)

Defined in Data.Swagger.Lens

Methods

additionalProperties :: Lens' Schema (Maybe AdditionalProperties)

HasAllOf Schema (Maybe [Referenced Schema])

Defined in Data.Swagger.Lens

Methods

allOf :: Lens' Schema (Maybe [Referenced Schema])

HasAllowEmptyValue ParamOtherSchema (Maybe Bool)

Defined in Data.Swagger.Lens

Methods

allowEmptyValue :: Lens' ParamOtherSchema (Maybe Bool)

HasAttribute Xml (Maybe Bool)

Defined in Data.Swagger.Lens

Methods

attribute :: Lens' Xml (Maybe Bool)

HasBasePath Swagger (Maybe FilePath)

Defined in Data.Swagger.Lens

Methods

basePath :: Lens' Swagger (Maybe FilePath)

HasConsumes Operation (Maybe MimeList)

Defined in Data.Swagger.Lens

Methods

consumes :: Lens' Operation (Maybe MimeList)

HasContact Info (Maybe Contact)

Defined in Data.Swagger.Lens

Methods

contact :: Lens' Info (Maybe Contact)

HasDefault Header (Maybe Value)

Defined in Data.Swagger.Lens

Methods

default_ :: Lens' Header (Maybe Value)

HasDefault ParamOtherSchema (Maybe Value)

Defined in Data.Swagger.Lens

Methods

default_ :: Lens' ParamOtherSchema (Maybe Value)

HasDefault Responses (Maybe (Referenced Response))

Defined in Data.Swagger.Lens

Methods

default_ :: Lens' Responses (Maybe (Referenced Response))

HasDefault Schema (Maybe Value)

Defined in Data.Swagger.Lens

Methods

default_ :: Lens' Schema (Maybe Value)

HasDelete PathItem (Maybe Operation)

Defined in Data.Swagger.Lens

Methods

delete :: Lens' PathItem (Maybe Operation)

HasDeprecated Operation (Maybe Bool)

Defined in Data.Swagger.Lens

Methods

deprecated :: Lens' Operation (Maybe Bool)

HasDescription ExternalDocs (Maybe Text)

Defined in Data.Swagger.Lens

Methods

description :: Lens' ExternalDocs (Maybe Text)

HasDescription Header (Maybe Text)

Defined in Data.Swagger.Lens

Methods

description :: Lens' Header (Maybe Text)

HasDescription Info (Maybe Text)

Defined in Data.Swagger.Lens

Methods

description :: Lens' Info (Maybe Text)

HasDescription Operation (Maybe Text)

Defined in Data.Swagger.Lens

Methods

description :: Lens' Operation (Maybe Text)

HasDescription Param (Maybe Text)

Defined in Data.Swagger.Lens

Methods

description :: Lens' Param (Maybe Text)

HasDescription Schema (Maybe Text)

Defined in Data.Swagger.Lens

Methods

description :: Lens' Schema (Maybe Text)

HasDescription SecurityScheme (Maybe Text)

Defined in Data.Swagger.Lens

Methods

description :: Lens' SecurityScheme (Maybe Text)

HasDescription Tag (Maybe Text)

Defined in Data.Swagger.Lens

Methods

description :: Lens' Tag (Maybe Text)

HasDiscriminator Schema (Maybe Text)

Defined in Data.Swagger.Lens

Methods

discriminator :: Lens' Schema (Maybe Text)

HasEmail Contact (Maybe Text)

Defined in Data.Swagger.Lens

Methods

email :: Lens' Contact (Maybe Text)

HasParamSchema s (ParamSchema t) => HasEnum s (Maybe [Value])

Defined in Data.Swagger.Lens

Methods

enum_ :: Lens' s (Maybe [Value])

HasExample Schema (Maybe Value)

Defined in Data.Swagger.Lens

Methods

example :: Lens' Schema (Maybe Value)

HasExamples Response (Maybe Example)

Defined in Data.Swagger.Lens

Methods

examples :: Lens' Response (Maybe Example)

HasParamSchema s (ParamSchema t) => HasExclusiveMaximum s (Maybe Bool)

Defined in Data.Swagger.Lens

Methods

exclusiveMaximum :: Lens' s (Maybe Bool)

HasParamSchema s (ParamSchema t) => HasExclusiveMinimum s (Maybe Bool)

Defined in Data.Swagger.Lens

Methods

exclusiveMinimum :: Lens' s (Maybe Bool)

HasExternalDocs Operation (Maybe ExternalDocs)

Defined in Data.Swagger.Lens

Methods

externalDocs :: Lens' Operation (Maybe ExternalDocs)

HasExternalDocs Schema (Maybe ExternalDocs)

Defined in Data.Swagger.Lens

Methods

externalDocs :: Lens' Schema (Maybe ExternalDocs)

HasExternalDocs Swagger (Maybe ExternalDocs)

Defined in Data.Swagger.Lens

Methods

externalDocs :: Lens' Swagger (Maybe ExternalDocs)

HasExternalDocs Tag (Maybe ExternalDocs)

Defined in Data.Swagger.Lens

Methods

externalDocs :: Lens' Tag (Maybe ExternalDocs)

HasParamSchema s (ParamSchema t) => HasFormat s (Maybe Format)

Defined in Data.Swagger.Lens

Methods

format :: Lens' s (Maybe Format)

HasGet PathItem (Maybe Operation)

Defined in Data.Swagger.Lens

Methods

get :: Lens' PathItem (Maybe Operation)

HasHead PathItem (Maybe Operation)

Defined in Data.Swagger.Lens

Methods

head_ :: Lens' PathItem (Maybe Operation)

HasHost Swagger (Maybe Host)

Defined in Data.Swagger.Lens

Methods

host :: Lens' Swagger (Maybe Host)

HasParamSchema s (ParamSchema t) => HasItems s (Maybe (SwaggerItems t))

Defined in Data.Swagger.Lens

Methods

items :: Lens' s (Maybe (SwaggerItems t))

HasLicense Info (Maybe License)

Defined in Data.Swagger.Lens

Methods

license :: Lens' Info (Maybe License)

HasParamSchema s (ParamSchema t) => HasMaxItems s (Maybe Integer)

Defined in Data.Swagger.Lens

Methods

maxItems :: Lens' s (Maybe Integer)

HasParamSchema s (ParamSchema t) => HasMaxLength s (Maybe Integer)

Defined in Data.Swagger.Lens

Methods

maxLength :: Lens' s (Maybe Integer)

HasMaxProperties Schema (Maybe Integer)

Defined in Data.Swagger.Lens

Methods

maxProperties :: Lens' Schema (Maybe Integer)

HasParamSchema s (ParamSchema t) => HasMaximum s (Maybe Scientific)

Defined in Data.Swagger.Lens

Methods

maximum_ :: Lens' s (Maybe Scientific)

HasParamSchema s (ParamSchema t) => HasMinItems s (Maybe Integer)

Defined in Data.Swagger.Lens

Methods

minItems :: Lens' s (Maybe Integer)

HasParamSchema s (ParamSchema t) => HasMinLength s (Maybe Integer)

Defined in Data.Swagger.Lens

Methods

minLength :: Lens' s (Maybe Integer)

HasMinProperties Schema (Maybe Integer)

Defined in Data.Swagger.Lens

Methods

minProperties :: Lens' Schema (Maybe Integer)

HasParamSchema s (ParamSchema t) => HasMinimum s (Maybe Scientific)

Defined in Data.Swagger.Lens

Methods

minimum_ :: Lens' s (Maybe Scientific)

HasParamSchema s (ParamSchema t) => HasMultipleOf s (Maybe Scientific)

Defined in Data.Swagger.Lens

Methods

multipleOf :: Lens' s (Maybe Scientific)

HasName Contact (Maybe Text)

Defined in Data.Swagger.Lens

Methods

name :: Lens' Contact (Maybe Text)

HasName NamedSchema (Maybe Text)

Defined in Data.Swagger.Lens

Methods

name :: Lens' NamedSchema (Maybe Text)

HasName Xml (Maybe Text)

Defined in Data.Swagger.Lens

Methods

name :: Lens' Xml (Maybe Text)

HasNamespace Xml (Maybe Text)

Defined in Data.Swagger.Lens

Methods

namespace :: Lens' Xml (Maybe Text)

HasOperationId Operation (Maybe Text)

Defined in Data.Swagger.Lens

Methods

operationId :: Lens' Operation (Maybe Text)

HasOptions PathItem (Maybe Operation)

Defined in Data.Swagger.Lens

Methods

options :: Lens' PathItem (Maybe Operation)

HasPatch PathItem (Maybe Operation)

Defined in Data.Swagger.Lens

Methods

patch :: Lens' PathItem (Maybe Operation)

HasParamSchema s (ParamSchema t) => HasPattern s (Maybe Text)

Defined in Data.Swagger.Lens

Methods

pattern :: Lens' s (Maybe Text)

HasPort Host (Maybe PortNumber)

Defined in Data.Swagger.Lens

Methods

port :: Lens' Host (Maybe PortNumber)

HasPost PathItem (Maybe Operation)

Defined in Data.Swagger.Lens

Methods

post :: Lens' PathItem (Maybe Operation)

HasPrefix Xml (Maybe Text)

Defined in Data.Swagger.Lens

Methods

prefix :: Lens' Xml (Maybe Text)

HasProduces Operation (Maybe MimeList)

Defined in Data.Swagger.Lens

Methods

produces :: Lens' Operation (Maybe MimeList)

HasPut PathItem (Maybe Operation)

Defined in Data.Swagger.Lens

Methods

put :: Lens' PathItem (Maybe Operation)

HasReadOnly Schema (Maybe Bool)

Defined in Data.Swagger.Lens

Methods

readOnly :: Lens' Schema (Maybe Bool)

HasRequired Param (Maybe Bool)

Defined in Data.Swagger.Lens

Methods

required :: Lens' Param (Maybe Bool)

HasSchema Response (Maybe (Referenced Schema))

Defined in Data.Swagger.Lens

Methods

schema :: Lens' Response (Maybe (Referenced Schema))

HasSchemes Operation (Maybe [Scheme])

Defined in Data.Swagger.Lens

Methods

schemes :: Lens' Operation (Maybe [Scheme])

HasSchemes Swagger (Maybe [Scheme])

Defined in Data.Swagger.Lens

Methods

schemes :: Lens' Swagger (Maybe [Scheme])

HasSummary Operation (Maybe Text)

Defined in Data.Swagger.Lens

Methods

summary :: Lens' Operation (Maybe Text)

HasTermsOfService Info (Maybe Text)

Defined in Data.Swagger.Lens

Methods

termsOfService :: Lens' Info (Maybe Text)

HasTitle Schema (Maybe Text)

Defined in Data.Swagger.Lens

Methods

title :: Lens' Schema (Maybe Text)

HasType Header (Maybe (SwaggerType ('SwaggerKindNormal Header)))

Defined in Data.Swagger.Lens

Methods

type_ :: Lens' Header (Maybe (SwaggerType ('SwaggerKindNormal Header)))

HasType NamedSchema (Maybe (SwaggerType ('SwaggerKindSchema :: SwaggerKind Type)))

Defined in Data.Swagger.Lens

Methods

type_ :: Lens' NamedSchema (Maybe (SwaggerType 'SwaggerKindSchema))

HasType ParamOtherSchema (Maybe (SwaggerType ('SwaggerKindParamOtherSchema :: SwaggerKind Type)))

Defined in Data.Swagger.Lens

Methods

type_ :: Lens' ParamOtherSchema (Maybe (SwaggerType 'SwaggerKindParamOtherSchema))

HasType Schema (Maybe (SwaggerType ('SwaggerKindSchema :: SwaggerKind Type)))

Defined in Data.Swagger.Lens

Methods

type_ :: Lens' Schema (Maybe (SwaggerType 'SwaggerKindSchema))

HasParamSchema s (ParamSchema t) => HasUniqueItems s (Maybe Bool)

Defined in Data.Swagger.Lens

Methods

uniqueItems :: Lens' s (Maybe Bool)

HasUrl Contact (Maybe URL)

Defined in Data.Swagger.Lens

Methods

url :: Lens' Contact (Maybe URL)

HasUrl License (Maybe URL)

Defined in Data.Swagger.Lens

Methods

url :: Lens' License (Maybe URL)

HasWrapped Xml (Maybe Bool)

Defined in Data.Swagger.Lens

Methods

wrapped :: Lens' Xml (Maybe Bool)

HasXml Schema (Maybe Xml)

Defined in Data.Swagger.Lens

Methods

xml :: Lens' Schema (Maybe Xml)

Lift a => Lift (Maybe a :: Type)

Defined in Language.Haskell.TH.Syntax

Methods

lift :: Quote m => Maybe a -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => Maybe a -> Code m (Maybe a)

(Selector s, FromJSON a) => RecordFromJSON' arity (S1 s (K1 i (Maybe a) :: Type -> Type))

Defined in Data.Aeson.Types.FromJSON

Methods

recordParseJSON' :: (ConName :* (TypeName :* (Options :* FromArgs arity a0))) -> Object -> Parser (S1 s (K1 i (Maybe a)) a0)

Arbitrary a => Arbitrary (Maybe a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Maybe a)

shrink :: Maybe a -> [Maybe a]

CoArbitrary a => CoArbitrary (Maybe a)

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Maybe a -> Gen b -> Gen b

FromJSON a => FromJSON (Maybe a)

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Maybe a)

parseJSONList :: Value -> Parser [Maybe a]

ToJSON a => ToJSON (Maybe a)

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Maybe a -> Value

toEncoding :: Maybe a -> Encoding

toJSONList :: [Maybe a] -> Value

toEncodingList :: [Maybe a] -> Encoding

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 Monoid to Semigroup.

Since: base-2.1

Defined in GHC.Base

Methods

mempty :: Maybe a

mappend :: Maybe a -> Maybe a -> Maybe a

mconcat :: [Maybe a] -> Maybe a

Semigroup a => Semigroup (Maybe a)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(<>) :: Maybe a -> Maybe a -> Maybe a

sconcat :: NonEmpty (Maybe a) -> Maybe a

stimes :: Integral b => b -> Maybe a -> Maybe a

Generic (Maybe a)

Defined in GHC.Generics

Associated Types

type Rep (Maybe a) :: Type -> Type

Methods

from :: Maybe a -> Rep (Maybe a) x

to :: Rep (Maybe a) x -> Maybe a

SingKind a => SingKind (Maybe a)

Since: base-4.9.0.0

Defined in GHC.Generics

Associated Types

type DemoteRep (Maybe a)

Methods

fromSing :: forall (a0 :: Maybe a). Sing a0 -> DemoteRep (Maybe a)

Read a => Read (Maybe a)

Since: base-2.1

Defined in GHC.Read

Methods

readsPrec :: Int -> ReadS (Maybe a)

readList :: ReadS [Maybe a]

readPrec :: ReadPrec (Maybe a)

readListPrec :: ReadPrec [Maybe a]

Show a => Show (Maybe a)

Since: base-2.1

Defined in GHC.Show

Methods

showsPrec :: Int -> Maybe a -> ShowS

show :: Maybe a -> String

showList :: [Maybe a] -> ShowS

Val a => Val (Maybe a)

Defined in Data.Bson

Methods

val :: Maybe a -> Value

valList :: [Maybe a] -> Value

valMaybe :: Maybe (Maybe a) -> Value

cast' :: Value -> Maybe (Maybe a)

cast'List :: Value -> Maybe [Maybe a]

cast'Maybe :: Value -> Maybe (Maybe (Maybe a))

FromField a => FromField (Maybe a)

Nothing if the Field is empty, Just otherwise.

Defined in Data.Csv.Conversion

Methods

parseField :: Field -> Parser (Maybe a)

ToField a => ToField (Maybe a)

Nothing is encoded as an empty field.

Defined in Data.Csv.Conversion

Methods

toField :: Maybe a -> Field

NFData a => NFData (Maybe a)

Defined in Control.DeepSeq

Methods

rnf :: Maybe a -> ()

ToMaybe (SqlExpr (Maybe a))

Defined in Database.Esqueleto.Experimental.ToMaybe

Associated Types

type ToMaybeT (SqlExpr (Maybe a))

Methods

toMaybe :: SqlExpr (Maybe a) -> ToMaybeT (SqlExpr (Maybe a))

FromPreprocess (SqlExpr (Maybe (Entity val))) => From (SqlExpr (Maybe (Entity val)))

Defined in Database.Esqueleto.Internal.Internal

Methods

from_ :: SqlQuery (SqlExpr (Maybe (Entity val)))

(PersistEntity val, BackendCompatible SqlBackend (PersistEntityBackend val)) => FromPreprocess (SqlExpr (Maybe (Entity val)))

Defined in Database.Esqueleto.Internal.Internal

Methods

fromPreprocess :: SqlQuery (PreprocessedFrom (SqlExpr (Maybe (Entity val))))

SqlString a => SqlString (Maybe a)

Since: esqueleto-2.4.0

Defined in Database.Esqueleto.Internal.Internal

Eq a => Eq (Maybe a)

Since: base-2.1

Defined in GHC.Maybe

Methods

(==) :: Maybe a -> Maybe a -> Bool

(/=) :: Maybe a -> Maybe a -> Bool

Ord a => Ord (Maybe a)

Since: base-2.1

Defined in GHC.Maybe

Methods

compare :: Maybe a -> Maybe a -> Ordering

(<) :: Maybe a -> Maybe a -> Bool

(<=) :: Maybe a -> Maybe a -> Bool

(>) :: Maybe a -> Maybe a -> Bool

(>=) :: Maybe a -> Maybe a -> Bool

max :: Maybe a -> Maybe a -> Maybe a

min :: Maybe a -> Maybe a -> Maybe a

Hashable a => Hashable (Maybe a)

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Maybe a -> Int

hash :: Maybe a -> Int

FromHttpApiData a => FromHttpApiData (Maybe a)

>>> parseUrlPiece "Just 123" :: Either Text (Maybe Int)
Right (Just 123)

Defined in Web.Internal.HttpApiData

Methods

parseUrlPiece :: Text -> Either Text (Maybe a)

parseHeader :: ByteString -> Either Text (Maybe a)

parseQueryParam :: Text -> Either Text (Maybe a)

ToHttpApiData a => ToHttpApiData (Maybe a)

>>> toUrlPiece (Just "Hello")
"just Hello"

Defined in Web.Internal.HttpApiData

Methods

toUrlPiece :: Maybe a -> Text

toEncodedUrlPiece :: Maybe a -> Builder

toHeader :: Maybe a -> ByteString

toQueryParam :: Maybe a -> Text

At (Maybe a)

Defined in Control.Lens.At

Methods

at :: Index (Maybe a) -> Lens' (Maybe a) (Maybe (IxValue (Maybe a)))

Ixed (Maybe a)

Defined in Control.Lens.At

Methods

ix :: Index (Maybe a) -> Traversal' (Maybe a) (IxValue (Maybe a))

MonoFoldable (Maybe a)

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Maybe a) -> m) -> Maybe a -> m

ofoldr :: (Element (Maybe a) -> b -> b) -> b -> Maybe a -> b

ofoldl' :: (a0 -> Element (Maybe a) -> a0) -> a0 -> Maybe a -> a0

otoList :: Maybe a -> [Element (Maybe a)]

oall :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool

oany :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool

onull :: Maybe a -> Bool

olength :: Maybe a -> Int

olength64 :: Maybe a -> Int64

ocompareLength :: Integral i => Maybe a -> i -> Ordering

otraverse_ :: Applicative f => (Element (Maybe a) -> f b) -> Maybe a -> f ()

ofor_ :: Applicative f => Maybe a -> (Element (Maybe a) -> f b) -> f ()

omapM_ :: Applicative m => (Element (Maybe a) -> m ()) -> Maybe a -> m ()

oforM_ :: Applicative m => Maybe a -> (Element (Maybe a) -> m ()) -> m ()

ofoldlM :: Monad m => (a0 -> Element (Maybe a) -> m a0) -> a0 -> Maybe a -> m a0

ofoldMap1Ex :: Semigroup m => (Element (Maybe a) -> m) -> Maybe a -> m

ofoldr1Ex :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Element (Maybe a)

ofoldl1Ex' :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Element (Maybe a)

headEx :: Maybe a -> Element (Maybe a)

lastEx :: Maybe a -> Element (Maybe a)

unsafeHead :: Maybe a -> Element (Maybe a)

unsafeLast :: Maybe a -> Element (Maybe a)

maximumByEx :: (Element (Maybe a) -> Element (Maybe a) -> Ordering) -> Maybe a -> Element (Maybe a)

minimumByEx :: (Element (Maybe a) -> Element (Maybe a) -> Ordering) -> Maybe a -> Element (Maybe a)

oelem :: Element (Maybe a) -> Maybe a -> Bool

onotElem :: Element (Maybe a) -> Maybe a -> Bool

MonoFunctor (Maybe a)

Defined in Data.MonoTraversable

Methods

omap :: (Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Maybe a

MonoPointed (Maybe a)

Defined in Data.MonoTraversable

Methods

opoint :: Element (Maybe a) -> Maybe a

MonoTraversable (Maybe a)

Defined in Data.MonoTraversable

Methods

otraverse :: Applicative f => (Element (Maybe a) -> f (Element (Maybe a))) -> Maybe a -> f (Maybe a)

omapM :: Applicative m => (Element (Maybe a) -> m (Element (Maybe a))) -> Maybe a -> m (Maybe a)

At (Maybe a)

Defined in Optics.At.Core

Methods

at :: Index (Maybe a) -> Lens' (Maybe a) (Maybe (IxValue (Maybe a)))

Ixed (Maybe a)

Defined in Optics.At.Core

Associated Types

type IxKind (Maybe a)

Methods

ix :: Index (Maybe a) -> Optic' (IxKind (Maybe a)) NoIx (Maybe a) (IxValue (Maybe a))

PersistField a => PersistField (Maybe a)

Defined in Database.Persist.Class.PersistField

Methods

toPersistValue :: Maybe a -> PersistValue

fromPersistValue :: PersistValue -> Either Text (Maybe a)

PersistFieldSql a => PersistFieldSql (Maybe a)

Defined in Database.Persist.Sql.Class

Methods

sqlType :: Proxy (Maybe a) -> SqlType

RawSql a => RawSql (Maybe a)

Since: persistent-1.0.1

Defined in Database.Persist.Sql.Class

Methods

rawSqlCols :: (Text -> Text) -> Maybe a -> (Int, [Text])

rawSqlColCountReason :: Maybe a -> String

rawSqlProcessRow :: [PersistValue] -> Either Text (Maybe a)

MongoRegexSearchable rs => MongoRegexSearchable (Maybe rs)

Defined in Database.Persist.MongoDB

ToSchema a => ToSchema (Maybe a)

Defined in Data.Swagger.Internal.Schema

Methods

declareNamedSchema :: Proxy (Maybe a) -> Declare (Definitions Schema) NamedSchema

SingI ('Nothing :: Maybe a)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

sing :: Sing 'Nothing

PersistEntity a => SqlSelect (SqlExpr (Maybe (Entity a))) (Maybe (Entity a))

You may return a possibly-NULL Entity from a select query.

Defined in Database.Esqueleto.Internal.Internal

Methods

sqlSelectCols :: IdentInfo -> SqlExpr (Maybe (Entity a)) -> (Builder, [PersistValue])

sqlSelectColCount :: Proxy (SqlExpr (Maybe (Entity a))) -> Int

sqlSelectProcessRow :: [PersistValue] -> Either Text (Maybe (Entity a))

sqlInsertInto :: IdentInfo -> SqlExpr (Maybe (Entity a)) -> (Builder, [PersistValue])

HasDefault (ParamSchema t) (Maybe Value)

Defined in Data.Swagger.Lens

Methods

default_ :: Lens' (ParamSchema t) (Maybe Value)

HasEnum (ParamSchema t) (Maybe [Value])

Defined in Data.Swagger.Lens

Methods

enum_ :: Lens' (ParamSchema t) (Maybe [Value])

HasExclusiveMaximum (ParamSchema t) (Maybe Bool)

Defined in Data.Swagger.Lens

Methods

exclusiveMaximum :: Lens' (ParamSchema t) (Maybe Bool)

HasExclusiveMinimum (ParamSchema t) (Maybe Bool)

Defined in Data.Swagger.Lens

Methods

exclusiveMinimum :: Lens' (ParamSchema t) (Maybe Bool)

HasFormat (ParamSchema t) (Maybe Format)

Defined in Data.Swagger.Lens

Methods

format :: Lens' (ParamSchema t) (Maybe Format)

HasItems (ParamSchema t) (Maybe (SwaggerItems t))

Defined in Data.Swagger.Lens

Methods

items :: Lens' (ParamSchema t) (Maybe (SwaggerItems t))

HasMaxItems (ParamSchema t) (Maybe Integer)

Defined in Data.Swagger.Lens

Methods

maxItems :: Lens' (ParamSchema t) (Maybe Integer)

HasMaxLength (ParamSchema t) (Maybe Integer)

Defined in Data.Swagger.Lens

Methods

maxLength :: Lens' (ParamSchema t) (Maybe Integer)

HasMaximum (ParamSchema t) (Maybe Scientific)

Defined in Data.Swagger.Lens

Methods

maximum_ :: Lens' (ParamSchema t) (Maybe Scientific)

HasMinItems (ParamSchema t) (Maybe Integer)

Defined in Data.Swagger.Lens

Methods

minItems :: Lens' (ParamSchema t) (Maybe Integer)

HasMinLength (ParamSchema t) (Maybe Integer)

Defined in Data.Swagger.Lens

Methods

minLength :: Lens' (ParamSchema t) (Maybe Integer)

HasMinimum (ParamSchema t) (Maybe Scientific)

Defined in Data.Swagger.Lens

Methods

minimum_ :: Lens' (ParamSchema t) (Maybe Scientific)

HasMultipleOf (ParamSchema t) (Maybe Scientific)

Defined in Data.Swagger.Lens

Methods

multipleOf :: Lens' (ParamSchema t) (Maybe Scientific)

HasPattern (ParamSchema t) (Maybe Pattern)

Defined in Data.Swagger.Lens

Methods

pattern :: Lens' (ParamSchema t) (Maybe Pattern)

HasType (ParamSchema t) (Maybe (SwaggerType t))

Defined in Data.Swagger.Lens

Methods

type_ :: Lens' (ParamSchema t) (Maybe (SwaggerType t))

HasUniqueItems (ParamSchema t) (Maybe Bool)

Defined in Data.Swagger.Lens

Methods

uniqueItems :: Lens' (ParamSchema t) (Maybe Bool)

SingI a2 => SingI ('Just a2 :: Maybe a1)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

sing :: Sing ('Just a2)

a ~ a' => FindGen ('Match 'INCOHERENT) ('S _fg _coh '(con, i, 'Just s)) (FieldGen s a) gs a'

Matching custom generator for field s.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('Match 'INCOHERENT), Proxy ('S _fg _coh '(con, i, 'Just s)), FullGenListOf ('S _fg _coh '(con, i, 'Just s))) -> FieldGen s a -> gs -> Gen a'

a ~ a' => FindGen ('Match 'INCOHERENT) ('S _fg _coh '('Just c, i, s)) (ConstrGen c i a) gs a'

Matching custom generator for i-th field of constructor c.

Defined in Generic.Random.Internal.Generic

Methods

findGen :: (Proxy ('Match 'INCOHERENT), Proxy ('S _fg _coh '('Just c, i, s)), FullGenListOf ('S _fg _coh '('Just c, i, s))) -> ConstrGen c i a -> gs -> Gen a'

ToSchema c => GToSchema (K1 i (Maybe c) :: Type -> Type)

Defined in Data.Swagger.Internal.Schema

Methods

gdeclareNamedSchema :: SchemaOptions -> Proxy (K1 i (Maybe c)) -> Schema -> Declare (Definitions Schema) NamedSchema

(Selector s, ToSchema c) => GToSchema (S1 s (K1 i (Maybe c) :: Type -> Type))

Optional record fields.

Defined in Data.Swagger.Internal.Schema

Methods

gdeclareNamedSchema :: SchemaOptions -> Proxy (S1 s (K1 i (Maybe c))) -> Schema -> Declare (Definitions Schema) NamedSchema

type Failure Maybe

Defined in Basement.Monad

type Failure Maybe = ()

type Rep1 Maybe

Since: base-4.6.0.0

Defined in GHC.Generics

type Rep1 Maybe = D1 ('MetaData "Maybe" "GHC.Maybe" "base" 'False) (C1 ('MetaCons "Nothing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Just" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))

type StM Maybe a

Defined in Control.Monad.Trans.Control

type StM Maybe a = a

type DemoteRep (Maybe a)

Defined in GHC.Generics

type DemoteRep (Maybe a) = Maybe (DemoteRep a)

type Rep (Maybe a)

Since: base-4.6.0.0

Defined in GHC.Generics

type Rep (Maybe a) = D1 ('MetaData "Maybe" "GHC.Maybe" "base" 'False) (C1 ('MetaCons "Nothing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Just" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

data Sing (b :: Maybe a)

Defined in GHC.Generics

data Sing (b :: Maybe a) where

• SNothing :: forall {a}. Sing ('Nothing :: Maybe a)
• SJust :: forall {a} (a1 :: a). Sing a1 -> Sing ('Just a1)

type ToMaybeT (SqlExpr (Maybe a))

Defined in Database.Esqueleto.Experimental.ToMaybe

type ToMaybeT (SqlExpr (Maybe a)) = SqlExpr (Maybe a)

type Code (Maybe a)

Defined in Generics.SOP.Instances

type Code (Maybe a) = '['[] :: [Type], '[a]]

type DatatypeInfoOf (Maybe a)

Defined in Generics.SOP.Instances

type DatatypeInfoOf (Maybe a) = 'ADT "GHC.Maybe" "Maybe" '['Constructor "Nothing", 'Constructor "Just"] '['[] :: [StrictnessInfo], '['StrictnessInfo 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy]]

type Index (Maybe a)

Defined in Control.Lens.At

type Index (Maybe a) = ()

type IxValue (Maybe a)

Defined in Control.Lens.At

type IxValue (Maybe a) = a

type Element (Maybe a)

Defined in Data.MonoTraversable

type Element (Maybe a) = a

type Index (Maybe a)

Defined in Optics.At.Core

type Index (Maybe a) = ()

type IxKind (Maybe a)

Defined in Optics.At.Core

type IxKind (Maybe a) = An_AffineTraversal

type IxValue (Maybe a)

Defined in Optics.At.Core

type IxValue (Maybe a) = a

maybeToList :: Maybe a -> [a]

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 Text.Read ( readMaybe )
>>> sum $ maybeToList (readMaybe "3")
3
>>> sum $ maybeToList (readMaybe "")
0

maybe :: b -> (a -> b) -> Maybe a -> b

The maybe function takes a default value, a function, and a Maybe value. If the Maybe value is Nothing, the function returns the default value. Otherwise, it applies the function to the value inside the Just and returns the result.

Examples

Basic usage:

>>> maybe False odd (Just 3)
True

>>> maybe False odd Nothing
False

Read an integer from a string using readMaybe. If we succeed, return twice the integer; that is, apply (*2) to it. If instead we fail to parse an integer, return 0 by default:

>>> import Text.Read ( readMaybe )
>>> maybe 0 (*2) (readMaybe "5")
10
>>> maybe 0 (*2) (readMaybe "")
0

Apply show to a Maybe Int. If we have Just n, we want to show the underlying Int n. But if we have Nothing, we return the empty string instead of (for example) "Nothing":

>>> maybe "" show (Just 5)
"5"
>>> maybe "" show Nothing
""

mapMaybe :: (a -> Maybe b) -> [a] -> [b]

The mapMaybe function is a version of map which can throw out elements. In particular, the functional argument returns something of type Maybe b. If this is Nothing, no element is added on to the result list. If it is Just b, then b is included in the result list.

Examples

Using mapMaybe f x is a shortcut for catMaybes $ map f x in most cases:

>>> import Text.Read ( readMaybe )
>>> let readMaybeInt = readMaybe :: String -> Maybe Int
>>> mapMaybe readMaybeInt ["1", "Foo", "3"]
[1,3]
>>> catMaybes $ map readMaybeInt ["1", "Foo", "3"]
[1,3]

If we map the Just constructor, the entire list should be returned:

>>> mapMaybe Just [1,2,3]
[1,2,3]

listToMaybe :: [a] -> Maybe a

The listToMaybe function returns Nothing on an empty list or Just a where a is the first element of the list.

Examples

Basic usage:

>>> listToMaybe []
Nothing

>>> listToMaybe [9]
Just 9

>>> listToMaybe [1,2,3]
Just 1

Composing maybeToList with listToMaybe should be the identity on singleton/empty lists:

>>> maybeToList $ listToMaybe [5]
[5]
>>> maybeToList $ listToMaybe []
[]

But not on lists with more than one element:

>>> maybeToList $ listToMaybe [1,2,3]
[1]

isNothing :: Maybe a -> Bool

The isNothing function returns True iff its argument is Nothing.

Examples

Basic usage:

>>> isNothing (Just 3)
False

>>> isNothing (Just ())
False

>>> isNothing Nothing
True

Only the outer constructor is taken into consideration:

>>> isNothing (Just Nothing)
False

isJust :: Maybe a -> Bool

The isJust function returns True iff its argument is of the form Just _.

Examples

Basic usage:

>>> isJust (Just 3)
True

>>> isJust (Just ())
True

>>> isJust Nothing
False

Only the outer constructor is taken into consideration:

>>> isJust (Just Nothing)
True

fromMaybe :: a -> Maybe a -> a

The fromMaybe function takes a default value and a Maybe value. If the Maybe is Nothing, it returns the default value; otherwise, it returns the value contained in the Maybe.

Examples

Basic usage:

>>> fromMaybe "" (Just "Hello, World!")
"Hello, World!"

>>> fromMaybe "" Nothing
""

Read an integer from a string using readMaybe. If we fail to parse an integer, we want to return 0 by default:

>>> import Text.Read ( readMaybe )
>>> fromMaybe 0 (readMaybe "5")
5
>>> fromMaybe 0 (readMaybe "")
0

catMaybes :: [Maybe a] -> [a]

The catMaybes function takes a list of Maybes and returns a list of all the Just values.

Examples

Basic usage:

>>> catMaybes [Just 1, Nothing, Just 3]
[1,3]

When constructing a list of Maybe values, catMaybes can be used to return all of the "success" results (if the list is the result of a map, then mapMaybe would be more appropriate):

>>> import Text.Read ( readMaybe )
>>> [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
[Just 1,Nothing,Just 3]
>>> catMaybes $ [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
[1,3]

note :: a -> Maybe b -> Either a b

Tag the Nothing value of a Maybe

hush :: Either a b -> Maybe b

Suppress the Left value of an Either