Opaleye.Internal.MaybeFields

Documentation

data MaybeFields fields

The Opaleye analogue of Maybe. A value of type MaybeFields a either contains a value of type a, or it contains nothing.

Constructors

MaybeFields

Fields

• mfPresent :: Column SqlBool
• mfFields :: fields

Instances

Applicative MaybeFields

Defined in Opaleye.Internal.MaybeFields

Methods

pure :: a -> MaybeFields a

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

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

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

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

Functor MaybeFields

Defined in Opaleye.Internal.MaybeFields

Methods

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

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

Monad MaybeFields

Defined in Opaleye.Internal.MaybeFields

Methods

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

(>>) :: MaybeFields a -> MaybeFields b -> MaybeFields b

return :: a -> MaybeFields a

Default (WithNulls Binaryspec) a b => Default Binaryspec (MaybeFields a) (MaybeFields b)

Defined in Opaleye.Internal.MaybeFields

Methods

def :: Binaryspec (MaybeFields a) (MaybeFields b)

(Default ToFields a b, Default Nullspec a b) => Default ToFields (Maybe a) (MaybeFields b)

Defined in Opaleye.Internal.MaybeFields

Methods

def :: ToFields (Maybe a) (MaybeFields b)

Default (WithNulls Distinctspec) a b => Default Distinctspec (MaybeFields a) (MaybeFields b)

Defined in Opaleye.Internal.Distinct

Methods

def :: Distinctspec (MaybeFields a) (MaybeFields b)

Default EqPP a b => Default EqPP (MaybeFields a) (MaybeFields b)

Defined in Opaleye.Internal.MaybeFields

Methods

def :: EqPP (MaybeFields a) (MaybeFields b)

Default IfPP a b => Default IfPP (MaybeFields a) (MaybeFields b)

Defined in Opaleye.Internal.MaybeFields

Methods

def :: IfPP (MaybeFields a) (MaybeFields b)

Default FromFields fields haskells => Default FromFields (MaybeFields fields) (Maybe haskells)

Defined in Opaleye.Internal.MaybeFields

Methods

def :: FromFields (MaybeFields fields) (Maybe haskells)

Default Unpackspec a b => Default Unpackspec (MaybeFields a) (MaybeFields b)

Defined in Opaleye.Internal.MaybeFields

Methods

def :: Unpackspec (MaybeFields a) (MaybeFields b)

Default Valuesspec a b => Default Valuesspec (MaybeFields a) (MaybeFields b)

Defined in Opaleye.Internal.MaybeFields

Methods

def :: Valuesspec (MaybeFields a) (MaybeFields b)

(Default (Inferrable FromFields) fields haskells, Maybe haskells ~ maybe_haskells) => Default (Inferrable FromFields) (MaybeFields fields) maybe_haskells

Defined in Opaleye.Internal.MaybeFields

Methods

def :: Inferrable FromFields (MaybeFields fields) maybe_haskells

nothingFields :: Default Nullspec a a => MaybeFields a

The Opaleye analogue of Nothing.

nothingFieldsOfTypeOf :: a -> MaybeFields a

The Opaleye analogue of const Nothing. Can be useful to avoid type inference problems, because it doesn't pick up a type class constraint.

justFields :: a -> MaybeFields a

The Opaleye analogue of Just. Equivalent to pure.

maybeFields :: Default IfPP b b => b -> (a -> b) -> MaybeFields a -> b

The Opaleye analogue of maybe

matchMaybe :: Default IfPP b b => MaybeFields a -> (Maybe a -> b) -> b

Use a Haskell \case expression to pattern match on a MaybeFields.

example :: MaybeFields (Field SqlInt4) -> Field SqlInt4
example mf = matchMaybe mf $ \case
  Nothing -> 0
  Just x  -> x * 100

fromMaybeFields :: Default IfPP b b => b -> MaybeFields b -> b

The Opaleye analogue of fromMaybe

maybeFieldsToSelect :: SelectArr (MaybeFields a) a

The Opaleye analogue of maybeToList. Unless you are using arrow notation you'll probably find catMaybeFields easier to use.

catMaybeFields :: SelectArr i (MaybeFields a) -> SelectArr i a

The Opaleye analogue of catMaybes. Most commonly you will want to use this at type

catMaybeFields :: Select (MaybeFields a) -> Select a

maybeFieldsExplicit :: IfPP b b' -> b -> (a -> b) -> MaybeFields a -> b'

fromMaybeFieldsExplicit :: IfPP b b -> b -> MaybeFields b -> b

nothingFieldsExplicit :: Nullspec a b -> MaybeFields b

traverseMaybeFields :: SelectArr a b -> SelectArr (MaybeFields a) (MaybeFields b)

optional :: SelectArr i a -> SelectArr i (MaybeFields a)

optionalInternal :: (FieldNullable SqlBool -> a -> r) -> Select a -> Select r

lateralLeftJoinOptional :: SelectArr i a -> SelectArr i b -> ((a, b) -> Field SqlBool) -> SelectArr i (a, MaybeFields b)

An example to demonstrate how the functionality of (lateral) LEFT JOIN can be recovered using optional.

optionalRestrictOptional :: Select a -> SelectArr (a -> Field SqlBool) (MaybeFields a)

An example to demonstrate how the functionality of optionalRestrict can be recovered using optional.

nullableToMaybeFields :: FieldNullable a -> MaybeFields (Field a)

Convert NULL to nothingFields and non-NULL to a justFields

maybeFieldsToNullable :: MaybeFields (Field a) -> FieldNullable a

Convert nothingFields to NULL to a justFields to non-NULL

fromFieldsMaybeFields :: FromFields fields haskells -> FromFields (MaybeFields fields) (Maybe haskells)

productProfunctorMaybeFields :: ProductProfunctor p => p (Field SqlBool) (Field SqlBool) -> p a b -> p (MaybeFields a) (MaybeFields b)

This is not safe in general because it relies on p not doing anything observable with the as if mfPresent is false. In particular, it won't work for Distinctspec because it does indeed look at the mfFields to check distinctness.

nullspecMaybeFields :: Nullspec a b -> Nullspec (MaybeFields a) (MaybeFields b)

unpackspecMaybeFields :: Unpackspec a b -> Unpackspec (MaybeFields a) (MaybeFields b)

valuesspecMaybeFields :: Valuesspec a b -> Valuesspec (MaybeFields a) (MaybeFields b)

toFieldsMaybeFields :: Nullspec a b -> ToFields a b -> ToFields (Maybe a) (MaybeFields b)

ifPPMaybeFields :: IfPP a b -> IfPP (MaybeFields a) (MaybeFields b)

eqPPMaybeFields :: EqPP a b -> EqPP (MaybeFields a) (MaybeFields b)

unWithNulls :: ProductProfunctor p => p (Field SqlBool) (Field SqlBool) -> WithNulls p a b -> p (MaybeFields a) (MaybeFields b)

This is only safe if d is OK with having nulls passed through it when they claim to be non-null.

newtype WithNulls p a b

Constructors

WithNulls (p (MaybeFields a) b)

Instances

ProductProfunctor p => ProductProfunctor (WithNulls p)

Defined in Opaleye.Internal.MaybeFields

Methods

purePP :: b -> WithNulls p a b

(****) :: WithNulls p a (b -> c) -> WithNulls p a b -> WithNulls p a c

empty :: WithNulls p () ()

(***!) :: WithNulls p a b -> WithNulls p a' b' -> WithNulls p (a, a') (b, b')

SumProfunctor p => SumProfunctor (WithNulls p)

Defined in Opaleye.Internal.MaybeFields

Methods

(+++!) :: WithNulls p a b -> WithNulls p a' b' -> WithNulls p (Either a a') (Either b b')

Profunctor p => Profunctor (WithNulls p)

Defined in Opaleye.Internal.MaybeFields

Methods

dimap :: (a -> b) -> (c -> d) -> WithNulls p b c -> WithNulls p a d

lmap :: (a -> b) -> WithNulls p b c -> WithNulls p a c

rmap :: (b -> c) -> WithNulls p a b -> WithNulls p a c

(#.) :: forall a b c q. Coercible c b => q b c -> WithNulls p a b -> WithNulls p a c

(.#) :: forall a b c q. Coercible b a => WithNulls p b c -> q a b -> WithNulls p a c

(Profunctor p, IsSqlType a, Default p (Field_ n a) (Field_ n a)) => Default (WithNulls p) (Field_ n a) (Field_ n a)

Defined in Opaleye.Internal.MaybeFields

Methods

def :: WithNulls p (Field_ n a) (Field_ n a)

ProductProfunctor p => Applicative (WithNulls p a)

Defined in Opaleye.Internal.MaybeFields

Methods

pure :: a0 -> WithNulls p a a0

(<*>) :: WithNulls p a (a0 -> b) -> WithNulls p a a0 -> WithNulls p a b

liftA2 :: (a0 -> b -> c) -> WithNulls p a a0 -> WithNulls p a b -> WithNulls p a c

(*>) :: WithNulls p a a0 -> WithNulls p a b -> WithNulls p a b

(<*) :: WithNulls p a a0 -> WithNulls p a b -> WithNulls p a a0

Profunctor p => Functor (WithNulls p a)

Defined in Opaleye.Internal.MaybeFields

Methods

fmap :: (a0 -> b) -> WithNulls p a a0 -> WithNulls p a b

(<$) :: a0 -> WithNulls p a b -> WithNulls p a a0

mapMaybeFieldsWithNulls :: ProductProfunctor p => p (Field SqlBool) (Field SqlBool) -> WithNulls p a b -> WithNulls p (MaybeFields a) (MaybeFields b)

This is only safe if b is OK with having nulls passed through it when they claim to be non-null.

withNullsField :: (IsSqlType a, Profunctor p) => p (Field_ n a) (Field_ n a) -> WithNulls p (Field_ n a) (Field_ n a)

This is only safe if col is OK with having nulls passed through it when they claim to be non-null.

binaryspecMaybeFields :: WithNulls Binaryspec a b -> Binaryspec (MaybeFields a) (MaybeFields b)

Orphan instances

(Default (Inferrable ToFields) a b, Default Nullspec a b, MaybeFields b ~ maybeFields_b) => Default (Inferrable ToFields) (Maybe a) maybeFields_b

Methods

def :: Inferrable ToFields (Maybe a) maybeFields_b