Opaleye.MaybeFields

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

The Opaleye analogue of Nothing.

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 Just. Equivalent to pure.

Convert NULL to nothingFields and non-NULL to a justFields

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

The Opaleye analogue of fromMaybe

The Opaleye analogue of maybe

Convert nothingFields to NULL to a justFields to non-NULL

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]
> runSelectI conn (optional (values l1))
[Just "one", Just "two", Just "three"]

> let l2 = [] :: [Field SqlText]
> runSelectI conn (optional (values l2))
[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)

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

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

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