module UVMHS.Core.Data.Sequence where

import UVMHS.Core.Init
import UVMHS.Core.Classes

import UVMHS.Core.Data.Iter
import UVMHS.Core.Data.Stream ()
import UVMHS.Core.Data.String

import qualified Prelude as HS
import qualified Data.Foldable as HS
import qualified Data.Sequence as Sequence

instance Null (𝑄 a) where 
  null :: 𝑄 a
null = 𝑄 a
forall a. 𝑄 a
qø
instance Append (𝑄 a) where 
  ⧺ :: 𝑄 a -> 𝑄 a -> 𝑄 a
(⧺) = 𝑄 a -> 𝑄 a -> 𝑄 a
forall a. 𝑄 a -> 𝑄 a -> 𝑄 a
append𝑄
instance Monoid (𝑄 a)
instance Single a (𝑄 a) where 
  single :: a -> 𝑄 a
single = a -> 𝑄 a
forall a. a -> 𝑄 a
single𝑄

instance Functor 𝑄 where 
  map :: forall a b. (a -> b) -> 𝑄 a -> 𝑄 b
map = (a -> b) -> 𝑄 a -> 𝑄 b
forall a b. (a -> b) -> 𝑄 a -> 𝑄 b
map𝑄
instance Return 𝑄 where 
  return :: forall a. a -> 𝑄 a
return = a -> 𝑄 a
forall a t. Single a t => a -> t
single
instance Bind 𝑄 where 
  ≫= :: forall a b. 𝑄 a -> (a -> 𝑄 b) -> 𝑄 b
(≫=) = 𝑄 a -> (a -> 𝑄 b) -> 𝑄 b
forall a b. 𝑄 a -> (a -> 𝑄 b) -> 𝑄 b
bind𝑄
instance Monad 𝑄

instance ToIter a (𝑄 a) where 
  iter :: 𝑄 a -> 𝐼 a
iter = 𝑄 a -> 𝐼 a
forall a. 𝑄 a -> 𝐼 a
iter𝑄

instance (Show a) ⇒ Show (𝑄 a) where 
  show :: 𝑄 a -> String
show = 𝕊 -> String
tohsChars (𝕊 -> String) -> (𝑄 a -> 𝕊) -> 𝑄 a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ 𝕊 -> 𝕊 -> 𝕊 -> (a -> 𝕊) -> 𝑄 a -> 𝕊
forall a t. ToIter a t => 𝕊 -> 𝕊 -> 𝕊 -> (a -> 𝕊) -> t -> 𝕊
showCollection 𝕊
"[" 𝕊
"]" 𝕊
"," a -> 𝕊
forall a. Show a => a -> 𝕊
show𝕊

qø ∷ 𝑄 a
qø :: forall a. 𝑄 a
qø = Seq a -> 𝑄 a
forall a. Seq a -> 𝑄 a
𝑄 Seq a
forall a. Seq a
Sequence.empty

cons𝑄 ∷ a → 𝑄 a → 𝑄 a
cons𝑄 :: forall a. a -> 𝑄 a -> 𝑄 a
cons𝑄 a
x 𝑄 a
xs = Seq a -> 𝑄 a
forall a. Seq a -> 𝑄 a
𝑄 (Seq a -> 𝑄 a) -> Seq a -> 𝑄 a
forall a b. (a -> b) -> a -> b
$ a
x a -> Seq a -> Seq a
forall a. a -> Seq a -> Seq a
Sequence.:<| 𝑄 a -> Seq a
forall a. 𝑄 a -> Seq a
un𝑄 𝑄 a
xs

uncons𝑄 ∷ 𝑄 a → 𝑂 (a ∧ 𝑄 a)
uncons𝑄 :: forall a. 𝑄 a -> 𝑂 (a ∧ 𝑄 a)
uncons𝑄 𝑄 a
xs = case Seq a -> ViewL a
forall a. Seq a -> ViewL a
Sequence.viewl (Seq a -> ViewL a) -> Seq a -> ViewL a
forall a b. (a -> b) -> a -> b
$ 𝑄 a -> Seq a
forall a. 𝑄 a -> Seq a
un𝑄 𝑄 a
xs of
  ViewL a
Sequence.EmptyL → 𝑂 (a ∧ 𝑄 a)
forall a. 𝑂 a
None
  a
x Sequence.:< Seq a
xs' → (a ∧ 𝑄 a) -> 𝑂 (a ∧ 𝑄 a)
forall a. a -> 𝑂 a
Some ((a ∧ 𝑄 a) -> 𝑂 (a ∧ 𝑄 a)) -> (a ∧ 𝑄 a) -> 𝑂 (a ∧ 𝑄 a)
forall a b. (a -> b) -> a -> b
$ a
x a -> 𝑄 a -> a ∧ 𝑄 a
forall a b. a -> b -> a ∧ b
:* Seq a -> 𝑄 a
forall a. Seq a -> 𝑄 a
𝑄 Seq a
xs'

snoc𝑄 ∷ 𝑄 a → a → 𝑄 a
snoc𝑄 :: forall a. 𝑄 a -> a -> 𝑄 a
snoc𝑄 𝑄 a
xs a
x = Seq a -> 𝑄 a
forall a. Seq a -> 𝑄 a
𝑄 (Seq a -> 𝑄 a) -> Seq a -> 𝑄 a
forall a b. (a -> b) -> a -> b
$ 𝑄 a -> Seq a
forall a. 𝑄 a -> Seq a
un𝑄 𝑄 a
xs Seq a -> a -> Seq a
forall a. Seq a -> a -> Seq a
Sequence.:|> a
x

unsnoc𝑄 ∷ 𝑄 a → 𝑂 (𝑄 a ∧ a)
unsnoc𝑄 :: forall a. 𝑄 a -> 𝑂 (𝑄 a ∧ a)
unsnoc𝑄 𝑄 a
xs = case Seq a -> ViewR a
forall a. Seq a -> ViewR a
Sequence.viewr (Seq a -> ViewR a) -> Seq a -> ViewR a
forall a b. (a -> b) -> a -> b
$ 𝑄 a -> Seq a
forall a. 𝑄 a -> Seq a
un𝑄 𝑄 a
xs of
  ViewR a
Sequence.EmptyR → 𝑂 (𝑄 a ∧ a)
forall a. 𝑂 a
None
  Seq a
xs' Sequence.:> a
x → (𝑄 a ∧ a) -> 𝑂 (𝑄 a ∧ a)
forall a. a -> 𝑂 a
Some ((𝑄 a ∧ a) -> 𝑂 (𝑄 a ∧ a)) -> (𝑄 a ∧ a) -> 𝑂 (𝑄 a ∧ a)
forall a b. (a -> b) -> a -> b
$ Seq a -> 𝑄 a
forall a. Seq a -> 𝑄 a
𝑄 Seq a
xs' 𝑄 a -> a -> 𝑄 a ∧ a
forall a b. a -> b -> a ∧ b
:* a
x

single𝑄 ∷ a → 𝑄 a
single𝑄 :: forall a. a -> 𝑄 a
single𝑄 = Seq a -> 𝑄 a
forall a. Seq a -> 𝑄 a
𝑄 (Seq a -> 𝑄 a) -> (a -> Seq a) -> a -> 𝑄 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ a -> Seq a
forall a. a -> Seq a
Sequence.singleton

append𝑄 ∷ 𝑄 a → 𝑄 a → 𝑄 a
append𝑄 :: forall a. 𝑄 a -> 𝑄 a -> 𝑄 a
append𝑄 𝑄 a
xs 𝑄 a
ys = Seq a -> 𝑄 a
forall a. Seq a -> 𝑄 a
𝑄 (Seq a -> 𝑄 a) -> Seq a -> 𝑄 a
forall a b. (a -> b) -> a -> b
$ 𝑄 a -> Seq a
forall a. 𝑄 a -> Seq a
un𝑄 𝑄 a
xs Seq a -> Seq a -> Seq a
forall a. Seq a -> Seq a -> Seq a
Sequence.>< 𝑄 a -> Seq a
forall a. 𝑄 a -> Seq a
un𝑄 𝑄 a
ys

map𝑄 ∷ (a → b) → 𝑄 a → 𝑄 b
map𝑄 :: forall a b. (a -> b) -> 𝑄 a -> 𝑄 b
map𝑄 a -> b
f = Seq b -> 𝑄 b
forall a. Seq a -> 𝑄 a
𝑄 (Seq b -> 𝑄 b) -> (Seq a -> Seq b) -> Seq a -> 𝑄 b
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ (a -> b) -> Seq a -> Seq b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
HS.fmap a -> b
f (Seq a -> 𝑄 b) -> (𝑄 a -> Seq a) -> 𝑄 a -> 𝑄 b
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ 𝑄 a -> Seq a
forall a. 𝑄 a -> Seq a
un𝑄

bind𝑄 ∷ 𝑄 a → (a → 𝑄 b) → 𝑄 b
bind𝑄 :: forall a b. 𝑄 a -> (a -> 𝑄 b) -> 𝑄 b
bind𝑄 𝑄 a
xs a -> 𝑄 b
f = Seq b -> 𝑄 b
forall a. Seq a -> 𝑄 a
𝑄 (Seq b -> 𝑄 b) -> Seq b -> 𝑄 b
forall a b. (a -> b) -> a -> b
$ 𝑄 a -> Seq a
forall a. 𝑄 a -> Seq a
un𝑄 𝑄 a
xs Seq a -> (a -> Seq b) -> Seq b
forall a b. Seq a -> (a -> Seq b) -> Seq b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
HS.>>= (𝑄 b -> Seq b
forall a. 𝑄 a -> Seq a
un𝑄 (𝑄 b -> Seq b) -> (a -> 𝑄 b) -> a -> Seq b
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ a -> 𝑄 b
f)

iter𝑄 ∷ 𝑄 a → 𝐼 a
iter𝑄 :: forall a. 𝑄 a -> 𝐼 a
iter𝑄 = [a] -> 𝐼 a
forall a. [a] -> 𝐼 a
iterLL ([a] -> 𝐼 a) -> (Seq a -> [a]) -> Seq a -> 𝐼 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ Seq a -> [a]
forall a. Seq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
HS.toList (Seq a -> 𝐼 a) -> (𝑄 a -> Seq a) -> 𝑄 a -> 𝐼 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ 𝑄 a -> Seq a
forall a. 𝑄 a -> Seq a
un𝑄

seq𝐼 ∷ 𝐼 a → 𝑄 a
seq𝐼 :: forall a. 𝐼 a -> 𝑄 a
seq𝐼 = Seq a -> 𝑄 a
forall a. Seq a -> 𝑄 a
𝑄 (Seq a -> 𝑄 a) -> ([a] -> Seq a) -> [a] -> 𝑄 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ [a] -> Seq a
forall a. [a] -> Seq a
Sequence.fromList ([a] -> 𝑄 a) -> (𝐼 a -> [a]) -> 𝐼 a -> 𝑄 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ 𝐼 a -> [a]
forall a t. ToIter a t => t -> [a]
lazyList

seq ∷ (ToIter a t) ⇒ t → 𝑄 a
seq :: forall a t. ToIter a t => t -> 𝑄 a
seq = 𝐼 a -> 𝑄 a
forall a. 𝐼 a -> 𝑄 a
seq𝐼 (𝐼 a -> 𝑄 a) -> (t -> 𝐼 a) -> t -> 𝑄 a
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ t -> 𝐼 a
forall a t. ToIter a t => t -> 𝐼 a
iter