{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE GeneralisedNewtypeDeriving #-}
{-# LANGUAGE RankNTypes #-}

module Data.Map.NonEmpty (
  NonEmptyMap,
  fromFoldable,
  fromMap,
  singleton,
  toList,
  toMap,
) where

import Cardano.Ledger.Binary (DecCBOR (decCBOR), EncCBOR)
import Control.DeepSeq (NFData)
import qualified Data.Foldable as Foldable
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import NoThunks.Class (NoThunks)
import Prelude hiding (map)

newtype NonEmptyMap k v = NonEmptyMap (Map k v)
  deriving stock (Int -> NonEmptyMap k v -> ShowS
[NonEmptyMap k v] -> ShowS
NonEmptyMap k v -> String
(Int -> NonEmptyMap k v -> ShowS)
-> (NonEmptyMap k v -> String)
-> ([NonEmptyMap k v] -> ShowS)
-> Show (NonEmptyMap k v)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k v. (Show k, Show v) => Int -> NonEmptyMap k v -> ShowS
forall k v. (Show k, Show v) => [NonEmptyMap k v] -> ShowS
forall k v. (Show k, Show v) => NonEmptyMap k v -> String
$cshowsPrec :: forall k v. (Show k, Show v) => Int -> NonEmptyMap k v -> ShowS
showsPrec :: Int -> NonEmptyMap k v -> ShowS
$cshow :: forall k v. (Show k, Show v) => NonEmptyMap k v -> String
show :: NonEmptyMap k v -> String
$cshowList :: forall k v. (Show k, Show v) => [NonEmptyMap k v] -> ShowS
showList :: [NonEmptyMap k v] -> ShowS
Show, NonEmptyMap k v -> NonEmptyMap k v -> Bool
(NonEmptyMap k v -> NonEmptyMap k v -> Bool)
-> (NonEmptyMap k v -> NonEmptyMap k v -> Bool)
-> Eq (NonEmptyMap k v)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k v.
(Eq k, Eq v) =>
NonEmptyMap k v -> NonEmptyMap k v -> Bool
$c== :: forall k v.
(Eq k, Eq v) =>
NonEmptyMap k v -> NonEmptyMap k v -> Bool
== :: NonEmptyMap k v -> NonEmptyMap k v -> Bool
$c/= :: forall k v.
(Eq k, Eq v) =>
NonEmptyMap k v -> NonEmptyMap k v -> Bool
/= :: NonEmptyMap k v -> NonEmptyMap k v -> Bool
Eq)
  deriving newtype (NonEmptyMap k v -> Encoding
(NonEmptyMap k v -> Encoding) -> EncCBOR (NonEmptyMap k v)
forall a. (a -> Encoding) -> EncCBOR a
forall k v. (EncCBOR k, EncCBOR v) => NonEmptyMap k v -> Encoding
$cencCBOR :: forall k v. (EncCBOR k, EncCBOR v) => NonEmptyMap k v -> Encoding
encCBOR :: NonEmptyMap k v -> Encoding
EncCBOR, Context -> NonEmptyMap k v -> IO (Maybe ThunkInfo)
Proxy (NonEmptyMap k v) -> String
(Context -> NonEmptyMap k v -> IO (Maybe ThunkInfo))
-> (Context -> NonEmptyMap k v -> IO (Maybe ThunkInfo))
-> (Proxy (NonEmptyMap k v) -> String)
-> NoThunks (NonEmptyMap k v)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
forall k v.
(NoThunks k, NoThunks v) =>
Context -> NonEmptyMap k v -> IO (Maybe ThunkInfo)
forall k v.
(NoThunks k, NoThunks v) =>
Proxy (NonEmptyMap k v) -> String
$cnoThunks :: forall k v.
(NoThunks k, NoThunks v) =>
Context -> NonEmptyMap k v -> IO (Maybe ThunkInfo)
noThunks :: Context -> NonEmptyMap k v -> IO (Maybe ThunkInfo)
$cwNoThunks :: forall k v.
(NoThunks k, NoThunks v) =>
Context -> NonEmptyMap k v -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> NonEmptyMap k v -> IO (Maybe ThunkInfo)
$cshowTypeOf :: forall k v.
(NoThunks k, NoThunks v) =>
Proxy (NonEmptyMap k v) -> String
showTypeOf :: Proxy (NonEmptyMap k v) -> String
NoThunks, NonEmptyMap k v -> ()
(NonEmptyMap k v -> ()) -> NFData (NonEmptyMap k v)
forall a. (a -> ()) -> NFData a
forall k v. (NFData k, NFData v) => NonEmptyMap k v -> ()
$crnf :: forall k v. (NFData k, NFData v) => NonEmptyMap k v -> ()
rnf :: NonEmptyMap k v -> ()
NFData)

instance (Ord k, DecCBOR k, DecCBOR v) => DecCBOR (NonEmptyMap k v) where
  decCBOR :: forall s. Decoder s (NonEmptyMap k v)
decCBOR = do
    m <- Decoder s (Map k v)
forall s. Decoder s (Map k v)
forall a s. DecCBOR a => Decoder s a
decCBOR
    case fromMap m of
      Maybe (NonEmptyMap k v)
Nothing -> String -> Decoder s (NonEmptyMap k v)
forall a. String -> Decoder s a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Empty map found, expected non-empty"
      Just NonEmptyMap k v
nem -> NonEmptyMap k v -> Decoder s (NonEmptyMap k v)
forall a. a -> Decoder s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NonEmptyMap k v
nem
  {-# INLINE decCBOR #-}

-- | \(O(1)\).
singleton :: forall k v. k -> v -> NonEmptyMap k v
singleton :: forall k v. k -> v -> NonEmptyMap k v
singleton k
k v
v = Map k v -> NonEmptyMap k v
forall k v. Map k v -> NonEmptyMap k v
NonEmptyMap (Map k v -> NonEmptyMap k v) -> Map k v -> NonEmptyMap k v
forall a b. (a -> b) -> a -> b
$ k -> v -> Map k v
forall k a. k -> a -> Map k a
Map.singleton k
k v
v

-- | \(O(1)\).
fromMap :: forall k v. Map k v -> Maybe (NonEmptyMap k v)
fromMap :: forall k v. Map k v -> Maybe (NonEmptyMap k v)
fromMap Map k v
set = if Map k v -> Bool
forall k a. Map k a -> Bool
Map.null Map k v
set then Maybe (NonEmptyMap k v)
forall a. Maybe a
Nothing else NonEmptyMap k v -> Maybe (NonEmptyMap k v)
forall a. a -> Maybe a
Just (Map k v -> NonEmptyMap k v
forall k v. Map k v -> NonEmptyMap k v
NonEmptyMap Map k v
set)

-- | \(O(1)\).
toMap :: forall k v. NonEmptyMap k v -> Map k v
toMap :: forall k v. NonEmptyMap k v -> Map k v
toMap (NonEmptyMap Map k v
set) = Map k v
set

-- | \(O(n \log n)\).
fromFoldable :: forall f k v. (Foldable f, Ord k) => f (k, v) -> Maybe (NonEmptyMap k v)
fromFoldable :: forall (f :: * -> *) k v.
(Foldable f, Ord k) =>
f (k, v) -> Maybe (NonEmptyMap k v)
fromFoldable = Map k v -> Maybe (NonEmptyMap k v)
forall k v. Map k v -> Maybe (NonEmptyMap k v)
fromMap (Map k v -> Maybe (NonEmptyMap k v))
-> (f (k, v) -> Map k v) -> f (k, v) -> Maybe (NonEmptyMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map k v -> (k, v) -> Map k v) -> Map k v -> f (k, v) -> Map k v
forall b a. (b -> a -> b) -> b -> f a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
Foldable.foldl' (((k, v) -> Map k v -> Map k v) -> Map k v -> (k, v) -> Map k v
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((k -> v -> Map k v -> Map k v) -> (k, v) -> Map k v -> Map k v
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry k -> v -> Map k v -> Map k v
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert)) Map k v
forall k a. Map k a
Map.empty

-- | \(O(n)\).
toList :: forall k v. NonEmptyMap k v -> [(k, v)]
toList :: forall k v. NonEmptyMap k v -> [(k, v)]
toList (NonEmptyMap Map k v
set) = Map k v -> [(k, v)]
forall k a. Map k a -> [(k, a)]
Map.toList Map k v
set