The Opaleye analogue of Maybe

The Opaleye analogue of Nothing.

The Opaleye analogue of Just. Equivalent to pure.

The Opaleye analogue of fromMaybe

The Opaleye analogue of maybe

The Opaleye analogue of maybeToList

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

The Opaleye analogue of catMaybes

NB Opaleye exports Opaleye.Table.optional from the top level. If you want this optional you will have to import it from this module.

Convenient access to lateral left/right join functionality. Performs a LATERAL LEFT JOIN under the hood and has behaviour equivalent to the following Haskell function:

optional :: [a] -> [Maybe a]
optional q = case q of
    [] -> [Nothing]
    xs -> map Just xs

That is, if q :: SelectArr i a returns no rows, optional q :: SelectArr i (MaybeFields a) returns exactly one "Nothing" row. Otherwise, optional q returns exactly the rows of q wrapped in "Just". For example,

> let l1 = ["one", "two", "three"] :: [Field SqlText]
> runSelect conn (optional (valuesSafe l1)) :: IO [Maybe String]
[Just "one", Just "two", Just "three"]

> let l2 = [] :: [Field SqlText]
> runSelect conn (optional (valuesSafe l2)) :: IO [Maybe String]
[Nothing]

optionalRestrict is a special case of optional and could be written in terms of optional as follows (except that optionalRestrict doesn't use LATERAL under the hood and optional does).

optionalRestrict q = optional $ proc cond -> do
  a <- q -< ()
  restrict -< cond a
  returnA -< a

traverseMaybeFields is analogous to Haskell's traverse :: (a -> [b]) -> Maybe a -> [Maybe b]. In particular, traverse has the following definition that generalises to traverseMaybeFields:

• traverse _ Nothing = pure Nothing

• traverse f (Just x) = fmap Just (f x)