module ASCII.CaseRefinement
(
ASCII'case, lift, asciiCaseUnsafe,
ASCII'upper, ASCII'lower,
validateChar, fromCaselessChar,
toCaselessChar, substituteChar, asCaselessChar, refineCharToCase,
validateString, fromCaselessCharList,
toCaselessCharList, substituteString, mapChars, refineStringToCase,
KnownCase (..),
)
where
import ASCII.Case (Case (..))
import ASCII.Caseless (CaselessChar)
import {-# source #-} ASCII.Refinement (ASCII)
import ASCII.Superset (CharSuperset, StringSuperset)
import qualified ASCII.Case as Case
import qualified ASCII.Caseless as Caseless
import qualified ASCII.Char as ASCII
import qualified ASCII.Superset as Superset
import {-# source #-} qualified ASCII.Refinement as Refinement
import Control.Monad (guard)
import Data.Bool (Bool (..))
import Data.Data (Data, Typeable)
import Data.Eq (Eq)
import Data.Foldable (any)
import Data.Function (id, ($), (.))
import Data.Hashable (Hashable)
import Data.Maybe (Maybe (..))
import Data.Monoid (Monoid)
import Data.Ord (Ord, (>))
import Data.Semigroup (Semigroup)
import Data.Traversable (traverse)
import GHC.Generics (Generic)
import Prelude (succ)
import Text.Show (Show, showList, showParen, showString, showsPrec)
import qualified Data.Bool as Bool
import qualified Data.List as List
newtype ASCII'case (letterCase :: Case) superset = ASCII'case_Unsafe
{ forall (letterCase :: Case) superset.
ASCII'case letterCase superset -> superset
lift :: superset
}
deriving stock instance Eq superset =>
Eq (ASCII'case letterCase superset)
deriving stock instance Ord superset =>
Ord (ASCII'case letterCase superset)
deriving newtype instance Hashable superset =>
Hashable (ASCII'case letterCase superset)
deriving newtype instance Semigroup superset =>
Semigroup (ASCII'case letterCase superset)
deriving newtype instance Monoid superset =>
Monoid (ASCII'case letterCase superset)
deriving stock instance (Data superset, Typeable letterCase) =>
Data (ASCII'case letterCase superset)
deriving stock instance Generic (ASCII'case letterCase superset)
instance Show superset => Show (ASCII'case letterCase superset) where
showsPrec :: Int -> ASCII'case letterCase superset -> ShowS
showsPrec Int
d ASCII'case letterCase superset
x = Bool -> ShowS -> ShowS
showParen (Int
d forall a. Ord a => a -> a -> Bool
> Int
app_prec) forall a b. (a -> b) -> a -> b
$
String -> ShowS
showString String
"asciiCaseUnsafe " forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => Int -> a -> ShowS
showsPrec (forall a. Enum a => a -> a
succ Int
app_prec) (forall (letterCase :: Case) superset.
ASCII'case letterCase superset -> superset
lift ASCII'case letterCase superset
x)
where app_prec :: Int
app_prec = Int
10
showList :: [ASCII'case letterCase superset] -> ShowS
showList [ASCII'case letterCase superset]
x = String -> ShowS
showString String
"asciiCaseUnsafe " forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => [a] -> ShowS
showList (forall a b. (a -> b) -> [a] -> [b]
List.map forall (letterCase :: Case) superset.
ASCII'case letterCase superset -> superset
lift [ASCII'case letterCase superset]
x)
asciiCaseUnsafe :: superset -> ASCII'case letterCase superset
asciiCaseUnsafe :: forall superset (letterCase :: Case).
superset -> ASCII'case letterCase superset
asciiCaseUnsafe = forall (letterCase :: Case) superset.
superset -> ASCII'case letterCase superset
ASCII'case_Unsafe
type ASCII'upper superset = ASCII'case 'UpperCase superset
type ASCII'lower superset = ASCII'case 'LowerCase superset
class KnownCase (letterCase :: Case) where theCase :: Case
instance KnownCase 'UpperCase where theCase :: Case
theCase = Case
UpperCase
instance KnownCase 'LowerCase where theCase :: Case
theCase = Case
LowerCase
validateChar :: forall letterCase superset. KnownCase letterCase => CharSuperset superset =>
superset
-> Maybe (ASCII'case letterCase superset)
validateChar :: forall (letterCase :: Case) superset.
(KnownCase letterCase, CharSuperset superset) =>
superset -> Maybe (ASCII'case letterCase superset)
validateChar superset
x = do
Char
c <- forall char. ToChar char => char -> Maybe Char
Superset.toCharMaybe superset
x
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Bool
Bool.not (Case -> Char -> Bool
Case.isCase (Case -> Case
Case.opposite (forall (letterCase :: Case). KnownCase letterCase => Case
theCase @letterCase)) Char
c))
forall a. a -> Maybe a
Just (forall superset (letterCase :: Case).
superset -> ASCII'case letterCase superset
asciiCaseUnsafe superset
x)
substituteChar :: forall letterCase superset. KnownCase letterCase => CharSuperset superset =>
superset
-> ASCII'case letterCase superset
substituteChar :: forall (letterCase :: Case) superset.
(KnownCase letterCase, CharSuperset superset) =>
superset -> ASCII'case letterCase superset
substituteChar superset
x = case forall (letterCase :: Case) superset.
(KnownCase letterCase, CharSuperset superset) =>
superset -> Maybe (ASCII'case letterCase superset)
validateChar superset
x of
Maybe (ASCII'case letterCase superset)
Nothing -> forall superset (letterCase :: Case).
superset -> ASCII'case letterCase superset
asciiCaseUnsafe (forall char. FromChar char => Char -> char
Superset.fromChar Char
ASCII.Substitute)
Just ASCII'case letterCase superset
c -> ASCII'case letterCase superset
c
fromCaselessChar :: forall letterCase superset. KnownCase letterCase => CharSuperset superset =>
CaselessChar
-> ASCII'case letterCase superset
fromCaselessChar :: forall (letterCase :: Case) superset.
(KnownCase letterCase, CharSuperset superset) =>
CaselessChar -> ASCII'case letterCase superset
fromCaselessChar = forall superset (letterCase :: Case).
superset -> ASCII'case letterCase superset
asciiCaseUnsafe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall char. FromChar char => Char -> char
Superset.fromChar forall b c a. (b -> c) -> (a -> b) -> a -> c
. Case -> CaselessChar -> Char
Caseless.toCase (forall (letterCase :: Case). KnownCase letterCase => Case
theCase @letterCase)
toCaselessChar :: CharSuperset superset =>
ASCII'case letterCase superset
-> CaselessChar
toCaselessChar :: forall superset (letterCase :: Case).
CharSuperset superset =>
ASCII'case letterCase superset -> CaselessChar
toCaselessChar = Char -> CaselessChar
Caseless.disregardCase forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall char. ToChar char => char -> Char
Superset.toCharUnsafe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (letterCase :: Case) superset.
ASCII'case letterCase superset -> superset
lift
asCaselessChar :: forall letterCase superset. KnownCase letterCase => CharSuperset superset =>
(CaselessChar -> CaselessChar)
-> ASCII'case letterCase superset
-> ASCII'case letterCase superset
asCaselessChar :: forall (letterCase :: Case) superset.
(KnownCase letterCase, CharSuperset superset) =>
(CaselessChar -> CaselessChar)
-> ASCII'case letterCase superset -> ASCII'case letterCase superset
asCaselessChar CaselessChar -> CaselessChar
f = forall superset (letterCase :: Case).
superset -> ASCII'case letterCase superset
asciiCaseUnsafe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall char. CharSuperset char => (Char -> Char) -> char -> char
Superset.asCharUnsafe Char -> Char
g forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (letterCase :: Case) superset.
ASCII'case letterCase superset -> superset
lift
where
g :: Char -> Char
g = Case -> CaselessChar -> Char
Caseless.toCase (forall (letterCase :: Case). KnownCase letterCase => Case
theCase @letterCase) forall b c a. (b -> c) -> (a -> b) -> a -> c
. CaselessChar -> CaselessChar
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. Case -> Char -> CaselessChar
Caseless.assumeCaseUnsafe (forall (letterCase :: Case). KnownCase letterCase => Case
theCase @letterCase)
refineCharToCase :: forall letterCase char. KnownCase letterCase => CharSuperset char =>
ASCII char -> ASCII'case letterCase char
refineCharToCase :: forall (letterCase :: Case) char.
(KnownCase letterCase, CharSuperset char) =>
ASCII char -> ASCII'case letterCase char
refineCharToCase = forall superset (letterCase :: Case).
superset -> ASCII'case letterCase superset
asciiCaseUnsafe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall char. CharSuperset char => Case -> char -> char
Superset.toCaseChar (forall (letterCase :: Case). KnownCase letterCase => Case
theCase @letterCase) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall superset. ASCII superset -> superset
Refinement.lift
validateString :: forall letterCase superset. KnownCase letterCase => StringSuperset superset =>
superset
-> Maybe (ASCII'case letterCase superset)
validateString :: forall (letterCase :: Case) superset.
(KnownCase letterCase, StringSuperset superset) =>
superset -> Maybe (ASCII'case letterCase superset)
validateString superset
x = do
[Char]
s <- forall string. ToString string => string -> Maybe [Char]
Superset.toCharListMaybe superset
x
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Bool
Bool.not (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Case -> Char -> Bool
Case.isCase (Case -> Case
Case.opposite (forall (letterCase :: Case). KnownCase letterCase => Case
theCase @letterCase))) [Char]
s))
forall a. a -> Maybe a
Just (forall superset (letterCase :: Case).
superset -> ASCII'case letterCase superset
asciiCaseUnsafe superset
x)
fromCaselessCharList :: forall letterCase superset. KnownCase letterCase => StringSuperset superset =>
[CaselessChar]
-> ASCII'case letterCase superset
fromCaselessCharList :: forall (letterCase :: Case) superset.
(KnownCase letterCase, StringSuperset superset) =>
[CaselessChar] -> ASCII'case letterCase superset
fromCaselessCharList = forall superset (letterCase :: Case).
superset -> ASCII'case letterCase superset
asciiCaseUnsafe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall string. FromString string => [Char] -> string
Superset.fromCharList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
List.map (Case -> CaselessChar -> Char
Caseless.toCase (forall (letterCase :: Case). KnownCase letterCase => Case
theCase @letterCase))
toCaselessCharList :: forall letterCase superset. KnownCase letterCase => StringSuperset superset =>
ASCII'case letterCase superset
-> [CaselessChar]
toCaselessCharList :: forall (letterCase :: Case) superset.
(KnownCase letterCase, StringSuperset superset) =>
ASCII'case letterCase superset -> [CaselessChar]
toCaselessCharList = forall a b. (a -> b) -> [a] -> [b]
List.map (Case -> Char -> CaselessChar
Caseless.assumeCaseUnsafe (forall (letterCase :: Case). KnownCase letterCase => Case
theCase @letterCase)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall string. ToString string => string -> [Char]
Superset.toCharListUnsafe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (letterCase :: Case) superset.
ASCII'case letterCase superset -> superset
lift
substituteString :: forall letterCase superset. KnownCase letterCase => StringSuperset superset =>
superset
-> ASCII'case letterCase superset
substituteString :: forall (letterCase :: Case) superset.
(KnownCase letterCase, StringSuperset superset) =>
superset -> ASCII'case letterCase superset
substituteString = forall superset (letterCase :: Case).
superset -> ASCII'case letterCase superset
asciiCaseUnsafe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall string. FromString string => [Char] -> string
Superset.fromCharList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
List.map Char -> Char
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall string. ToString string => string -> [Char]
Superset.toCharListSub
where
f :: Char -> Char
f Char
x = if Case -> Char -> Bool
Case.isCase (Case -> Case
Case.opposite (forall (letterCase :: Case). KnownCase letterCase => Case
theCase @letterCase)) Char
x
then Char
ASCII.Substitute
else Char
x
mapChars :: forall letterCase superset. KnownCase letterCase => StringSuperset superset =>
(CaselessChar -> CaselessChar)
-> ASCII'case letterCase superset
-> ASCII'case letterCase superset
mapChars :: forall (letterCase :: Case) superset.
(KnownCase letterCase, StringSuperset superset) =>
(CaselessChar -> CaselessChar)
-> ASCII'case letterCase superset -> ASCII'case letterCase superset
mapChars CaselessChar -> CaselessChar
f = forall superset (letterCase :: Case).
superset -> ASCII'case letterCase superset
asciiCaseUnsafe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall string.
StringSuperset string =>
(Char -> Char) -> string -> string
Superset.mapCharsUnsafe Char -> Char
g forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (letterCase :: Case) superset.
ASCII'case letterCase superset -> superset
lift
where
g :: Char -> Char
g = Case -> CaselessChar -> Char
Caseless.toCase (forall (letterCase :: Case). KnownCase letterCase => Case
theCase @letterCase) forall b c a. (b -> c) -> (a -> b) -> a -> c
. CaselessChar -> CaselessChar
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. Case -> Char -> CaselessChar
Caseless.assumeCaseUnsafe (forall (letterCase :: Case). KnownCase letterCase => Case
theCase @letterCase)
refineStringToCase :: forall letterCase char. KnownCase letterCase => StringSuperset char =>
ASCII char -> ASCII'case letterCase char
refineStringToCase :: forall (letterCase :: Case) char.
(KnownCase letterCase, StringSuperset char) =>
ASCII char -> ASCII'case letterCase char
refineStringToCase = forall superset (letterCase :: Case).
superset -> ASCII'case letterCase superset
asciiCaseUnsafe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall string. StringSuperset string => Case -> string -> string
Superset.toCaseString (forall (letterCase :: Case). KnownCase letterCase => Case
theCase @letterCase) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall superset. ASCII superset -> superset
Refinement.lift