{-# LANGUAGE CPP #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE UnliftedFFITypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TemplateHaskellQuotes #-}
{-# LANGUAGE ViewPatterns #-}
module System.OsString.Internal where
import System.OsString.Internal.Types
import Control.Monad.Catch
( MonadThrow )
import Data.ByteString
( ByteString )
import Data.Char
import Language.Haskell.TH.Quote
( QuasiQuoter (..) )
import Language.Haskell.TH.Syntax
( Lift (..), lift )
import System.IO
( TextEncoding )
import System.OsString.Encoding ( EncodingException(..) )
import GHC.IO.Encoding.Failure ( CodingFailureMode(..) )
#if defined(mingw32_HOST_OS) || defined(__MINGW32__)
import GHC.IO.Encoding.UTF16 ( mkUTF16le )
import qualified System.OsString.Windows as PF
#else
import GHC.IO.Encoding.UTF8 ( mkUTF8 )
import qualified System.OsString.Posix as PF
#endif
import GHC.Stack (HasCallStack)
import Data.Coerce (coerce)
import Data.Type.Coercion (coerceWith)
encodeUtf :: MonadThrow m => String -> m OsString
encodeUtf :: forall (m :: * -> *). MonadThrow m => String -> m OsString
encodeUtf = (PosixString -> OsString) -> m PosixString -> m OsString
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PosixString -> OsString
OsString (m PosixString -> m OsString)
-> (String -> m PosixString) -> String -> m OsString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> m PosixString
forall (m :: * -> *). MonadThrow m => String -> m PosixString
PF.encodeUtf
unsafeEncodeUtf :: HasCallStack => String -> OsString
unsafeEncodeUtf :: HasCallStack => String -> OsString
unsafeEncodeUtf = PosixString -> OsString
OsString (PosixString -> OsString)
-> (String -> PosixString) -> String -> OsString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => String -> PosixString
String -> PosixString
PF.unsafeEncodeUtf
encodeWith :: TextEncoding
-> TextEncoding
-> String
-> Either EncodingException OsString
#if defined(mingw32_HOST_OS) || defined(__MINGW32__)
encodeWith _ winEnc str = OsString <$> PF.encodeWith winEnc str
#else
encodeWith :: TextEncoding
-> TextEncoding -> String -> Either EncodingException OsString
encodeWith TextEncoding
unixEnc TextEncoding
_ String
str = PosixString -> OsString
OsString (PosixString -> OsString)
-> Either EncodingException PosixString
-> Either EncodingException OsString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TextEncoding -> String -> Either EncodingException PosixString
PF.encodeWith TextEncoding
unixEnc String
str
#endif
encodeFS :: String -> IO OsString
encodeFS :: String -> IO OsString
encodeFS = (PosixString -> OsString) -> IO PosixString -> IO OsString
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PosixString -> OsString
OsString (IO PosixString -> IO OsString)
-> (String -> IO PosixString) -> String -> IO OsString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO PosixString
PF.encodeFS
decodeUtf :: MonadThrow m => OsString -> m String
decodeUtf :: forall (m :: * -> *). MonadThrow m => OsString -> m String
decodeUtf (OsString PosixString
x) = PosixString -> m String
forall (m :: * -> *). MonadThrow m => PosixString -> m String
PF.decodeUtf PosixString
x
decodeWith :: TextEncoding
-> TextEncoding
-> OsString
-> Either EncodingException String
#if defined(mingw32_HOST_OS) || defined(__MINGW32__)
decodeWith _ winEnc (OsString x) = PF.decodeWith winEnc x
#else
decodeWith :: TextEncoding
-> TextEncoding -> OsString -> Either EncodingException String
decodeWith TextEncoding
unixEnc TextEncoding
_ (OsString PosixString
x) = TextEncoding -> PosixString -> Either EncodingException String
PF.decodeWith TextEncoding
unixEnc PosixString
x
#endif
decodeFS :: OsString -> IO String
decodeFS :: OsString -> IO String
decodeFS (OsString PosixString
x) = PosixString -> IO String
PF.decodeFS PosixString
x
fromBytes :: MonadThrow m
=> ByteString
-> m OsString
fromBytes :: forall (m :: * -> *). MonadThrow m => ByteString -> m OsString
fromBytes = (PosixString -> OsString) -> m PosixString -> m OsString
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PosixString -> OsString
OsString (m PosixString -> m OsString)
-> (ByteString -> m PosixString) -> ByteString -> m OsString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> m PosixString
forall (m :: * -> *). MonadThrow m => ByteString -> m PosixString
PF.fromBytes
osstr :: QuasiQuoter
osstr :: QuasiQuoter
osstr =
QuasiQuoter
#if defined(mingw32_HOST_OS) || defined(__MINGW32__)
{ quoteExp = \s -> do
osp <- either (fail . show) (pure . OsString) . PF.encodeWith (mkUTF16le ErrorOnCodingFailure) $ s
lift osp
, quotePat = \s -> do
osp' <- either (fail . show) (pure . OsString) . PF.encodeWith (mkUTF16le ErrorOnCodingFailure) $ s
[p|((==) osp' -> True)|]
, quoteType = \_ ->
fail "illegal QuasiQuote (allowed as expression or pattern only, used as a type)"
, quoteDec = \_ ->
fail "illegal QuasiQuote (allowed as expression or pattern only, used as a declaration)"
}
#else
{ quoteExp :: String -> Q Exp
quoteExp = \String
s -> do
OsString
osp <- (EncodingException -> Q OsString)
-> (PosixString -> Q OsString)
-> Either EncodingException PosixString
-> Q OsString
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (String -> Q OsString
forall a. String -> Q a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Q OsString)
-> (EncodingException -> String) -> EncodingException -> Q OsString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EncodingException -> String
forall a. Show a => a -> String
show) (OsString -> Q OsString
forall a. a -> Q a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (OsString -> Q OsString)
-> (PosixString -> OsString) -> PosixString -> Q OsString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PosixString -> OsString
OsString) (Either EncodingException PosixString -> Q OsString)
-> (String -> Either EncodingException PosixString)
-> String
-> Q OsString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextEncoding -> String -> Either EncodingException PosixString
PF.encodeWith (CodingFailureMode -> TextEncoding
mkUTF8 CodingFailureMode
ErrorOnCodingFailure) (String -> Q OsString) -> String -> Q OsString
forall a b. (a -> b) -> a -> b
$ String
s
OsString -> Q Exp
forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
forall (m :: * -> *). Quote m => OsString -> m Exp
lift OsString
osp
, quotePat :: String -> Q Pat
quotePat = \String
s -> do
OsString
osp' <- (EncodingException -> Q OsString)
-> (PosixString -> Q OsString)
-> Either EncodingException PosixString
-> Q OsString
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (String -> Q OsString
forall a. String -> Q a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Q OsString)
-> (EncodingException -> String) -> EncodingException -> Q OsString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EncodingException -> String
forall a. Show a => a -> String
show) (OsString -> Q OsString
forall a. a -> Q a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (OsString -> Q OsString)
-> (PosixString -> OsString) -> PosixString -> Q OsString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PosixString -> OsString
OsString) (Either EncodingException PosixString -> Q OsString)
-> (String -> Either EncodingException PosixString)
-> String
-> Q OsString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextEncoding -> String -> Either EncodingException PosixString
PF.encodeWith (CodingFailureMode -> TextEncoding
mkUTF8 CodingFailureMode
ErrorOnCodingFailure) (String -> Q OsString) -> String -> Q OsString
forall a b. (a -> b) -> a -> b
$ String
s
[p|((==) osp' -> True)|]
, quoteType :: String -> Q Type
quoteType = \String
_ ->
String -> Q Type
forall a. String -> Q a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"illegal QuasiQuote (allowed as expression or pattern only, used as a type)"
, quoteDec :: String -> Q [Dec]
quoteDec = \String
_ ->
String -> Q [Dec]
forall a. String -> Q a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"illegal QuasiQuote (allowed as expression or pattern only, used as a declaration)"
}
#endif
unpack :: OsString -> [OsChar]
unpack :: OsString -> [OsChar]
unpack = (PosixString -> [PosixChar]) -> OsString -> [OsChar]
forall a b. Coercible a b => a -> b
coerce PosixString -> [PosixChar]
PF.unpack
pack :: [OsChar] -> OsString
pack :: [OsChar] -> OsString
pack = ([PosixChar] -> PosixString) -> [OsChar] -> OsString
forall a b. Coercible a b => a -> b
coerce [PosixChar] -> PosixString
PF.pack
empty :: OsString
empty :: OsString
empty = OsString
forall a. Monoid a => a
mempty
singleton :: OsChar -> OsString
singleton :: OsChar -> OsString
singleton = (PosixChar -> PosixString) -> OsChar -> OsString
forall a b. Coercible a b => a -> b
coerce PosixChar -> PosixString
PF.singleton
unsafeFromChar :: Char -> OsChar
unsafeFromChar :: Char -> OsChar
unsafeFromChar = (Char -> PosixChar) -> Char -> OsChar
forall a b. Coercible a b => a -> b
coerce Char -> PosixChar
PF.unsafeFromChar
toChar :: OsChar -> Char
toChar :: OsChar -> Char
toChar = case Either
(Coercion OsChar WindowsChar, Coercion OsString WindowsString)
(Coercion OsChar PosixChar, Coercion OsString PosixString)
coercionToPlatformTypes of
Left (Coercion OsChar WindowsChar
co, Coercion OsString WindowsString
_) -> Int -> Char
chr (Int -> Char) -> (OsChar -> Int) -> OsChar -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Int) -> (OsChar -> Word16) -> OsChar -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WindowsChar -> Word16
getWindowsChar (WindowsChar -> Word16)
-> (OsChar -> WindowsChar) -> OsChar -> Word16
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Coercion OsChar WindowsChar -> OsChar -> WindowsChar
forall a b. Coercion a b -> a -> b
coerceWith Coercion OsChar WindowsChar
co
Right (Coercion OsChar PosixChar
co, Coercion OsString PosixString
_) -> Int -> Char
chr (Int -> Char) -> (OsChar -> Int) -> OsChar -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8 -> Int) -> (OsChar -> Word8) -> OsChar -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PosixChar -> Word8
getPosixChar (PosixChar -> Word8) -> (OsChar -> PosixChar) -> OsChar -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Coercion OsChar PosixChar -> OsChar -> PosixChar
forall a b. Coercion a b -> a -> b
coerceWith Coercion OsChar PosixChar
co
snoc :: OsString -> OsChar -> OsString
snoc :: OsString -> OsChar -> OsString
snoc = (PosixString -> PosixChar -> PosixString)
-> OsString -> OsChar -> OsString
forall a b. Coercible a b => a -> b
coerce PosixString -> PosixChar -> PosixString
PF.snoc
cons :: OsChar -> OsString -> OsString
cons :: OsChar -> OsString -> OsString
cons = (PosixChar -> PosixString -> PosixString)
-> OsChar -> OsString -> OsString
forall a b. Coercible a b => a -> b
coerce PosixChar -> PosixString -> PosixString
PF.cons
last :: HasCallStack => OsString -> OsChar
last :: HasCallStack => OsString -> OsChar
last = (PosixString -> PosixChar) -> OsString -> OsChar
forall a b. Coercible a b => a -> b
coerce HasCallStack => PosixString -> PosixChar
PosixString -> PosixChar
PF.last
tail :: HasCallStack => OsString -> OsString
tail :: HasCallStack => OsString -> OsString
tail = (PosixString -> PosixString) -> OsString -> OsString
forall a b. Coercible a b => a -> b
coerce HasCallStack => PosixString -> PosixString
PosixString -> PosixString
PF.tail
uncons :: OsString -> Maybe (OsChar, OsString)
uncons :: OsString -> Maybe (OsChar, OsString)
uncons = (PosixString -> Maybe (PosixChar, PosixString))
-> OsString -> Maybe (OsChar, OsString)
forall a b. Coercible a b => a -> b
coerce PosixString -> Maybe (PosixChar, PosixString)
PF.uncons
head :: HasCallStack => OsString -> OsChar
head :: HasCallStack => OsString -> OsChar
head = (PosixString -> PosixChar) -> OsString -> OsChar
forall a b. Coercible a b => a -> b
coerce HasCallStack => PosixString -> PosixChar
PosixString -> PosixChar
PF.head
init :: HasCallStack => OsString -> OsString
init :: HasCallStack => OsString -> OsString
init = (PosixString -> PosixString) -> OsString -> OsString
forall a b. Coercible a b => a -> b
coerce HasCallStack => PosixString -> PosixString
PosixString -> PosixString
PF.init
unsnoc :: OsString -> Maybe (OsString, OsChar)
unsnoc :: OsString -> Maybe (OsString, OsChar)
unsnoc = (PosixString -> Maybe (PosixString, PosixChar))
-> OsString -> Maybe (OsString, OsChar)
forall a b. Coercible a b => a -> b
coerce PosixString -> Maybe (PosixString, PosixChar)
PF.unsnoc
null :: OsString -> Bool
null :: OsString -> Bool
null = (PosixString -> Bool) -> OsString -> Bool
forall a b. Coercible a b => a -> b
coerce PosixString -> Bool
PF.null
length :: OsString -> Int
length :: OsString -> Int
length = (PosixString -> Int) -> OsString -> Int
forall a b. Coercible a b => a -> b
coerce PosixString -> Int
PF.length
map :: (OsChar -> OsChar) -> OsString -> OsString
map :: (OsChar -> OsChar) -> OsString -> OsString
map = ((PosixChar -> PosixChar) -> PosixString -> PosixString)
-> (OsChar -> OsChar) -> OsString -> OsString
forall a b. Coercible a b => a -> b
coerce (PosixChar -> PosixChar) -> PosixString -> PosixString
PF.map
reverse :: OsString -> OsString
reverse :: OsString -> OsString
reverse = (PosixString -> PosixString) -> OsString -> OsString
forall a b. Coercible a b => a -> b
coerce PosixString -> PosixString
PF.reverse
intercalate :: OsString -> [OsString] -> OsString
intercalate :: OsString -> [OsString] -> OsString
intercalate = (PosixString -> [PosixString] -> PosixString)
-> OsString -> [OsString] -> OsString
forall a b. Coercible a b => a -> b
coerce PosixString -> [PosixString] -> PosixString
PF.intercalate
foldl :: forall a. (a -> OsChar -> a) -> a -> OsString -> a
foldl :: forall a. (a -> OsChar -> a) -> a -> OsString -> a
foldl = ((a -> PosixChar -> a) -> a -> PosixString -> a)
-> (a -> OsChar -> a) -> a -> OsString -> a
forall a b. Coercible a b => a -> b
coerce (forall a. (a -> PosixChar -> a) -> a -> PosixString -> a
PF.foldl @a)
foldl' :: forall a. (a -> OsChar -> a) -> a -> OsString -> a
foldl' :: forall a. (a -> OsChar -> a) -> a -> OsString -> a
foldl' = ((a -> PosixChar -> a) -> a -> PosixString -> a)
-> (a -> OsChar -> a) -> a -> OsString -> a
forall a b. Coercible a b => a -> b
coerce (forall a. (a -> PosixChar -> a) -> a -> PosixString -> a
PF.foldl' @a)
foldl1 :: (OsChar -> OsChar -> OsChar) -> OsString -> OsChar
foldl1 :: (OsChar -> OsChar -> OsChar) -> OsString -> OsChar
foldl1 = ((PosixChar -> PosixChar -> PosixChar) -> PosixString -> PosixChar)
-> (OsChar -> OsChar -> OsChar) -> OsString -> OsChar
forall a b. Coercible a b => a -> b
coerce (PosixChar -> PosixChar -> PosixChar) -> PosixString -> PosixChar
PF.foldl1
foldl1' :: (OsChar -> OsChar -> OsChar) -> OsString -> OsChar
foldl1' :: (OsChar -> OsChar -> OsChar) -> OsString -> OsChar
foldl1' = ((PosixChar -> PosixChar -> PosixChar) -> PosixString -> PosixChar)
-> (OsChar -> OsChar -> OsChar) -> OsString -> OsChar
forall a b. Coercible a b => a -> b
coerce (PosixChar -> PosixChar -> PosixChar) -> PosixString -> PosixChar
PF.foldl1'
foldr :: forall a. (OsChar -> a -> a) -> a -> OsString -> a
foldr :: forall a. (OsChar -> a -> a) -> a -> OsString -> a
foldr = ((PosixChar -> a -> a) -> a -> PosixString -> a)
-> (OsChar -> a -> a) -> a -> OsString -> a
forall a b. Coercible a b => a -> b
coerce (forall a. (PosixChar -> a -> a) -> a -> PosixString -> a
PF.foldr @a)
foldr' :: forall a. (OsChar -> a -> a) -> a -> OsString -> a
foldr' :: forall a. (OsChar -> a -> a) -> a -> OsString -> a
foldr' = ((PosixChar -> a -> a) -> a -> PosixString -> a)
-> (OsChar -> a -> a) -> a -> OsString -> a
forall a b. Coercible a b => a -> b
coerce (forall a. (PosixChar -> a -> a) -> a -> PosixString -> a
PF.foldr' @a)
foldr1 :: (OsChar -> OsChar -> OsChar) -> OsString -> OsChar
foldr1 :: (OsChar -> OsChar -> OsChar) -> OsString -> OsChar
foldr1 = ((PosixChar -> PosixChar -> PosixChar) -> PosixString -> PosixChar)
-> (OsChar -> OsChar -> OsChar) -> OsString -> OsChar
forall a b. Coercible a b => a -> b
coerce (PosixChar -> PosixChar -> PosixChar) -> PosixString -> PosixChar
PF.foldr1
foldr1' :: (OsChar -> OsChar -> OsChar) -> OsString -> OsChar
foldr1' :: (OsChar -> OsChar -> OsChar) -> OsString -> OsChar
foldr1' = ((PosixChar -> PosixChar -> PosixChar) -> PosixString -> PosixChar)
-> (OsChar -> OsChar -> OsChar) -> OsString -> OsChar
forall a b. Coercible a b => a -> b
coerce (PosixChar -> PosixChar -> PosixChar) -> PosixString -> PosixChar
PF.foldr1'
all :: (OsChar -> Bool) -> OsString -> Bool
all :: (OsChar -> Bool) -> OsString -> Bool
all = ((PosixChar -> Bool) -> PosixString -> Bool)
-> (OsChar -> Bool) -> OsString -> Bool
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> Bool
PF.all
any :: (OsChar -> Bool) -> OsString -> Bool
any :: (OsChar -> Bool) -> OsString -> Bool
any = ((PosixChar -> Bool) -> PosixString -> Bool)
-> (OsChar -> Bool) -> OsString -> Bool
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> Bool
PF.any
concat :: [OsString] -> OsString
concat :: [OsString] -> OsString
concat = [OsString] -> OsString
forall a. Monoid a => [a] -> a
mconcat
replicate :: Int -> OsChar -> OsString
replicate :: Int -> OsChar -> OsString
replicate = (Int -> PosixChar -> PosixString) -> Int -> OsChar -> OsString
forall a b. Coercible a b => a -> b
coerce Int -> PosixChar -> PosixString
PF.replicate
unfoldr :: forall a. (a -> Maybe (OsChar, a)) -> a -> OsString
unfoldr :: forall a. (a -> Maybe (OsChar, a)) -> a -> OsString
unfoldr = ((a -> Maybe (PosixChar, a)) -> a -> PosixString)
-> (a -> Maybe (OsChar, a)) -> a -> OsString
forall a b. Coercible a b => a -> b
coerce (forall a. (a -> Maybe (PosixChar, a)) -> a -> PosixString
PF.unfoldr @a)
unfoldrN :: forall a. Int -> (a -> Maybe (OsChar, a)) -> a -> (OsString, Maybe a)
unfoldrN :: forall a.
Int -> (a -> Maybe (OsChar, a)) -> a -> (OsString, Maybe a)
unfoldrN = (Int -> (a -> Maybe (PosixChar, a)) -> a -> (PosixString, Maybe a))
-> Int -> (a -> Maybe (OsChar, a)) -> a -> (OsString, Maybe a)
forall a b. Coercible a b => a -> b
coerce (forall a.
Int -> (a -> Maybe (PosixChar, a)) -> a -> (PosixString, Maybe a)
PF.unfoldrN @a)
take :: Int -> OsString -> OsString
take :: Int -> OsString -> OsString
take = (Int -> PosixString -> PosixString) -> Int -> OsString -> OsString
forall a b. Coercible a b => a -> b
coerce Int -> PosixString -> PosixString
PF.take
takeEnd :: Int -> OsString -> OsString
takeEnd :: Int -> OsString -> OsString
takeEnd = (Int -> PosixString -> PosixString) -> Int -> OsString -> OsString
forall a b. Coercible a b => a -> b
coerce Int -> PosixString -> PosixString
PF.takeEnd
takeWhileEnd :: (OsChar -> Bool) -> OsString -> OsString
takeWhileEnd :: (OsChar -> Bool) -> OsString -> OsString
takeWhileEnd = ((PosixChar -> Bool) -> PosixString -> PosixString)
-> (OsChar -> Bool) -> OsString -> OsString
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> PosixString
PF.takeWhileEnd
takeWhile :: (OsChar -> Bool) -> OsString -> OsString
takeWhile :: (OsChar -> Bool) -> OsString -> OsString
takeWhile = ((PosixChar -> Bool) -> PosixString -> PosixString)
-> (OsChar -> Bool) -> OsString -> OsString
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> PosixString
PF.takeWhile
drop :: Int -> OsString -> OsString
drop :: Int -> OsString -> OsString
drop = (Int -> PosixString -> PosixString) -> Int -> OsString -> OsString
forall a b. Coercible a b => a -> b
coerce Int -> PosixString -> PosixString
PF.drop
dropEnd :: Int -> OsString -> OsString
dropEnd :: Int -> OsString -> OsString
dropEnd = (Int -> PosixString -> PosixString) -> Int -> OsString -> OsString
forall a b. Coercible a b => a -> b
coerce Int -> PosixString -> PosixString
PF.dropEnd
dropWhile :: (OsChar -> Bool) -> OsString -> OsString
dropWhile :: (OsChar -> Bool) -> OsString -> OsString
dropWhile = ((PosixChar -> Bool) -> PosixString -> PosixString)
-> (OsChar -> Bool) -> OsString -> OsString
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> PosixString
PF.dropWhile
dropWhileEnd :: (OsChar -> Bool) -> OsString -> OsString
dropWhileEnd :: (OsChar -> Bool) -> OsString -> OsString
dropWhileEnd = ((PosixChar -> Bool) -> PosixString -> PosixString)
-> (OsChar -> Bool) -> OsString -> OsString
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> PosixString
PF.dropWhileEnd
breakEnd :: (OsChar -> Bool) -> OsString -> (OsString, OsString)
breakEnd :: (OsChar -> Bool) -> OsString -> (OsString, OsString)
breakEnd = ((PosixChar -> Bool) -> PosixString -> (PosixString, PosixString))
-> (OsChar -> Bool) -> OsString -> (OsString, OsString)
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> (PosixString, PosixString)
PF.breakEnd
break :: (OsChar -> Bool) -> OsString -> (OsString, OsString)
break :: (OsChar -> Bool) -> OsString -> (OsString, OsString)
break = ((PosixChar -> Bool) -> PosixString -> (PosixString, PosixString))
-> (OsChar -> Bool) -> OsString -> (OsString, OsString)
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> (PosixString, PosixString)
PF.break
span :: (OsChar -> Bool) -> OsString -> (OsString, OsString)
span :: (OsChar -> Bool) -> OsString -> (OsString, OsString)
span = ((PosixChar -> Bool) -> PosixString -> (PosixString, PosixString))
-> (OsChar -> Bool) -> OsString -> (OsString, OsString)
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> (PosixString, PosixString)
PF.span
spanEnd :: (OsChar -> Bool) -> OsString -> (OsString, OsString)
spanEnd :: (OsChar -> Bool) -> OsString -> (OsString, OsString)
spanEnd = ((PosixChar -> Bool) -> PosixString -> (PosixString, PosixString))
-> (OsChar -> Bool) -> OsString -> (OsString, OsString)
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> (PosixString, PosixString)
PF.spanEnd
splitAt :: Int -> OsString -> (OsString, OsString)
splitAt :: Int -> OsString -> (OsString, OsString)
splitAt = (Int -> PosixString -> (PosixString, PosixString))
-> Int -> OsString -> (OsString, OsString)
forall a b. Coercible a b => a -> b
coerce Int -> PosixString -> (PosixString, PosixString)
PF.splitAt
split :: OsChar -> OsString -> [OsString]
split :: OsChar -> OsString -> [OsString]
split = (PosixChar -> PosixString -> [PosixString])
-> OsChar -> OsString -> [OsString]
forall a b. Coercible a b => a -> b
coerce PosixChar -> PosixString -> [PosixString]
PF.split
splitWith :: (OsChar -> Bool) -> OsString -> [OsString]
splitWith :: (OsChar -> Bool) -> OsString -> [OsString]
splitWith = ((PosixChar -> Bool) -> PosixString -> [PosixString])
-> (OsChar -> Bool) -> OsString -> [OsString]
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> [PosixString]
PF.splitWith
stripSuffix :: OsString -> OsString -> Maybe OsString
stripSuffix :: OsString -> OsString -> Maybe OsString
stripSuffix = (PosixString -> PosixString -> Maybe PosixString)
-> OsString -> OsString -> Maybe OsString
forall a b. Coercible a b => a -> b
coerce PosixString -> PosixString -> Maybe PosixString
PF.stripSuffix
stripPrefix :: OsString -> OsString -> Maybe OsString
stripPrefix :: OsString -> OsString -> Maybe OsString
stripPrefix = (PosixString -> PosixString -> Maybe PosixString)
-> OsString -> OsString -> Maybe OsString
forall a b. Coercible a b => a -> b
coerce PosixString -> PosixString -> Maybe PosixString
PF.stripPrefix
isInfixOf :: OsString -> OsString -> Bool
isInfixOf :: OsString -> OsString -> Bool
isInfixOf = (PosixString -> PosixString -> Bool)
-> OsString -> OsString -> Bool
forall a b. Coercible a b => a -> b
coerce PosixString -> PosixString -> Bool
PF.isInfixOf
isPrefixOf :: OsString -> OsString -> Bool
isPrefixOf :: OsString -> OsString -> Bool
isPrefixOf = (PosixString -> PosixString -> Bool)
-> OsString -> OsString -> Bool
forall a b. Coercible a b => a -> b
coerce PosixString -> PosixString -> Bool
PF.isPrefixOf
isSuffixOf :: OsString -> OsString -> Bool
isSuffixOf :: OsString -> OsString -> Bool
isSuffixOf = (PosixString -> PosixString -> Bool)
-> OsString -> OsString -> Bool
forall a b. Coercible a b => a -> b
coerce PosixString -> PosixString -> Bool
PF.isSuffixOf
breakSubstring :: OsString -> OsString -> (OsString, OsString)
breakSubstring :: OsString -> OsString -> (OsString, OsString)
breakSubstring = (PosixString -> PosixString -> (PosixString, PosixString))
-> OsString -> OsString -> (OsString, OsString)
forall a b. Coercible a b => a -> b
coerce PosixString -> PosixString -> (PosixString, PosixString)
PF.breakSubstring
elem :: OsChar -> OsString -> Bool
elem :: OsChar -> OsString -> Bool
elem = (PosixChar -> PosixString -> Bool) -> OsChar -> OsString -> Bool
forall a b. Coercible a b => a -> b
coerce PosixChar -> PosixString -> Bool
PF.elem
find :: (OsChar -> Bool) -> OsString -> Maybe OsChar
find :: (OsChar -> Bool) -> OsString -> Maybe OsChar
find = ((PosixChar -> Bool) -> PosixString -> Maybe PosixChar)
-> (OsChar -> Bool) -> OsString -> Maybe OsChar
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> Maybe PosixChar
PF.find
filter :: (OsChar -> Bool) -> OsString -> OsString
filter :: (OsChar -> Bool) -> OsString -> OsString
filter = ((PosixChar -> Bool) -> PosixString -> PosixString)
-> (OsChar -> Bool) -> OsString -> OsString
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> PosixString
PF.filter
partition :: (OsChar -> Bool) -> OsString -> (OsString, OsString)
partition :: (OsChar -> Bool) -> OsString -> (OsString, OsString)
partition = ((PosixChar -> Bool) -> PosixString -> (PosixString, PosixString))
-> (OsChar -> Bool) -> OsString -> (OsString, OsString)
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> (PosixString, PosixString)
PF.partition
index :: HasCallStack => OsString -> Int -> OsChar
index :: HasCallStack => OsString -> Int -> OsChar
index = (PosixString -> Int -> PosixChar) -> OsString -> Int -> OsChar
forall a b. Coercible a b => a -> b
coerce HasCallStack => PosixString -> Int -> PosixChar
PosixString -> Int -> PosixChar
PF.index
indexMaybe :: OsString -> Int -> Maybe OsChar
indexMaybe :: OsString -> Int -> Maybe OsChar
indexMaybe = (PosixString -> Int -> Maybe PosixChar)
-> OsString -> Int -> Maybe OsChar
forall a b. Coercible a b => a -> b
coerce PosixString -> Int -> Maybe PosixChar
PF.indexMaybe
(!?) :: OsString -> Int -> Maybe OsChar
!? :: OsString -> Int -> Maybe OsChar
(!?) = OsString -> Int -> Maybe OsChar
indexMaybe
elemIndex :: OsChar -> OsString -> Maybe Int
elemIndex :: OsChar -> OsString -> Maybe Int
elemIndex = (PosixChar -> PosixString -> Maybe Int)
-> OsChar -> OsString -> Maybe Int
forall a b. Coercible a b => a -> b
coerce PosixChar -> PosixString -> Maybe Int
PF.elemIndex
elemIndices :: OsChar -> OsString -> [Int]
elemIndices :: OsChar -> OsString -> [Int]
elemIndices = (PosixChar -> PosixString -> [Int]) -> OsChar -> OsString -> [Int]
forall a b. Coercible a b => a -> b
coerce PosixChar -> PosixString -> [Int]
PF.elemIndices
count :: OsChar -> OsString -> Int
count :: OsChar -> OsString -> Int
count = (PosixChar -> PosixString -> Int) -> OsChar -> OsString -> Int
forall a b. Coercible a b => a -> b
coerce PosixChar -> PosixString -> Int
PF.count
findIndex :: (OsChar -> Bool) -> OsString -> Maybe Int
findIndex :: (OsChar -> Bool) -> OsString -> Maybe Int
findIndex = ((PosixChar -> Bool) -> PosixString -> Maybe Int)
-> (OsChar -> Bool) -> OsString -> Maybe Int
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> Maybe Int
PF.findIndex
findIndices :: (OsChar -> Bool) -> OsString -> [Int]
findIndices :: (OsChar -> Bool) -> OsString -> [Int]
findIndices = ((PosixChar -> Bool) -> PosixString -> [Int])
-> (OsChar -> Bool) -> OsString -> [Int]
forall a b. Coercible a b => a -> b
coerce (PosixChar -> Bool) -> PosixString -> [Int]
PF.findIndices