module Mit.Seq1 where

import Data.Coerce
import qualified Data.Foldable
import Data.Sequence (Seq)
import qualified Data.Sequence as Seq
import Prelude

newtype Seq1 a = Seq1
  {Seq1 a -> Seq a
unSeq1 :: Seq a}
  deriving newtype (a -> Seq1 a -> Bool
Seq1 m -> m
Seq1 a -> [a]
Seq1 a -> Bool
Seq1 a -> Int
Seq1 a -> a
Seq1 a -> a
Seq1 a -> a
Seq1 a -> a
(a -> m) -> Seq1 a -> m
(a -> m) -> Seq1 a -> m
(a -> b -> b) -> b -> Seq1 a -> b
(a -> b -> b) -> b -> Seq1 a -> b
(b -> a -> b) -> b -> Seq1 a -> b
(b -> a -> b) -> b -> Seq1 a -> b
(a -> a -> a) -> Seq1 a -> a
(a -> a -> a) -> Seq1 a -> a
(forall m. Monoid m => Seq1 m -> m)
-> (forall m a. Monoid m => (a -> m) -> Seq1 a -> m)
-> (forall m a. Monoid m => (a -> m) -> Seq1 a -> m)
-> (forall a b. (a -> b -> b) -> b -> Seq1 a -> b)
-> (forall a b. (a -> b -> b) -> b -> Seq1 a -> b)
-> (forall b a. (b -> a -> b) -> b -> Seq1 a -> b)
-> (forall b a. (b -> a -> b) -> b -> Seq1 a -> b)
-> (forall a. (a -> a -> a) -> Seq1 a -> a)
-> (forall a. (a -> a -> a) -> Seq1 a -> a)
-> (forall a. Seq1 a -> [a])
-> (forall a. Seq1 a -> Bool)
-> (forall a. Seq1 a -> Int)
-> (forall a. Eq a => a -> Seq1 a -> Bool)
-> (forall a. Ord a => Seq1 a -> a)
-> (forall a. Ord a => Seq1 a -> a)
-> (forall a. Num a => Seq1 a -> a)
-> (forall a. Num a => Seq1 a -> a)
-> Foldable Seq1
forall a. Eq a => a -> Seq1 a -> Bool
forall a. Num a => Seq1 a -> a
forall a. Ord a => Seq1 a -> a
forall m. Monoid m => Seq1 m -> m
forall a. Seq1 a -> Bool
forall a. Seq1 a -> Int
forall a. Seq1 a -> [a]
forall a. (a -> a -> a) -> Seq1 a -> a
forall m a. Monoid m => (a -> m) -> Seq1 a -> m
forall b a. (b -> a -> b) -> b -> Seq1 a -> b
forall a b. (a -> b -> b) -> b -> Seq1 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 :: Seq1 a -> a
$cproduct :: forall a. Num a => Seq1 a -> a
sum :: Seq1 a -> a
$csum :: forall a. Num a => Seq1 a -> a
minimum :: Seq1 a -> a
$cminimum :: forall a. Ord a => Seq1 a -> a
maximum :: Seq1 a -> a
$cmaximum :: forall a. Ord a => Seq1 a -> a
elem :: a -> Seq1 a -> Bool
$celem :: forall a. Eq a => a -> Seq1 a -> Bool
length :: Seq1 a -> Int
$clength :: forall a. Seq1 a -> Int
null :: Seq1 a -> Bool
$cnull :: forall a. Seq1 a -> Bool
toList :: Seq1 a -> [a]
$ctoList :: forall a. Seq1 a -> [a]
foldl1 :: (a -> a -> a) -> Seq1 a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Seq1 a -> a
foldr1 :: (a -> a -> a) -> Seq1 a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Seq1 a -> a
foldl' :: (b -> a -> b) -> b -> Seq1 a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Seq1 a -> b
foldl :: (b -> a -> b) -> b -> Seq1 a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Seq1 a -> b
foldr' :: (a -> b -> b) -> b -> Seq1 a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Seq1 a -> b
foldr :: (a -> b -> b) -> b -> Seq1 a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Seq1 a -> b
foldMap' :: (a -> m) -> Seq1 a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Seq1 a -> m
foldMap :: (a -> m) -> Seq1 a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Seq1 a -> m
fold :: Seq1 m -> m
$cfold :: forall m. Monoid m => Seq1 m -> m
Foldable)

dropEnd :: Int -> Seq1 a -> Seq a
dropEnd :: Int -> Seq1 a -> Seq a
dropEnd =
  let loop :: t -> Seq a -> Seq a
loop t
n =
        case t
n of
          t
0 -> Seq a -> Seq a
forall a. a -> a
id
          t
_ -> \case
            Seq a
Seq.Empty -> Seq a
forall a. Seq a
Seq.Empty
            Seq a
ys Seq.:|> a
_ -> t -> Seq a -> Seq a
loop (t
n t -> t -> t
forall a. Num a => a -> a -> a
-t
1) Seq a
ys
   in \Int
n (Seq1 Seq a
xs) -> Int -> Seq a -> Seq a
forall t a. (Eq t, Num t) => t -> Seq a -> Seq a
loop Int
n Seq a
xs

fromSeq :: Seq a -> Maybe (Seq1 a)
fromSeq :: Seq a -> Maybe (Seq1 a)
fromSeq = \case
  Seq a
Seq.Empty -> Maybe (Seq1 a)
forall a. Maybe a
Nothing
  Seq a
xs -> Seq1 a -> Maybe (Seq1 a)
forall a. a -> Maybe a
Just (Seq a -> Seq1 a
forall a. Seq a -> Seq1 a
Seq1 Seq a
xs)

length :: forall a. Seq1 a -> Int
length :: Seq1 a -> Int
length =
  (Seq a -> Int) -> Seq1 a -> Int
coerce (Seq a -> Int
forall a. Seq a -> Int
Seq.length @a)

toList :: forall a. Seq1 a -> [a]
toList :: Seq1 a -> [a]
toList =
  (Seq a -> [a]) -> Seq1 a -> [a]
coerce (Seq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Data.Foldable.toList @Seq @a)

toSeq :: Seq1 a -> Seq a
toSeq :: Seq1 a -> Seq a
toSeq =
  Seq1 a -> Seq a
coerce