module UVMHS.Core.Data.String where

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

import UVMHS.Core.Data.Arithmetic ()

import qualified Data.Text                 as Text
import qualified Data.Text.Internal.Fusion as TextI
import qualified Data.Text.Lazy            as TextLazy
import qualified Data.Text.Lazy.Builder    as TextBuilder
import qualified Prelude                   as HS

instance Null 𝕊 where
  null :: 𝕊
null = 𝕊
Text.empty
instance Append 𝕊 where
  ⧺ :: 𝕊 -> 𝕊 -> 𝕊
(⧺) = 𝕊 -> 𝕊 -> 𝕊
Text.append
instance Monoid 𝕊

instance Single ℂ 𝕊 where
  single :: ℂ -> 𝕊
single = ℂ -> 𝕊
Text.singleton

instance ToIter ℂ 𝕊 where
  iter :: 𝕊 -> 𝐼 ℂ
iter 𝕊
cs = (forall b. (ℂ -> b -> (b -> b) -> b) -> b -> (b -> b) -> b) -> 𝐼 ℂ
forall a.
(forall b. (a -> b -> (b -> b) -> b) -> b -> (b -> b) -> b) -> 𝐼 a
𝐼 ((forall b. (ℂ -> b -> (b -> b) -> b) -> b -> (b -> b) -> b)
 -> 𝐼 ℂ)
-> (forall b. (ℂ -> b -> (b -> b) -> b) -> b -> (b -> b) -> b)
-> 𝐼 ℂ
forall a b. (a -> b) -> a -> b
HS.$ \ ℂ -> b -> (b -> b) -> b
f → ((b -> b) -> b -> b) -> b -> (b -> b) -> b
forall a b c. (a -> b -> c) -> b -> a -> c
flip (((b -> b) -> b -> b) -> b -> (b -> b) -> b)
-> ((b -> b) -> b -> b) -> b -> (b -> b) -> b
forall a b. (a -> b) -> a -> b
$ \ b -> b
𝓀 →
    case 𝕊 -> Stream ℂ
TextI.stream 𝕊
cs of
      TextI.Stream s -> Step s ℂ
g s
s₀ Size
_ →
        let loop :: s -> b -> b
loop s
s b
i = case s -> Step s ℂ
g s
s of
              Step s ℂ
TextI.Done → b -> b
𝓀 b
i
              TextI.Skip s
s' → s -> b -> b
loop s
s' b
i
              TextI.Yield ℂ
c s
s' →
                ℂ -> b -> (b -> b) -> b
f ℂ
c b
i ((b -> b) -> b) -> (b -> b) -> b
forall a b. (a -> b) -> a -> b
$ \ b
i' →
                s -> b -> b
loop s
s' b
i'
        in s -> b -> b
loop s
s₀

instance Lookup ℕ ℂ 𝕊 where
  𝕊
s ⋕? :: 𝕊 -> ℕ -> 𝑂 ℂ
⋕? ℕ
n
    | (ℕ
n ℕ -> ℕ -> 𝔹
forall a. Ord a => a -> a -> 𝔹
> ℕ
0) 𝔹 -> 𝔹 -> 𝔹
⩓ (ℕ
n ℕ -> ℕ -> 𝔹
forall a. Ord a => a -> a -> 𝔹
≤ 𝕊 -> ℕ
length𝕊 𝕊
s) = ℂ -> 𝑂 ℂ
forall a. a -> 𝑂 a
Some (ℂ -> 𝑂 ℂ) -> ℂ -> 𝑂 ℂ
forall a b. (a -> b) -> a -> b
$ HasCallStack => 𝕊 -> Int -> ℂ
𝕊 -> Int -> ℂ
Text.index 𝕊
s (Int -> ℂ) -> Int -> ℂ
forall a b. (a -> b) -> a -> b
$ ℕ -> Int
forall a b. (Integral a, Num b) => a -> b
HS.fromIntegral (ℕ -> Int) -> ℕ -> Int
forall a b. (a -> b) -> a -> b
$ ℕ
n ℕ -> ℕ -> ℕ
forall a. Minus a => a -> a -> a
- ℕ
1
    | 𝔹
otherwise = 𝑂 ℂ
forall a. 𝑂 a
None

empty𝕊 ∷ 𝕊 → 𝔹
empty𝕊 :: 𝕊 -> 𝔹
empty𝕊 = 𝕊 -> 𝔹
Text.null

single𝕊 ∷ ℂ → 𝕊
single𝕊 :: ℂ -> 𝕊
single𝕊 = ℂ -> 𝕊
Text.singleton

build𝕊C ∷ (ToIter ℂ t) ⇒ t → 𝕊
build𝕊C :: forall t. ToIter ℂ t => t -> 𝕊
build𝕊C = String -> 𝕊
Text.pack (String -> 𝕊) -> (𝐼 ℂ -> String) -> 𝐼 ℂ -> 𝕊
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ 𝐼 ℂ -> String
forall a. 𝐼 a -> [a]
lazyList𝐼 (𝐼 ℂ -> 𝕊) -> (t -> 𝐼 ℂ) -> t -> 𝕊
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ t -> 𝐼 ℂ
forall a t. ToIter a t => t -> 𝐼 a
iter

build𝕊S ∷ (ToIter 𝕊 t) ⇒ t → 𝕊
build𝕊S :: forall t. ToIter 𝕊 t => t -> 𝕊
build𝕊S = LazyText -> 𝕊
TextLazy.toStrict (LazyText -> 𝕊) -> (Builder -> LazyText) -> Builder -> 𝕊
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ Builder -> LazyText
TextBuilder.toLazyText (Builder -> 𝕊) -> (𝐼 𝕊 -> Builder) -> 𝐼 𝕊 -> 𝕊
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ Builder -> (𝕊 -> Builder -> Builder) -> 𝐼 𝕊 -> Builder
forall b a. b -> (a -> b -> b) -> 𝐼 a -> b
foldr𝐼 Builder
forall a. Monoid a => a
HS.mempty (Builder -> Builder -> Builder
forall a. Monoid a => a -> a -> a
HS.mappend (Builder -> Builder -> Builder)
-> (𝕊 -> Builder) -> 𝕊 -> Builder -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ 𝕊 -> Builder
TextBuilder.fromText) (𝐼 𝕊 -> 𝕊) -> (t -> 𝐼 𝕊) -> t -> 𝕊
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ t -> 𝐼 𝕊
forall a t. ToIter a t => t -> 𝐼 a
iter

build𝕊CN ∷ (ToIter ℂ t) ⇒ ℕ64 → t → 𝕊
build𝕊CN :: forall t. ToIter ℂ t => ℕ64 -> t -> 𝕊
build𝕊CN ℕ64
n = LazyText -> 𝕊
TextLazy.toStrict (LazyText -> 𝕊) -> (Builder -> LazyText) -> Builder -> 𝕊
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ Int -> Builder -> LazyText
TextBuilder.toLazyTextWith (ℕ64 -> Int
forall a b. (Integral a, Num b) => a -> b
HS.fromIntegral ℕ64
n) (Builder -> 𝕊) -> (𝐼 ℂ -> Builder) -> 𝐼 ℂ -> 𝕊
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ Builder -> (ℂ -> Builder -> Builder) -> 𝐼 ℂ -> Builder
forall b a. b -> (a -> b -> b) -> 𝐼 a -> b
foldr𝐼 Builder
forall a. Monoid a => a
HS.mempty (Builder -> Builder -> Builder
forall a. Monoid a => a -> a -> a
HS.mappend (Builder -> Builder -> Builder)
-> (ℂ -> Builder) -> ℂ -> Builder -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ ℂ -> Builder
TextBuilder.singleton) (𝐼 ℂ -> 𝕊) -> (t -> 𝐼 ℂ) -> t -> 𝕊
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ t -> 𝐼 ℂ
forall a t. ToIter a t => t -> 𝐼 a
iter

build𝕊SN ∷ (ToIter 𝕊 t) ⇒ ℕ64 → t → 𝕊
build𝕊SN :: forall t. ToIter 𝕊 t => ℕ64 -> t -> 𝕊
build𝕊SN ℕ64
n = LazyText -> 𝕊
TextLazy.toStrict (LazyText -> 𝕊) -> (Builder -> LazyText) -> Builder -> 𝕊
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ Int -> Builder -> LazyText
TextBuilder.toLazyTextWith (ℕ64 -> Int
forall a b. (Integral a, Num b) => a -> b
HS.fromIntegral ℕ64
n) (Builder -> 𝕊) -> (𝐼 𝕊 -> Builder) -> 𝐼 𝕊 -> 𝕊
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ Builder -> (𝕊 -> Builder -> Builder) -> 𝐼 𝕊 -> Builder
forall b a. b -> (a -> b -> b) -> 𝐼 a -> b
foldr𝐼 Builder
forall a. Monoid a => a
HS.mempty (Builder -> Builder -> Builder
forall a. Monoid a => a -> a -> a
HS.mappend (Builder -> Builder -> Builder)
-> (𝕊 -> Builder) -> 𝕊 -> Builder -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ 𝕊 -> Builder
TextBuilder.fromText) (𝐼 𝕊 -> 𝕊) -> (t -> 𝐼 𝕊) -> t -> 𝕊
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ t -> 𝐼 𝕊
forall a t. ToIter a t => t -> 𝐼 a
iter

show𝕊 ∷ (Show a) ⇒ a → 𝕊
show𝕊 :: forall a. Show a => a -> 𝕊
show𝕊 = String -> 𝕊
frhsChars (String -> 𝕊) -> (a -> String) -> a -> 𝕊
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ a -> String
forall a. Show a => a -> String
HS.show

read𝕊 ∷ (HS.Read a) ⇒ 𝕊 → a
read𝕊 :: forall a. Read a => 𝕊 -> a
read𝕊 = String -> a
forall a. Read a => String -> a
HS.read (String -> a) -> (𝕊 -> String) -> 𝕊 -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ 𝕊 -> String
tohsChars

lower𝕊 ∷ 𝕊 → 𝕊
lower𝕊 :: 𝕊 -> 𝕊
lower𝕊 = 𝕊 -> 𝕊
Text.toLower

upper𝕊 ∷ 𝕊 → 𝕊
upper𝕊 :: 𝕊 -> 𝕊
upper𝕊 = 𝕊 -> 𝕊
Text.toUpper

isEmpty𝕊 ∷ 𝕊 → 𝔹
isEmpty𝕊 :: 𝕊 -> 𝔹
isEmpty𝕊 = 𝕊 -> 𝔹
Text.null

length𝕊 ∷ 𝕊 → ℕ
length𝕊 :: 𝕊 -> ℕ
length𝕊 = ℤ64 -> ℕ
forall a. (ToNatO a, HasCallStack) => a -> ℕ
natΩ (ℤ64 -> ℕ) -> (Int -> ℤ64) -> Int -> ℕ
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ Int -> ℤ64
forall a b. CHS a b => b -> a
frhs (Int -> ℕ) -> (𝕊 -> Int) -> 𝕊 -> ℕ
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ 𝕊 -> Int
Text.length

length64𝕊 ∷ 𝕊 → ℕ64
length64𝕊 :: 𝕊 -> ℕ64
length64𝕊 = ℤ64 -> ℕ64
forall a. (ToNatO64 a, HasCallStack) => a -> ℕ64
natΩ64 (ℤ64 -> ℕ64) -> (Int -> ℤ64) -> Int -> ℕ64
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ Int -> ℤ64
forall a b. CHS a b => b -> a
frhs (Int -> ℕ64) -> (𝕊 -> Int) -> 𝕊 -> ℕ64
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ 𝕊 -> Int
Text.length

splitOn𝕊 ∷ 𝕊 → 𝕊 → 𝐼 𝕊
splitOn𝕊 :: 𝕊 -> 𝕊 -> 𝐼 𝕊
splitOn𝕊 𝕊
i 𝕊
s = [𝕊] -> 𝐼 𝕊
forall a. [a] -> 𝐼 a
iterLL ([𝕊] -> 𝐼 𝕊) -> [𝕊] -> 𝐼 𝕊
forall a b. (a -> b) -> a -> b
$ HasCallStack => 𝕊 -> 𝕊 -> [𝕊]
𝕊 -> 𝕊 -> [𝕊]
Text.splitOn 𝕊
i 𝕊
s

replace𝕊 ∷ 𝕊 → 𝕊 → 𝕊 → 𝕊
replace𝕊 :: 𝕊 -> 𝕊 -> 𝕊 -> 𝕊
replace𝕊 = HasCallStack => 𝕊 -> 𝕊 -> 𝕊 -> 𝕊
𝕊 -> 𝕊 -> 𝕊 -> 𝕊
Text.replace