{-# LANGUAGE DeriveAnyClass        #-}
{-# LANGUAGE DeriveDataTypeable    #-}
{-# LANGUAGE DeriveGeneric         #-}
{-# LANGUAGE DeriveTraversable     #-}
{-# LANGUAGE DerivingStrategies    #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE UndecidableInstances  #-}

-- | This module provides a `Defaultable` type constructor for extending
-- `Map`-like types with a valid `Applicative` and `Alternative` instance.  If
--  you're looking for an \"`Applicative` `Map`\" then you are in the right
--  place!
--
--  The `Defaultable` type constructor can be used to wrap any `Map`-like, such
--  as @"Data.Map".`Data.Map.Map`@ or @"Data.HashMap".`Data.HashMap.HashMap`@.
--
--  For convenience, this module also includes a concrete API wrapping
--  @"Data.Map".`Data.Map.Map`@ since that's the most common case.  If you
--  are interested in a more general API that works with other `Map` types then
--  check out the "Defaultable.Map.Generalized" module.
--
--  The `Applicative` instance enables the use of the @ApplicativeDo@ language
--  extension.  For example, suppose that you created the following three
--  `Defaultable` `Map`s:
--
-- @
-- firstNames, lastNames, handles :: `Defaultable` (`Map` `Int`) `String`
-- firstNames = `fromList` [(0, \"Gabriella\"    ), (1, \"Oscar\"), (2, \"Edgar\"    )                  ]
-- lastNames  = `fromList` [(0, \"Gonzalez\"     ),               (2, \"Codd\"     ), (3, \"Bryant\"   )]
-- handles    = `fromList` [(0, \"GabriellaG439\"), (1, \"posco\"),                   (3, \"avibryant\")]
-- @
--
--  Then you can use @ApplicativeDo@ notation to create an \"inner join\" of
--  these various maps, like this:
--
-- >>> :set -XApplicativeDo
-- >>> do firstName <- firstNames; lastName <- lastNames; return (firstName, lastName)
-- Defaultable (fromList [(0,("Gabriella","Gonzalez")),(2,("Edgar","Codd"))]) Nothing
--
-- … and you can join as many of these maps as you want by adding statements
-- to these @ApplicativeDo@ blocks:
--
-- @
-- {-# LANGUAGE ApplicativeDo #-}
--
-- innerJoins :: `Defaultable` (`Map` Int) (`String`, `String`, `String`)
-- innerJoins = do
--     firstName <- firstNames
--     lastName  <- lastNames
--     handles   <- handles
--     return (firstName, lastName, handles)
-- @
--
-- >>> innerJoins
-- Defaultable (fromList [(0,("Gabriella","Gonzalez","GabriellaG439"))]) Nothing
--
--  The `Alternative` instance for `Defaultable` is also important, too, because
--  you can use `Alternative` operations to create \"left/right joins\" and
--  something similar to an outer join, like this:
--
-- @
-- leftJoin :: `Defaultable` (`Map` `Int`) (`String`, `Maybe` `String`)
-- leftJoin = do
--     firstName <- firstNames
--     lastName  <- `Control.Applicative.optional` lastNames
--     return (firstName, lastName)
--
-- rightJoin :: `Defaultable` (`Map` `Int`) (`Maybe` `String`, `String`)
-- rightJoin = do
--     firstName <- `Control.Applicative.optional` firstNames
--     lastName  <- lastNames
--     return (firstName, lastName)
--
-- 
-- similarToOuterJoin :: `Defaultable` (`Map` `Int`) (`Maybe` `String`, `Maybe` `String`)
-- similarToOuterJoin = do
--     firstName <- `Control.Applicative.optional` firstNames
--     lastName  <- `Control.Applicative.optional` lastNames
--     return (firstName, lastName)
-- @
--
-- >>> leftJoin
-- Defaultable (fromList [(0,("Gabriella",Just "Gonzalez")),(1,("Oscar",Nothing)),(2,("Edgar",Just "Codd"))]) Nothing
-- >>> rightJoin
-- Defaultable (fromList [(0,(Just "Gabriella","Gonzalez")),(2,(Just "Edgar","Codd")),(3,(Nothing,"Bryant"))]) Nothing
-- >>> similarToOuterJoin
-- Defaultable (fromList [(0,(Just "Gabriella",Just "Gonzalez")),(1,(Just "Oscar",Nothing)),(2,(Just "Edgar",Just "Codd")),(3,(Nothing,Just "Bryant"))]) (Just (Nothing,Nothing))
-- 
-- You can also do more interesting multiway joins where any combiination of
-- the inputs may be `Control.Applicative.optional`:
-- 
-- @
-- complexJoin :: `Defaultable` (`Map` `Int`) (`Maybe` `String`, `String`, `Maybe` `String`)
-- complexJoin = do
--     firstName <- `Control.Applicative.optional` firstNames
--     lastName  <- lastNames
--     handle    <- `Control.Applicative.optional` handles
--     return (firstName, lastName, handle)
-- @
--
-- >>> complexJoin
-- Defaultable (fromList [(0,(Just "Gabriella","Gonzalez",Just "GabrielG439")),(2,(Just "Edgar","Codd",Nothing)),(3,(Nothing,"Bryant",Just "avibryant"))]) Nothing

module Defaultable.Map
    ( -- * Comparison
      -- $comparison

      -- * Type
      Defaultable(..)
    , Map

      -- * Construction
    , fromMap
    , singleton
    , fromList
    , insert
    , withDefault

      -- * Query
    , lookup
    , toMap
    , toDefault
    ) where

import Control.Applicative (liftA2, Alternative(..))
import Control.DeepSeq (NFData)
import Data.Data (Data)
import Data.Functor.Alt (Alt(..))
import Data.Functor.Apply (Apply(..))
import Data.Map (Map)
import GHC.Generics (Generic, Generic1)
import Prelude hiding (lookup)

import qualified Data.Map as Map

-- $comparison
--
-- This package is similar to the
-- <https://hackage.haskell.org/package/total-map total-map package>,
-- which also provides an \"`Applicative` `Map`\" type.  However, there are a
-- couple of differences.
--
-- The first difference is that this package does not require you to supply a
-- default value in order to get a valid `Applicative` instance.  In other
-- words the default value is optional.  In contrast, the @total-map@ package
-- requires you to supply a default value.  That means that the `lookup`
-- function from this package can return `Nothing`, whereas the analogous
-- @(!)@ operator from the @total-map@ package always returns a value.
--
-- However, the benefit of this tradeoff is that this package can provide an
-- `Alternative` instance for `Defaultable`, whereas the @total-map@ package
-- does not have a valid `Alternative` instance.  Furthermore, the `Alternative`
-- instance enables support for left\/right\/\"outer\" joins as noted above.
--
-- Also, sometimes you just need an `Applicative` `Map` without a default value.
--
-- The other key difference compared to @total-map@ is that this package works
-- with `Map`-like types other than @"Data.Map".`Data.Map.Map`@, whereas
-- @total-map@ is hard-coded to @"Data.Map".`Data.Map.Map`@.  The only caveat
-- is that if you use the `Defaultable` type to wrap other `Map`-like types
-- (such as @"Data.HashMap".`Data.HashMap.HashMap`@) then you need to create
-- your own utility functions, such as a new `lookup` function for a
-- `Defaultable` `Data.HashMap.HashMap`.  However, this is not hard to do, as
-- you'll see if you consult the source code for each utility function.

{-| A `Defaultable` type is a @Map@-like type that is extended with an optional
    default value.  This default value can be used as a fallback if a lookup
    into the @Map@-like type does not find a matching key.

    The type variables are:

    * @map@: The @Map@-like type to wrap (typically including the type of key,
      but not the type of the value)

    * @value@ The type of each value stored in the @Map@-like type

    For example, you will typically have a type like
    @`Defaultable` (`Map` key) value@ or
    @`Defaultable` `Data.IntMap.IntMap` value@.

    You can build a `Defaultable` value using:

    * `empty` - The empty `Defaultable` has no keys and no default value
    * `pure` - A `Defaultable` with a default value but no keys
    * `fromMap` \/ `fromList` \/ `singleton` - Convenient construction functions
    * The `Defaultable` constructor

    You can transform and combine `Defaultable` values using:

    * (`<|>`) - Concatenate two `Defaultable` values, preferring keys and
      defaults from the left one
    * @do@ notation, if you enable @ApplicativeDo@
    * `withDefault` - To extend a `Defaultable` value with a default value

    You can query a `Defaultable` value using:

    * `lookup`
    * `toMap` / `toDefault`

    Note that the `Applicative` instance for this type is only valid for
    @map@ type constructors that satisfy the following extra law:

@
Given:

• mf :: map (a -> b)
• mx :: map a
• kf :: (a -> b) -> c
• kx :: a -> c

  (mf `<.>` mx) `<>` `fmap` kf mf `<>` `fmap` kx mx
= (mf `<.>` mx) `<>` `fmap` kx mx `<>` `fmap` kf mf
@

    … where `map` is the first type parameter that implements `Apply` and
    `Monoid`.

    The intuition here is if that @map@ is a `Map`-like type then we can think
    of those three expressions as having a set of keys associated with them,
    such that:

@
Given:

• keys :: map a -> `Data.Set.Set` key

keys (mf `<.>` mx) = keys (`fmap` kf mf) \`intersection\` keys (`fmap` kx mx)
@

    So normally the following equality would not be true:

@
  `fmap` kf mf `<>` `fmap` kx mx
= `fmap` kx mx `<>` `fmap` kf mf
@

    … because the result would change if there was a key collision.  Then the
    order in which we union (`<>`) the two maps would change the result.

    However, if you union yet another map (@mf `<.>` mx@) that shadows the
    colliding keys then result remains the same.
-}
data Defaultable map value =
    Defaultable
        (map value)
        -- ^ The underlying @Map@-like type
        (Maybe value)
        -- ^ An optional default value to return if a key is missing
    deriving stock
        ( Typeable (Defaultable map value)
DataType
Constr
Typeable (Defaultable map value)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> Defaultable map value
    -> c (Defaultable map value))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Defaultable map value))
-> (Defaultable map value -> Constr)
-> (Defaultable map value -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Defaultable map value)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Defaultable map value)))
-> ((forall b. Data b => b -> b)
    -> Defaultable map value -> Defaultable map value)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> Defaultable map value
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> Defaultable map value
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Defaultable map value -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Defaultable map value -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Defaultable map value -> m (Defaultable map value))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Defaultable map value -> m (Defaultable map value))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Defaultable map value -> m (Defaultable map value))
-> Data (Defaultable map value)
Defaultable map value -> DataType
Defaultable map value -> Constr
(forall b. Data b => b -> b)
-> Defaultable map value -> Defaultable map value
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Defaultable map value
-> c (Defaultable map value)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Defaultable map value)
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> Defaultable map value -> u
forall u.
(forall d. Data d => d -> u) -> Defaultable map value -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Defaultable map value -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Defaultable map value -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Defaultable map value -> m (Defaultable map value)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Defaultable map value -> m (Defaultable map value)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Defaultable map value)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Defaultable map value
-> c (Defaultable map value)
forall (map :: * -> *) value.
(Typeable map, Data value, Data (map value)) =>
Typeable (Defaultable map value)
forall (map :: * -> *) value.
(Typeable map, Data value, Data (map value)) =>
Defaultable map value -> DataType
forall (map :: * -> *) value.
(Typeable map, Data value, Data (map value)) =>
Defaultable map value -> Constr
forall (map :: * -> *) value.
(Typeable map, Data value, Data (map value)) =>
(forall b. Data b => b -> b)
-> Defaultable map value -> Defaultable map value
forall (map :: * -> *) value u.
(Typeable map, Data value, Data (map value)) =>
Int -> (forall d. Data d => d -> u) -> Defaultable map value -> u
forall (map :: * -> *) value u.
(Typeable map, Data value, Data (map value)) =>
(forall d. Data d => d -> u) -> Defaultable map value -> [u]
forall (map :: * -> *) value r r'.
(Typeable map, Data value, Data (map value)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Defaultable map value -> r
forall (map :: * -> *) value r r'.
(Typeable map, Data value, Data (map value)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Defaultable map value -> r
forall (map :: * -> *) value (m :: * -> *).
(Typeable map, Data value, Data (map value), Monad m) =>
(forall d. Data d => d -> m d)
-> Defaultable map value -> m (Defaultable map value)
forall (map :: * -> *) value (m :: * -> *).
(Typeable map, Data value, Data (map value), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Defaultable map value -> m (Defaultable map value)
forall (map :: * -> *) value (c :: * -> *).
(Typeable map, Data value, Data (map value)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Defaultable map value)
forall (map :: * -> *) value (c :: * -> *).
(Typeable map, Data value, Data (map value)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Defaultable map value
-> c (Defaultable map value)
forall (map :: * -> *) value (t :: * -> *) (c :: * -> *).
(Typeable map, Data value, Data (map value), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Defaultable map value))
forall (map :: * -> *) value (t :: * -> * -> *) (c :: * -> *).
(Typeable map, Data value, Data (map value), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Defaultable map value))
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Defaultable map value))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Defaultable map value))
$cDefaultable :: Constr
$tDefaultable :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Defaultable map value -> m (Defaultable map value)
$cgmapMo :: forall (map :: * -> *) value (m :: * -> *).
(Typeable map, Data value, Data (map value), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Defaultable map value -> m (Defaultable map value)
gmapMp :: (forall d. Data d => d -> m d)
-> Defaultable map value -> m (Defaultable map value)
$cgmapMp :: forall (map :: * -> *) value (m :: * -> *).
(Typeable map, Data value, Data (map value), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Defaultable map value -> m (Defaultable map value)
gmapM :: (forall d. Data d => d -> m d)
-> Defaultable map value -> m (Defaultable map value)
$cgmapM :: forall (map :: * -> *) value (m :: * -> *).
(Typeable map, Data value, Data (map value), Monad m) =>
(forall d. Data d => d -> m d)
-> Defaultable map value -> m (Defaultable map value)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Defaultable map value -> u
$cgmapQi :: forall (map :: * -> *) value u.
(Typeable map, Data value, Data (map value)) =>
Int -> (forall d. Data d => d -> u) -> Defaultable map value -> u
gmapQ :: (forall d. Data d => d -> u) -> Defaultable map value -> [u]
$cgmapQ :: forall (map :: * -> *) value u.
(Typeable map, Data value, Data (map value)) =>
(forall d. Data d => d -> u) -> Defaultable map value -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Defaultable map value -> r
$cgmapQr :: forall (map :: * -> *) value r r'.
(Typeable map, Data value, Data (map value)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Defaultable map value -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Defaultable map value -> r
$cgmapQl :: forall (map :: * -> *) value r r'.
(Typeable map, Data value, Data (map value)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Defaultable map value -> r
gmapT :: (forall b. Data b => b -> b)
-> Defaultable map value -> Defaultable map value
$cgmapT :: forall (map :: * -> *) value.
(Typeable map, Data value, Data (map value)) =>
(forall b. Data b => b -> b)
-> Defaultable map value -> Defaultable map value
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Defaultable map value))
$cdataCast2 :: forall (map :: * -> *) value (t :: * -> * -> *) (c :: * -> *).
(Typeable map, Data value, Data (map value), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Defaultable map value))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Defaultable map value))
$cdataCast1 :: forall (map :: * -> *) value (t :: * -> *) (c :: * -> *).
(Typeable map, Data value, Data (map value), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Defaultable map value))
dataTypeOf :: Defaultable map value -> DataType
$cdataTypeOf :: forall (map :: * -> *) value.
(Typeable map, Data value, Data (map value)) =>
Defaultable map value -> DataType
toConstr :: Defaultable map value -> Constr
$ctoConstr :: forall (map :: * -> *) value.
(Typeable map, Data value, Data (map value)) =>
Defaultable map value -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Defaultable map value)
$cgunfold :: forall (map :: * -> *) value (c :: * -> *).
(Typeable map, Data value, Data (map value)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Defaultable map value)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Defaultable map value
-> c (Defaultable map value)
$cgfoldl :: forall (map :: * -> *) value (c :: * -> *).
(Typeable map, Data value, Data (map value)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Defaultable map value
-> c (Defaultable map value)
$cp1Data :: forall (map :: * -> *) value.
(Typeable map, Data value, Data (map value)) =>
Typeable (Defaultable map value)
Data
        , Defaultable map value -> Defaultable map value -> Bool
(Defaultable map value -> Defaultable map value -> Bool)
-> (Defaultable map value -> Defaultable map value -> Bool)
-> Eq (Defaultable map value)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (map :: * -> *) value.
(Eq value, Eq (map value)) =>
Defaultable map value -> Defaultable map value -> Bool
/= :: Defaultable map value -> Defaultable map value -> Bool
$c/= :: forall (map :: * -> *) value.
(Eq value, Eq (map value)) =>
Defaultable map value -> Defaultable map value -> Bool
== :: Defaultable map value -> Defaultable map value -> Bool
$c== :: forall (map :: * -> *) value.
(Eq value, Eq (map value)) =>
Defaultable map value -> Defaultable map value -> Bool
Eq
        , Defaultable map a -> Bool
(a -> m) -> Defaultable map a -> m
(a -> b -> b) -> b -> Defaultable map a -> b
(forall m. Monoid m => Defaultable map m -> m)
-> (forall m a. Monoid m => (a -> m) -> Defaultable map a -> m)
-> (forall m a. Monoid m => (a -> m) -> Defaultable map a -> m)
-> (forall a b. (a -> b -> b) -> b -> Defaultable map a -> b)
-> (forall a b. (a -> b -> b) -> b -> Defaultable map a -> b)
-> (forall b a. (b -> a -> b) -> b -> Defaultable map a -> b)
-> (forall b a. (b -> a -> b) -> b -> Defaultable map a -> b)
-> (forall a. (a -> a -> a) -> Defaultable map a -> a)
-> (forall a. (a -> a -> a) -> Defaultable map a -> a)
-> (forall a. Defaultable map a -> [a])
-> (forall a. Defaultable map a -> Bool)
-> (forall a. Defaultable map a -> Int)
-> (forall a. Eq a => a -> Defaultable map a -> Bool)
-> (forall a. Ord a => Defaultable map a -> a)
-> (forall a. Ord a => Defaultable map a -> a)
-> (forall a. Num a => Defaultable map a -> a)
-> (forall a. Num a => Defaultable map a -> a)
-> Foldable (Defaultable map)
forall a. Eq a => a -> Defaultable map a -> Bool
forall a. Num a => Defaultable map a -> a
forall a. Ord a => Defaultable map a -> a
forall m. Monoid m => Defaultable map m -> m
forall a. Defaultable map a -> Bool
forall a. Defaultable map a -> Int
forall a. Defaultable map a -> [a]
forall a. (a -> a -> a) -> Defaultable map a -> a
forall m a. Monoid m => (a -> m) -> Defaultable map a -> m
forall b a. (b -> a -> b) -> b -> Defaultable map a -> b
forall a b. (a -> b -> b) -> b -> Defaultable map a -> b
forall (map :: * -> *) a.
(Foldable map, Eq a) =>
a -> Defaultable map a -> Bool
forall (map :: * -> *) a.
(Foldable map, Num a) =>
Defaultable map a -> a
forall (map :: * -> *) a.
(Foldable map, Ord a) =>
Defaultable map a -> a
forall (map :: * -> *) m.
(Foldable map, Monoid m) =>
Defaultable map m -> m
forall (map :: * -> *) a. Foldable map => Defaultable map a -> Bool
forall (map :: * -> *) a. Foldable map => Defaultable map a -> Int
forall (map :: * -> *) a. Foldable map => Defaultable map a -> [a]
forall (map :: * -> *) a.
Foldable map =>
(a -> a -> a) -> Defaultable map a -> a
forall (map :: * -> *) m a.
(Foldable map, Monoid m) =>
(a -> m) -> Defaultable map a -> m
forall (map :: * -> *) b a.
Foldable map =>
(b -> a -> b) -> b -> Defaultable map a -> b
forall (map :: * -> *) a b.
Foldable map =>
(a -> b -> b) -> b -> Defaultable map a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Defaultable map a -> a
$cproduct :: forall (map :: * -> *) a.
(Foldable map, Num a) =>
Defaultable map a -> a
sum :: Defaultable map a -> a
$csum :: forall (map :: * -> *) a.
(Foldable map, Num a) =>
Defaultable map a -> a
minimum :: Defaultable map a -> a
$cminimum :: forall (map :: * -> *) a.
(Foldable map, Ord a) =>
Defaultable map a -> a
maximum :: Defaultable map a -> a
$cmaximum :: forall (map :: * -> *) a.
(Foldable map, Ord a) =>
Defaultable map a -> a
elem :: a -> Defaultable map a -> Bool
$celem :: forall (map :: * -> *) a.
(Foldable map, Eq a) =>
a -> Defaultable map a -> Bool
length :: Defaultable map a -> Int
$clength :: forall (map :: * -> *) a. Foldable map => Defaultable map a -> Int
null :: Defaultable map a -> Bool
$cnull :: forall (map :: * -> *) a. Foldable map => Defaultable map a -> Bool
toList :: Defaultable map a -> [a]
$ctoList :: forall (map :: * -> *) a. Foldable map => Defaultable map a -> [a]
foldl1 :: (a -> a -> a) -> Defaultable map a -> a
$cfoldl1 :: forall (map :: * -> *) a.
Foldable map =>
(a -> a -> a) -> Defaultable map a -> a
foldr1 :: (a -> a -> a) -> Defaultable map a -> a
$cfoldr1 :: forall (map :: * -> *) a.
Foldable map =>
(a -> a -> a) -> Defaultable map a -> a
foldl' :: (b -> a -> b) -> b -> Defaultable map a -> b
$cfoldl' :: forall (map :: * -> *) b a.
Foldable map =>
(b -> a -> b) -> b -> Defaultable map a -> b
foldl :: (b -> a -> b) -> b -> Defaultable map a -> b
$cfoldl :: forall (map :: * -> *) b a.
Foldable map =>
(b -> a -> b) -> b -> Defaultable map a -> b
foldr' :: (a -> b -> b) -> b -> Defaultable map a -> b
$cfoldr' :: forall (map :: * -> *) a b.
Foldable map =>
(a -> b -> b) -> b -> Defaultable map a -> b
foldr :: (a -> b -> b) -> b -> Defaultable map a -> b
$cfoldr :: forall (map :: * -> *) a b.
Foldable map =>
(a -> b -> b) -> b -> Defaultable map a -> b
foldMap' :: (a -> m) -> Defaultable map a -> m
$cfoldMap' :: forall (map :: * -> *) m a.
(Foldable map, Monoid m) =>
(a -> m) -> Defaultable map a -> m
foldMap :: (a -> m) -> Defaultable map a -> m
$cfoldMap :: forall (map :: * -> *) m a.
(Foldable map, Monoid m) =>
(a -> m) -> Defaultable map a -> m
fold :: Defaultable map m -> m
$cfold :: forall (map :: * -> *) m.
(Foldable map, Monoid m) =>
Defaultable map m -> m
Foldable
        , a -> Defaultable map b -> Defaultable map a
(a -> b) -> Defaultable map a -> Defaultable map b
(forall a b. (a -> b) -> Defaultable map a -> Defaultable map b)
-> (forall a b. a -> Defaultable map b -> Defaultable map a)
-> Functor (Defaultable map)
forall a b. a -> Defaultable map b -> Defaultable map a
forall a b. (a -> b) -> Defaultable map a -> Defaultable map b
forall (map :: * -> *) a b.
Functor map =>
a -> Defaultable map b -> Defaultable map a
forall (map :: * -> *) a b.
Functor map =>
(a -> b) -> Defaultable map a -> Defaultable map b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Defaultable map b -> Defaultable map a
$c<$ :: forall (map :: * -> *) a b.
Functor map =>
a -> Defaultable map b -> Defaultable map a
fmap :: (a -> b) -> Defaultable map a -> Defaultable map b
$cfmap :: forall (map :: * -> *) a b.
Functor map =>
(a -> b) -> Defaultable map a -> Defaultable map b
Functor
        , (forall x. Defaultable map value -> Rep (Defaultable map value) x)
-> (forall x.
    Rep (Defaultable map value) x -> Defaultable map value)
-> Generic (Defaultable map value)
forall x. Rep (Defaultable map value) x -> Defaultable map value
forall x. Defaultable map value -> Rep (Defaultable map value) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (map :: * -> *) value x.
Rep (Defaultable map value) x -> Defaultable map value
forall (map :: * -> *) value x.
Defaultable map value -> Rep (Defaultable map value) x
$cto :: forall (map :: * -> *) value x.
Rep (Defaultable map value) x -> Defaultable map value
$cfrom :: forall (map :: * -> *) value x.
Defaultable map value -> Rep (Defaultable map value) x
Generic
        , (forall a. Defaultable map a -> Rep1 (Defaultable map) a)
-> (forall a. Rep1 (Defaultable map) a -> Defaultable map a)
-> Generic1 (Defaultable map)
forall a. Rep1 (Defaultable map) a -> Defaultable map a
forall a. Defaultable map a -> Rep1 (Defaultable map) a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
forall (map :: * -> *) a.
Rep1 (Defaultable map) a -> Defaultable map a
forall (map :: * -> *) a.
Defaultable map a -> Rep1 (Defaultable map) a
$cto1 :: forall (map :: * -> *) a.
Rep1 (Defaultable map) a -> Defaultable map a
$cfrom1 :: forall (map :: * -> *) a.
Defaultable map a -> Rep1 (Defaultable map) a
Generic1
        , Eq (Defaultable map value)
Eq (Defaultable map value)
-> (Defaultable map value -> Defaultable map value -> Ordering)
-> (Defaultable map value -> Defaultable map value -> Bool)
-> (Defaultable map value -> Defaultable map value -> Bool)
-> (Defaultable map value -> Defaultable map value -> Bool)
-> (Defaultable map value -> Defaultable map value -> Bool)
-> (Defaultable map value
    -> Defaultable map value -> Defaultable map value)
-> (Defaultable map value
    -> Defaultable map value -> Defaultable map value)
-> Ord (Defaultable map value)
Defaultable map value -> Defaultable map value -> Bool
Defaultable map value -> Defaultable map value -> Ordering
Defaultable map value
-> Defaultable map value -> Defaultable map value
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (map :: * -> *) value.
(Ord value, Ord (map value)) =>
Eq (Defaultable map value)
forall (map :: * -> *) value.
(Ord value, Ord (map value)) =>
Defaultable map value -> Defaultable map value -> Bool
forall (map :: * -> *) value.
(Ord value, Ord (map value)) =>
Defaultable map value -> Defaultable map value -> Ordering
forall (map :: * -> *) value.
(Ord value, Ord (map value)) =>
Defaultable map value
-> Defaultable map value -> Defaultable map value
min :: Defaultable map value
-> Defaultable map value -> Defaultable map value
$cmin :: forall (map :: * -> *) value.
(Ord value, Ord (map value)) =>
Defaultable map value
-> Defaultable map value -> Defaultable map value
max :: Defaultable map value
-> Defaultable map value -> Defaultable map value
$cmax :: forall (map :: * -> *) value.
(Ord value, Ord (map value)) =>
Defaultable map value
-> Defaultable map value -> Defaultable map value
>= :: Defaultable map value -> Defaultable map value -> Bool
$c>= :: forall (map :: * -> *) value.
(Ord value, Ord (map value)) =>
Defaultable map value -> Defaultable map value -> Bool
> :: Defaultable map value -> Defaultable map value -> Bool
$c> :: forall (map :: * -> *) value.
(Ord value, Ord (map value)) =>
Defaultable map value -> Defaultable map value -> Bool
<= :: Defaultable map value -> Defaultable map value -> Bool
$c<= :: forall (map :: * -> *) value.
(Ord value, Ord (map value)) =>
Defaultable map value -> Defaultable map value -> Bool
< :: Defaultable map value -> Defaultable map value -> Bool
$c< :: forall (map :: * -> *) value.
(Ord value, Ord (map value)) =>
Defaultable map value -> Defaultable map value -> Bool
compare :: Defaultable map value -> Defaultable map value -> Ordering
$ccompare :: forall (map :: * -> *) value.
(Ord value, Ord (map value)) =>
Defaultable map value -> Defaultable map value -> Ordering
$cp1Ord :: forall (map :: * -> *) value.
(Ord value, Ord (map value)) =>
Eq (Defaultable map value)
Ord
        , Int -> Defaultable map value -> ShowS
[Defaultable map value] -> ShowS
Defaultable map value -> String
(Int -> Defaultable map value -> ShowS)
-> (Defaultable map value -> String)
-> ([Defaultable map value] -> ShowS)
-> Show (Defaultable map value)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (map :: * -> *) value.
(Show value, Show (map value)) =>
Int -> Defaultable map value -> ShowS
forall (map :: * -> *) value.
(Show value, Show (map value)) =>
[Defaultable map value] -> ShowS
forall (map :: * -> *) value.
(Show value, Show (map value)) =>
Defaultable map value -> String
showList :: [Defaultable map value] -> ShowS
$cshowList :: forall (map :: * -> *) value.
(Show value, Show (map value)) =>
[Defaultable map value] -> ShowS
show :: Defaultable map value -> String
$cshow :: forall (map :: * -> *) value.
(Show value, Show (map value)) =>
Defaultable map value -> String
showsPrec :: Int -> Defaultable map value -> ShowS
$cshowsPrec :: forall (map :: * -> *) value.
(Show value, Show (map value)) =>
Int -> Defaultable map value -> ShowS
Show
        , Functor (Defaultable map)
Foldable (Defaultable map)
Functor (Defaultable map)
-> Foldable (Defaultable map)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Defaultable map a -> f (Defaultable map b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Defaultable map (f a) -> f (Defaultable map a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Defaultable map a -> m (Defaultable map b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Defaultable map (m a) -> m (Defaultable map a))
-> Traversable (Defaultable map)
(a -> f b) -> Defaultable map a -> f (Defaultable map b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (map :: * -> *).
Traversable map =>
Functor (Defaultable map)
forall (map :: * -> *).
Traversable map =>
Foldable (Defaultable map)
forall (map :: * -> *) (m :: * -> *) a.
(Traversable map, Monad m) =>
Defaultable map (m a) -> m (Defaultable map a)
forall (map :: * -> *) (f :: * -> *) a.
(Traversable map, Applicative f) =>
Defaultable map (f a) -> f (Defaultable map a)
forall (map :: * -> *) (m :: * -> *) a b.
(Traversable map, Monad m) =>
(a -> m b) -> Defaultable map a -> m (Defaultable map b)
forall (map :: * -> *) (f :: * -> *) a b.
(Traversable map, Applicative f) =>
(a -> f b) -> Defaultable map a -> f (Defaultable map b)
forall (m :: * -> *) a.
Monad m =>
Defaultable map (m a) -> m (Defaultable map a)
forall (f :: * -> *) a.
Applicative f =>
Defaultable map (f a) -> f (Defaultable map a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Defaultable map a -> m (Defaultable map b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Defaultable map a -> f (Defaultable map b)
sequence :: Defaultable map (m a) -> m (Defaultable map a)
$csequence :: forall (map :: * -> *) (m :: * -> *) a.
(Traversable map, Monad m) =>
Defaultable map (m a) -> m (Defaultable map a)
mapM :: (a -> m b) -> Defaultable map a -> m (Defaultable map b)
$cmapM :: forall (map :: * -> *) (m :: * -> *) a b.
(Traversable map, Monad m) =>
(a -> m b) -> Defaultable map a -> m (Defaultable map b)
sequenceA :: Defaultable map (f a) -> f (Defaultable map a)
$csequenceA :: forall (map :: * -> *) (f :: * -> *) a.
(Traversable map, Applicative f) =>
Defaultable map (f a) -> f (Defaultable map a)
traverse :: (a -> f b) -> Defaultable map a -> f (Defaultable map b)
$ctraverse :: forall (map :: * -> *) (f :: * -> *) a b.
(Traversable map, Applicative f) =>
(a -> f b) -> Defaultable map a -> f (Defaultable map b)
$cp2Traversable :: forall (map :: * -> *).
Traversable map =>
Foldable (Defaultable map)
$cp1Traversable :: forall (map :: * -> *).
Traversable map =>
Functor (Defaultable map)
Traversable
        )
    deriving anyclass (Defaultable map value -> ()
(Defaultable map value -> ()) -> NFData (Defaultable map value)
forall a. (a -> ()) -> NFData a
forall (map :: * -> *) value.
(NFData value, NFData (map value)) =>
Defaultable map value -> ()
rnf :: Defaultable map value -> ()
$crnf :: forall (map :: * -> *) value.
(NFData value, NFData (map value)) =>
Defaultable map value -> ()
NFData)

instance (Apply map, forall a . Monoid (map a)) => Apply (Defaultable map) where
    <.> :: Defaultable map (a -> b) -> Defaultable map a -> Defaultable map b
(<.>) = Defaultable map (a -> b) -> Defaultable map a -> Defaultable map b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
(<*>)

instance (Apply map, forall a . Monoid (map a)) => Applicative (Defaultable map) where
    pure :: a -> Defaultable map a
pure a
v = map a -> Maybe a -> Defaultable map a
forall (map :: * -> *) value.
map value -> Maybe value -> Defaultable map value
Defaultable map a
forall a. Monoid a => a
mempty (a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
v)

    Defaultable map (a -> b)
fMap Maybe (a -> b)
fDefault <*> :: Defaultable map (a -> b) -> Defaultable map a -> Defaultable map b
<*> Defaultable map a
xMap Maybe a
xDefault =
        map b -> Maybe b -> Defaultable map b
forall (map :: * -> *) value.
map value -> Maybe value -> Defaultable map value
Defaultable map b
fxMap Maybe b
fxDefault
      where
        fxMap :: map b
fxMap = (map (a -> b)
fMap map (a -> b) -> map a -> map b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
<.> map a
xMap) map b -> map b -> map b
forall a. Semigroup a => a -> a -> a
<> map b
fFallback map b -> map b -> map b
forall a. Semigroup a => a -> a -> a
<> map b
xFallback
          where
            fFallback :: map b
fFallback =
                case Maybe (a -> b)
fDefault of
                    Maybe (a -> b)
Nothing -> map b
forall a. Monoid a => a
mempty
                    Just a -> b
f  -> (a -> b) -> map a -> map b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f map a
xMap

            xFallback :: map b
xFallback =
                case Maybe a
xDefault of
                    Maybe a
Nothing -> map b
forall a. Monoid a => a
mempty
                    Just a
x  -> ((a -> b) -> b) -> map (a -> b) -> map b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ a
x) map (a -> b)
fMap

        fxDefault :: Maybe b
fxDefault = Maybe (a -> b)
fDefault Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe a
xDefault

instance (Apply map, forall a . Monoid (map a)) => Alt (Defaultable map) where
    <!> :: Defaultable map a -> Defaultable map a -> Defaultable map a
(<!>) = Defaultable map a -> Defaultable map a -> Defaultable map a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
(<|>)

instance (Apply map, forall a . Monoid (map a)) => Alternative (Defaultable map) where
    empty :: Defaultable map a
empty = map a -> Maybe a -> Defaultable map a
forall (map :: * -> *) value.
map value -> Maybe value -> Defaultable map value
Defaultable map a
forall a. Monoid a => a
mempty Maybe a
forall (f :: * -> *) a. Alternative f => f a
empty

    Defaultable map a
lMap Maybe a
lDefault <|> :: Defaultable map a -> Defaultable map a -> Defaultable map a
<|> Defaultable map a
rMap Maybe a
rDefault =
        map a -> Maybe a -> Defaultable map a
forall (map :: * -> *) value.
map value -> Maybe value -> Defaultable map value
Defaultable (map a
lMap map a -> map a -> map a
forall a. Semigroup a => a -> a -> a
<> map a
rMap) (Maybe a
lDefault Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe a
rDefault)

-- | Not the same as the `Semigroup` instance for the underlying @map@ type
instance (Apply map, forall a . Monoid (map a), Semigroup value) => Semigroup (Defaultable map value) where
    <> :: Defaultable map value
-> Defaultable map value -> Defaultable map value
(<>) = (value -> value -> value)
-> Defaultable map value
-> Defaultable map value
-> Defaultable map value
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 value -> value -> value
forall a. Semigroup a => a -> a -> a
(<>)

-- | Not the same as the `Monoid` instance for the underlying @map@ type
instance (Apply map, forall a . Monoid (map a), Monoid value) => Monoid (Defaultable map value) where
    mempty :: Defaultable map value
mempty = value -> Defaultable map value
forall (f :: * -> *) a. Applicative f => a -> f a
pure value
forall a. Monoid a => a
mempty

{-| Create a `Defaultable` `Map` from a `Map`

>>> fromMap (Map.fromList [('A',1),('B',2),('B',3)])
Defaultable (fromList [('A',1),('B',3)]) Nothing
-}
fromMap :: Map key value -> Defaultable (Map key) value
fromMap :: Map key value -> Defaultable (Map key) value
fromMap Map key value
map_ = Map key value -> Maybe value -> Defaultable (Map key) value
forall (map :: * -> *) value.
map value -> Maybe value -> Defaultable map value
Defaultable Map key value
map_ Maybe value
forall (f :: * -> *) a. Alternative f => f a
empty

{-| Create a `Defaultable` `Map` from a single key-value pair

>>> singleton ('A', 1)
Defaultable (fromList [('A',1)]) Nothing
-}
singleton :: (key, value) -> Defaultable (Map key) value
singleton :: (key, value) -> Defaultable (Map key) value
singleton (key
key, value
value) = Map key value -> Defaultable (Map key) value
forall key value. Map key value -> Defaultable (Map key) value
fromMap (key -> value -> Map key value
forall k a. k -> a -> Map k a
Map.singleton key
key value
value)

{-| Create a `Defaultable` `Map` from a list of key-value pairs

>>> fromList [('A',1),('B',2),('B',3)]
Defaultable (fromList [('A',1),('B',3)]) Nothing
-}
fromList :: Ord key => [(key, value)] -> Defaultable (Map key) value
fromList :: [(key, value)] -> Defaultable (Map key) value
fromList [(key, value)]
pairs = Map key value -> Defaultable (Map key) value
forall key value. Map key value -> Defaultable (Map key) value
fromMap ([(key, value)] -> Map key value
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(key, value)]
pairs)

{-| Insert a key-value pair into a `Defaultable` `Map`

>>> let example = fromList [('A', 1)]
>>> insert ('B', 2) example
Defaultable (fromList [('A',1),('B',2)]) Nothing
>>> insert ('A', 0) example
Defaultable (fromList [('A',0)]) Nothing

    For bulk updates, you should instead use `fromList`/`fromMap` with (`<|>`):

>>> fromList [('A',0),('B', 2), ('C', 3)] <|> example
Defaultable (fromList [('A',0),('B',2),('C',3)]) Nothing
-}
insert
    :: Ord key
    => (key, value)
    -- ^
    -> Defaultable (Map key) value
    -- ^
    -> Defaultable (Map key) value
insert :: (key, value)
-> Defaultable (Map key) value -> Defaultable (Map key) value
insert (key
key, value
value) (Defaultable Map key value
map_ Maybe value
default_) =
    (Map key value -> Maybe value -> Defaultable (Map key) value
forall (map :: * -> *) value.
map value -> Maybe value -> Defaultable map value
Defaultable (key -> value -> Map key value -> Map key value
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert key
key value
value Map key value
map_) Maybe value
default_)

{-| Add a default value to a `Defaultable` `Map` that is returned as a fallback
    if a `lookup` cannot find a matching key

>>> let example = fromList [('A',1)] `withDefault` 2
>>> lookup 'A' example
Just 1
>>> lookup 'B' example
Just 2
-}
withDefault
    :: Ord key
    => Defaultable (Map key) value
    -- ^
    -> value
    -- ^
    -> Defaultable (Map key) value
Defaultable Map key value
map_ Maybe value
_ withDefault :: Defaultable (Map key) value -> value -> Defaultable (Map key) value
`withDefault` value
default_ = Map key value -> Maybe value -> Defaultable (Map key) value
forall (map :: * -> *) value.
map value -> Maybe value -> Defaultable map value
Defaultable Map key value
map_ (value -> Maybe value
forall a. a -> Maybe a
Just value
default_)

{-| Lookup the value at a key in the map

    If the key is missing this falls back to returning the default value if
    present

    `lookup` is an `Monad` morphism, meaning that `lookup` distributes
    over `Monad` operatiorns:

@
`lookup` (`return` x) = `return` x

`lookup` (do x <- m; f x) = do x <- `lookup` m; `lookup` (f x)
@

    `lookup` is also an `Alternative` morphism, meaning that `lookup`
    distributes over `Alternative` operations:

@
`lookup` `empty` = `empty`

`lookup` (l `<|>` r) = `lookup` l `<|>` `lookup` r
@

>>> let example = fromList [('A',1)]
>>> lookup 'A' example
Just 1
>>> lookup 'B' example
Nothing
>>> lookup 'B' (example `withDefault` 2)
Just 2
-}
lookup :: Ord key => key -> Defaultable (Map key) value -> Maybe value
lookup :: key -> Defaultable (Map key) value -> Maybe value
lookup key
key (Defaultable Map key value
map_ Maybe value
default_) = key -> Map key value -> Maybe value
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup key
key Map key value
map_ Maybe value -> Maybe value -> Maybe value
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe value
default_

-- | Extract the underlying map from a `Defaultable` map
toMap :: Defaultable (Map key) value -> Map key value
toMap :: Defaultable (Map key) value -> Map key value
toMap (Defaultable Map key value
map_ Maybe value
_) = Map key value
map_

-- | Extract the default value from a `Defaultable` map
toDefault :: Defaultable (Map key) value -> Maybe value
toDefault :: Defaultable (Map key) value -> Maybe value
toDefault (Defaultable Map key value
_ Maybe value
default_) = Maybe value
default_