{- HLINT ignore "Avoid lambda" -}
{- HLINT ignore "Avoid lambda using `infix`" -}
{- HLINT ignore "Redundant bracket" -}
{- HLINT ignore "Use camelCase" -}

-- |
-- Copyright: © 2022–2026 Jonathan Knowles
-- License: Apache-2.0
--
-- Provides alternative implementations of @fromMap@, which constructs a
-- map of 'NonNull' values from an ordinary map.
--
-- These implementations are exported so that they can be benchmarked against
-- one another.
--
module Data.MonoidMap.Internal.NonNullMap.FromMap
    ( fromMap_filter
    , fromMap_filter_if_any_null
    , fromMap_mapMaybe
    )
    where

import Prelude hiding
    ( null )

import Data.Map.Strict
    ( Map )
import Data.Monoid.Null
    ( MonoidNull (null) )
import Data.MonoidMap.Internal.NonNull
    ( NonNull, nonNull )
import Data.MonoidMap.Internal.NonNullMap.Unsafe
    ( NonNullMap (..)
    , unsafeFromMap
    )

import qualified Data.Foldable as F
import qualified Data.Map.Strict as Map

fromMap_filter
    :: MonoidNull v => Map k v -> NonNullMap k v
fromMap_filter :: forall v k. MonoidNull v => Map k v -> NonNullMap k v
fromMap_filter = Map k v -> NonNullMap k v
forall k v. Map k v -> NonNullMap k v
unsafeFromMap (Map k v -> NonNullMap k v)
-> (Map k v -> Map k v) -> Map k v -> NonNullMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v -> Bool) -> Map k v -> Map k v
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (\(!v
v) -> Bool -> Bool
not (v -> Bool
forall m. MonoidNull m => m -> Bool
null v
v))
{-# INLINABLE fromMap_filter #-}

fromMap_filter_if_any_null
    :: MonoidNull v => Map k v -> NonNullMap k v
fromMap_filter_if_any_null :: forall v k. MonoidNull v => Map k v -> NonNullMap k v
fromMap_filter_if_any_null Map k v
m
    | (v -> Bool) -> Map k v -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (\(!v
v) -> v -> Bool
forall m. MonoidNull m => m -> Bool
null v
v) Map k v
m =
        Map k v -> NonNullMap k v
forall k v. Map k v -> NonNullMap k v
unsafeFromMap (Map k v -> NonNullMap k v) -> Map k v -> NonNullMap k v
forall a b. (a -> b) -> a -> b
$ (v -> Bool) -> Map k v -> Map k v
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (\(!v
v) -> Bool -> Bool
not (v -> Bool
forall m. MonoidNull m => m -> Bool
null v
v)) Map k v
m
    | Bool
otherwise =
        Map k v -> NonNullMap k v
forall k v. Map k v -> NonNullMap k v
unsafeFromMap Map k v
m
{-# INLINABLE fromMap_filter_if_any_null #-}

fromMap_mapMaybe
    :: MonoidNull v => Map k v -> NonNullMap k v
fromMap_mapMaybe :: forall v k. MonoidNull v => Map k v -> NonNullMap k v
fromMap_mapMaybe = Map k (NonNull v) -> NonNullMap k v
forall k v. Map k (NonNull v) -> NonNullMap k v
NonNullMap (Map k (NonNull v) -> NonNullMap k v)
-> (Map k v -> Map k (NonNull v)) -> Map k v -> NonNullMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v -> Maybe (NonNull v)) -> Map k v -> Map k (NonNull v)
forall a b k. (a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybe v -> Maybe (NonNull v)
forall v. MonoidNull v => v -> Maybe (NonNull v)
nonNull
{-# INLINABLE fromMap_mapMaybe #-}