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 = Text -> π•Š
TextLazy.toStrict (Text -> π•Š) -> (Builder -> Text) -> Builder -> π•Š
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ Builder -> Text
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 = Text -> π•Š
TextLazy.toStrict (Text -> π•Š) -> (Builder -> Text) -> Builder -> π•Š
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ Int -> Builder -> Text
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 = Text -> π•Š
TextLazy.toStrict (Text -> π•Š) -> (Builder -> Text) -> Builder -> π•Š
forall b c a. (b -> c) -> (a -> b) -> a -> c
∘ Int -> Builder -> Text
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