{-# LANGUAGE NoImplicitPrelude, MultiParamTypeClasses, FlexibleInstances #-}
{-# OPTIONS -fno-warn-orphans #-}
{-# LANGUAGE CPP #-}

-- | 'Data.ListLike.ListLike' instances for 'Data.DList.DList'

module Data.ListLike.DList () where

import qualified Prelude

import Data.ListLike.Base
import Data.ListLike.FoldableLL
import Data.ListLike.String
#if MIN_VERSION_dlist(1,0,0)
import Data.DList.Unsafe (DList(UnsafeDList), unsafeApplyDList)
#else
import Data.DList (DList)
#endif
import qualified Data.DList as D
import qualified Data.Foldable as F
import qualified Data.List as List
import qualified Data.String as S
import Control.Category
import Data.Char (Char)


instance FoldableLL (DList a) a where
  foldl :: forall a. (a -> a -> a) -> a -> DList a -> a
foldl = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl
  foldr :: forall b. (a -> b -> b) -> b -> DList a -> b
foldr = forall a b. (a -> b -> b) -> b -> DList a -> b
D.foldr
  foldl1 :: (a -> a -> a) -> DList a -> a
foldl1 = forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
F.foldl1
  foldr1 :: (a -> a -> a) -> DList a -> a
foldr1 = forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
F.foldr1
  foldl' :: forall a. (a -> a -> a) -> a -> DList a -> a
foldl' = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl'
  foldr' :: forall b. (a -> b -> b) -> b -> DList a -> b
foldr' = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
F.foldr'

instance ListLike (DList a) a where
  empty :: DList a
empty = forall a. DList a
D.empty
  singleton :: a -> DList a
singleton = forall a. a -> DList a
D.singleton
  cons :: a -> DList a -> DList a
cons = forall a. a -> DList a -> DList a
D.cons
  snoc :: DList a -> a -> DList a
snoc = forall a. DList a -> a -> DList a
D.snoc
  append :: DList a -> DList a -> DList a
append = forall a. DList a -> DList a -> DList a
D.append
  head :: DList a -> a
head = forall a. DList a -> a
D.head
#if MIN_VERSION_dlist(1,0,0)
  -- Andreas Abel, 2021-09-01, issue #14,
  -- work around https://github.com/spl/dlist/issues/98:
  --
  -- dlist-1.0 changed @tail@ so that it is not an operation
  -- on difference lists anymore, but collapses the difference list
  -- into a plain list.
  --
  -- The following tail function restores the spirit of difference
  -- lists, at the cost of breaking data abstraction, i.e.,
  -- using the constructor and destructor of the newtype DList.
  -- Andreas Abel, 2023-10-10, issue #32:
  -- Use @drop 1@ instead of @tail@ as the latter triggers the x-partial warning in GHC 9.8.
  tail :: DList a -> DList a
tail = forall a. ([a] -> [a]) -> DList a
UnsafeDList forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. (forall a. Int -> [a] -> [a]
List.drop Int
1 forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
.) forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. DList a -> [a] -> [a]
unsafeApplyDList
#else
  tail = D.tail
#endif
  rigidMap :: (a -> a) -> DList a -> DList a
rigidMap = forall a b. (a -> b) -> DList a -> DList b
D.map
  null :: DList a -> Bool
null = forall full item. ListLike full item => full -> Bool
null forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. DList a -> [a]
D.toList
  --toList = D.toList
  --fromList = D.fromList
  replicate :: Int -> a -> DList a
replicate = forall a. Int -> a -> DList a
D.replicate
  uncons :: DList a -> Maybe (a, DList a)
uncons DList a
xs = case DList a
xs of
    DList a
D.Nil -> forall a. Maybe a
Prelude.Nothing
    D.Cons a
d_head [a]
l_tail -> forall a. a -> Maybe a
Prelude.Just (a
d_head,forall l. IsList l => [Item l] -> l
fromList [a]
l_tail)
    DList a
_ -> forall a. HasCallStack => [Char] -> a
Prelude.error [Char]
"Workaround for missing COMPLETE pragma on dlist patterns"


instance StringLike (DList Char) where
  toString :: DList Char -> [Char]
toString = forall a. DList a -> [a]
D.toList
  -- fromString = D.fromList
  lines :: forall full. ListLike full (DList Char) => DList Char -> full
lines = forall full item full' item'.
(ListLike full item, ListLike full' item') =>
(item -> item') -> full -> full'
map forall a. [a] -> DList a
D.fromList forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. [Char] -> [[Char]]
S.lines forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. DList a -> [a]
D.toList
  words :: forall full. ListLike full (DList Char) => DList Char -> full
words = forall full item full' item'.
(ListLike full item, ListLike full' item') =>
(item -> item') -> full -> full'
map forall a. [a] -> DList a
D.fromList forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. [Char] -> [[Char]]
S.words forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. DList a -> [a]
D.toList
  unlines :: forall full. ListLike full (DList Char) => full -> DList Char
unlines = forall a. [a] -> DList a
D.fromList forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. [[Char]] -> [Char]
S.unlines forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall full item full' item'.
(ListLike full item, ListLike full' item') =>
(item -> item') -> full -> full'
map forall a. DList a -> [a]
D.toList
  unwords :: forall full. ListLike full (DList Char) => full -> DList Char
unwords = forall a. [a] -> DList a
D.fromList forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. [[Char]] -> [Char]
S.unwords forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall full item full' item'.
(ListLike full item, ListLike full' item') =>
(item -> item') -> full -> full'
map forall a. DList a -> [a]
D.toList