{-# OPTIONS_GHC -Wno-dodgy-imports #-}

module PostgresqlSyntax.Extras.NonEmpty where

import Data.List.NonEmpty
import PostgresqlSyntax.Prelude hiding (cons, fromList, head, init, last, reverse, tail, uncons)

-- |
-- >>> intersperseFoldMap ", " id (fromList ["a"])
-- "a"
--
-- >>> intersperseFoldMap ", " id (fromList ["a", "b", "c"])
-- "a, b, c"
intersperseFoldMap :: (Monoid m) => m -> (a -> m) -> NonEmpty a -> m
intersperseFoldMap :: forall m a. Monoid m => m -> (a -> m) -> NonEmpty a -> m
intersperseFoldMap m
a a -> m
b (a
c :| [a]
d) = a -> m
b a
c forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (forall a. Monoid a => a -> a -> a
mappend m
a forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. a -> m
b) [a]
d

unsnoc :: NonEmpty a -> (Maybe (NonEmpty a), a)
unsnoc :: forall a. NonEmpty a -> (Maybe (NonEmpty a), a)
unsnoc =
  let build1 :: NonEmpty t -> (Maybe (NonEmpty t), t)
build1 = \case
        t
a :| [t]
b -> forall {t}. t -> [t] -> (Maybe (NonEmpty t), t)
build2 t
a [t]
b
      build2 :: t -> [t] -> (Maybe (NonEmpty t), t)
build2 t
a = \case
        t
b : [t]
c -> forall {t}. t -> NonEmpty t -> [t] -> (Maybe (NonEmpty t), t)
build3 t
b (t
a forall a. a -> [a] -> NonEmpty a
:| []) [t]
c
        [t]
_ -> (forall a. Maybe a
Nothing, t
a)
      build3 :: t -> NonEmpty t -> [t] -> (Maybe (NonEmpty t), t)
build3 t
a NonEmpty t
b = \case
        t
c : [t]
d -> t -> NonEmpty t -> [t] -> (Maybe (NonEmpty t), t)
build3 t
c (forall a. a -> NonEmpty a -> NonEmpty a
cons t
a NonEmpty t
b) [t]
d
        [t]
_ -> (forall a. a -> Maybe a
Just (forall a. NonEmpty a -> NonEmpty a
reverse NonEmpty t
b), t
a)
   in forall a. NonEmpty a -> (Maybe (NonEmpty a), a)
build1

consAndUnsnoc :: a -> NonEmpty a -> (NonEmpty a, a)
consAndUnsnoc :: forall a. a -> NonEmpty a -> (NonEmpty a, a)
consAndUnsnoc a
a NonEmpty a
b = case forall a. NonEmpty a -> (Maybe (NonEmpty a), a)
unsnoc NonEmpty a
b of
  (Maybe (NonEmpty a)
c, a
d) -> case Maybe (NonEmpty a)
c of
    Just NonEmpty a
e -> (forall a. a -> NonEmpty a -> NonEmpty a
cons a
a NonEmpty a
e, a
d)
    Maybe (NonEmpty a)
Nothing -> (forall (f :: * -> *) a. Applicative f => a -> f a
pure a
a, a
d)