{-# OPTIONS_GHC -Wno-redundant-constraints #-}

-- | Provides a static effect for reading a handle.
--
-- @since 0.1
module Effectful.FileSystem.HandleReader.Static
  ( -- * Effect
    HandleReader,
    hIsEOF,
    hGetBuffering,
    hIsOpen,
    hIsClosed,
    hIsReadable,
    hIsWritable,
    hIsSeekable,
    hIsTerminalDevice,
    hGetEcho,
    hWaitForInput,
    hReady,
    hGetChar,
    hGetLine,
    hGetContents,
    hGet,
    hGetSome,
    hGetNonBlocking,

    -- ** Handlers
    runHandleReader,

    -- * UTF-8 Utils

    -- ** GetLine
    hGetLineUtf8,
    hGetLineUtf8Lenient,
    hGetLineUtf8ThrowM,

    -- ** GetContents
    hGetContentsUtf8,
    hGetContentsUtf8Lenient,
    hGetContentsUtf8ThrowM,

    -- ** Get
    hGetUtf8,
    hGetUtf8Lenient,
    hGetUtf8ThrowM,

    -- ** GetSome
    hGetSomeUtf8,
    hGetSomeUtf8Lenient,
    hGetSomeUtf8ThrowM,

    -- ** GetNonBlocking
    hGetNonBlockingUtf8,
    hGetNonBlockingUtf8Lenient,
    hGetNonBlockingUtf8ThrowM,

    -- * Re-exports
    ByteString,
    Handle,
    OsPath,
    Text,
    UnicodeException,
  )
where

import Control.Monad ((>=>))
import Data.ByteString (ByteString)
import Data.ByteString.Char8 qualified as C8
import Data.Text (Text)
import Data.Text.Encoding.Error (UnicodeException)
import Effectful
  ( Dispatch (Static),
    DispatchOf,
    Eff,
    Effect,
    IOE,
    type (:>),
  )
import Effectful.Dispatch.Static
  ( HasCallStack,
    SideEffects (WithSideEffects),
    StaticRep,
    evalStaticRep,
    unsafeEff_,
  )
import FileSystem.OsPath (OsPath)
import FileSystem.UTF8 qualified as FS.UTF8
import System.IO (BufferMode, Handle)
import System.IO qualified as IO

-- | Static effect for reading a handle.
--
-- @since 0.1
data HandleReader :: Effect

type instance DispatchOf HandleReader = Static WithSideEffects

data instance StaticRep HandleReader = MkHandleReader

-- | Runs 'HandleReader' in 'IO'.
--
-- @since 0.1
runHandleReader ::
  (HasCallStack, IOE :> es) =>
  Eff (HandleReader : es) a ->
  Eff es a
runHandleReader :: forall (es :: [Effect]) a.
(HasCallStack, IOE :> es) =>
Eff (HandleReader : es) a -> Eff es a
runHandleReader = StaticRep HandleReader -> Eff (HandleReader : es) a -> Eff es a
forall (e :: Effect) (sideEffects :: SideEffects) (es :: [Effect])
       a.
(HasCallStack, DispatchOf e ~ 'Static sideEffects,
 MaybeIOE sideEffects es) =>
StaticRep e -> Eff (e : es) a -> Eff es a
evalStaticRep StaticRep HandleReader
MkHandleReader

-- | Lifted 'IO.hIsEof'.
--
-- @since 0.1
hIsEOF :: (HandleReader :> es, HasCallStack) => Handle -> Eff es Bool
hIsEOF :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es Bool
hIsEOF = IO Bool -> Eff es Bool
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO Bool -> Eff es Bool)
-> (Handle -> IO Bool) -> Handle -> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO Bool
IO.hIsEOF

-- | Lifted 'IO.hGetBuffering'.
--
-- @since 0.1
hGetBuffering ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es BufferMode
hGetBuffering :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es BufferMode
hGetBuffering = IO BufferMode -> Eff es BufferMode
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO BufferMode -> Eff es BufferMode)
-> (Handle -> IO BufferMode) -> Handle -> Eff es BufferMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO BufferMode
IO.hGetBuffering

-- | Lifted 'IO.hIsOpen'.
--
-- @since 0.1
hIsOpen ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es Bool
hIsOpen :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es Bool
hIsOpen = IO Bool -> Eff es Bool
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO Bool -> Eff es Bool)
-> (Handle -> IO Bool) -> Handle -> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO Bool
IO.hIsOpen

-- | Lifted 'IO.hIsClosed'.
--
-- @since 0.1
hIsClosed ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es Bool
hIsClosed :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es Bool
hIsClosed = IO Bool -> Eff es Bool
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO Bool -> Eff es Bool)
-> (Handle -> IO Bool) -> Handle -> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO Bool
IO.hIsClosed

-- | Lifted 'IO.hIsReadable'.
--
-- @since 0.1
hIsReadable ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es Bool
hIsReadable :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es Bool
hIsReadable = IO Bool -> Eff es Bool
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO Bool -> Eff es Bool)
-> (Handle -> IO Bool) -> Handle -> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO Bool
IO.hIsReadable

-- | Lifted 'IO.hIsWritable'.
--
-- @since 0.1
hIsWritable ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es Bool
hIsWritable :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es Bool
hIsWritable = IO Bool -> Eff es Bool
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO Bool -> Eff es Bool)
-> (Handle -> IO Bool) -> Handle -> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO Bool
IO.hIsWritable

-- | Lifted 'IO.hIsSeekable'.
--
-- @since 0.1
hIsSeekable ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es Bool
hIsSeekable :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es Bool
hIsSeekable = IO Bool -> Eff es Bool
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO Bool -> Eff es Bool)
-> (Handle -> IO Bool) -> Handle -> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO Bool
IO.hIsSeekable

-- | Lifted 'IO.hIsTerminalDevice'.
--
-- @since 0.1
hIsTerminalDevice ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es Bool
hIsTerminalDevice :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es Bool
hIsTerminalDevice = IO Bool -> Eff es Bool
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO Bool -> Eff es Bool)
-> (Handle -> IO Bool) -> Handle -> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO Bool
IO.hIsTerminalDevice

-- | Lifted 'IO.hGetEcho'.
--
-- @since 0.1
hGetEcho ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es Bool
hGetEcho :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es Bool
hGetEcho = IO Bool -> Eff es Bool
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO Bool -> Eff es Bool)
-> (Handle -> IO Bool) -> Handle -> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO Bool
IO.hGetEcho

-- | Lifted 'IO.hWaitForInput'.
--
-- @since 0.1
hWaitForInput ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Int ->
  Eff es Bool
hWaitForInput :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es Bool
hWaitForInput Handle
h = IO Bool -> Eff es Bool
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO Bool -> Eff es Bool) -> (Int -> IO Bool) -> Int -> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> Int -> IO Bool
IO.hWaitForInput Handle
h

-- | Lifted 'IO.hReady'.
--
-- @since 0.1
hReady ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es Bool
hReady :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es Bool
hReady = IO Bool -> Eff es Bool
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO Bool -> Eff es Bool)
-> (Handle -> IO Bool) -> Handle -> Eff es Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO Bool
IO.hReady

-- | Lifted 'IO.hGetChar'.
--
-- @since 0.1
hGetChar ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es Char
hGetChar :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es Char
hGetChar = IO Char -> Eff es Char
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO Char -> Eff es Char)
-> (Handle -> IO Char) -> Handle -> Eff es Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO Char
IO.hGetChar

-- | Lifted 'BS.hGetLine'.
--
-- @since 0.1
hGetLine ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es ByteString
hGetLine :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es ByteString
hGetLine = IO ByteString -> Eff es ByteString
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO ByteString -> Eff es ByteString)
-> (Handle -> IO ByteString) -> Handle -> Eff es ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO ByteString
C8.hGetLine

-- | Lifted 'BS.hGetContents'.
--
-- @since 0.1
hGetContents ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es ByteString
hGetContents :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es ByteString
hGetContents = IO ByteString -> Eff es ByteString
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO ByteString -> Eff es ByteString)
-> (Handle -> IO ByteString) -> Handle -> Eff es ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> IO ByteString
C8.hGetContents

-- | Lifted 'BS.hGet'.
--
-- @since 0.1
hGet ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Int ->
  Eff es ByteString
hGet :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es ByteString
hGet Handle
h = IO ByteString -> Eff es ByteString
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO ByteString -> Eff es ByteString)
-> (Int -> IO ByteString) -> Int -> Eff es ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> Int -> IO ByteString
C8.hGet Handle
h

-- | Lifted 'BS.hGetSome'.
--
-- @since 0.1
hGetSome ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Int ->
  Eff es ByteString
hGetSome :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es ByteString
hGetSome Handle
h = IO ByteString -> Eff es ByteString
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO ByteString -> Eff es ByteString)
-> (Int -> IO ByteString) -> Int -> Eff es ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> Int -> IO ByteString
C8.hGetSome Handle
h

-- | Lifted 'BS.hGetNonBlocking'.
--
-- @since 0.1
hGetNonBlocking ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Int ->
  Eff es ByteString
hGetNonBlocking :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es ByteString
hGetNonBlocking Handle
h = IO ByteString -> Eff es ByteString
forall a (es :: [Effect]). IO a -> Eff es a
unsafeEff_ (IO ByteString -> Eff es ByteString)
-> (Int -> IO ByteString) -> Int -> Eff es ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> Int -> IO ByteString
C8.hGetNonBlocking Handle
h

-- | 'hGetLine' and 'FS.UTF8.decodeUtf8'.
--
-- @since 0.1
hGetLineUtf8 ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es (Either UnicodeException Text)
hGetLineUtf8 :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es (Either UnicodeException Text)
hGetLineUtf8 = (ByteString -> Either UnicodeException Text)
-> Eff es ByteString -> Eff es (Either UnicodeException Text)
forall a b. (a -> b) -> Eff es a -> Eff es b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> Either UnicodeException Text
FS.UTF8.decodeUtf8 (Eff es ByteString -> Eff es (Either UnicodeException Text))
-> (Handle -> Eff es ByteString)
-> Handle
-> Eff es (Either UnicodeException Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es ByteString
hGetLine

-- | 'hGetLine' and 'FS.UTF8.decodeUtf8Lenient'.
--
-- @since 0.1
hGetLineUtf8Lenient ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es Text
hGetLineUtf8Lenient :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es Text
hGetLineUtf8Lenient = (ByteString -> Text) -> Eff es ByteString -> Eff es Text
forall a b. (a -> b) -> Eff es a -> Eff es b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> Text
FS.UTF8.decodeUtf8Lenient (Eff es ByteString -> Eff es Text)
-> (Handle -> Eff es ByteString) -> Handle -> Eff es Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es ByteString
hGetLine

-- | 'hGetLine' and 'FS.UTF8.decodeUtf8ThrowM'.
--
-- @since 0.1
hGetLineUtf8ThrowM ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es Text
hGetLineUtf8ThrowM :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es Text
hGetLineUtf8ThrowM = Handle -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es ByteString
hGetLine (Handle -> Eff es ByteString)
-> (ByteString -> Eff es Text) -> Handle -> Eff es Text
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ByteString -> Eff es Text
forall (m :: * -> *).
(HasCallStack, MonadThrow m) =>
ByteString -> m Text
FS.UTF8.decodeUtf8ThrowM

-- | 'hGetContents' and 'FS.UTF8.decodeUtf8'.
--
-- @since 0.1
hGetContentsUtf8 ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es (Either UnicodeException Text)
hGetContentsUtf8 :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es (Either UnicodeException Text)
hGetContentsUtf8 = (ByteString -> Either UnicodeException Text)
-> Eff es ByteString -> Eff es (Either UnicodeException Text)
forall a b. (a -> b) -> Eff es a -> Eff es b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> Either UnicodeException Text
FS.UTF8.decodeUtf8 (Eff es ByteString -> Eff es (Either UnicodeException Text))
-> (Handle -> Eff es ByteString)
-> Handle
-> Eff es (Either UnicodeException Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es ByteString
hGetContents

-- | 'hGetContents' and 'FS.UTF8.decodeUtf8Lenient'.
--
-- @since 0.1
hGetContentsUtf8Lenient ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es Text
hGetContentsUtf8Lenient :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es Text
hGetContentsUtf8Lenient = (ByteString -> Text) -> Eff es ByteString -> Eff es Text
forall a b. (a -> b) -> Eff es a -> Eff es b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> Text
FS.UTF8.decodeUtf8Lenient (Eff es ByteString -> Eff es Text)
-> (Handle -> Eff es ByteString) -> Handle -> Eff es Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es ByteString
hGetContents

-- | 'hGetContents' and 'FS.UTF8.decodeUtf8ThrowM'.
--
-- @since 0.1
hGetContentsUtf8ThrowM ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Eff es Text
hGetContentsUtf8ThrowM :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es Text
hGetContentsUtf8ThrowM = Handle -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Eff es ByteString
hGetContents (Handle -> Eff es ByteString)
-> (ByteString -> Eff es Text) -> Handle -> Eff es Text
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ByteString -> Eff es Text
forall (m :: * -> *).
(HasCallStack, MonadThrow m) =>
ByteString -> m Text
FS.UTF8.decodeUtf8ThrowM

-- | 'hGet' and 'FS.UTF8.decodeUtf8'.
--
-- @since 0.1
hGetUtf8 ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Int ->
  Eff es (Either UnicodeException Text)
hGetUtf8 :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es (Either UnicodeException Text)
hGetUtf8 Handle
h = (ByteString -> Either UnicodeException Text)
-> Eff es ByteString -> Eff es (Either UnicodeException Text)
forall a b. (a -> b) -> Eff es a -> Eff es b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> Either UnicodeException Text
FS.UTF8.decodeUtf8 (Eff es ByteString -> Eff es (Either UnicodeException Text))
-> (Int -> Eff es ByteString)
-> Int
-> Eff es (Either UnicodeException Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> Int -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es ByteString
hGet Handle
h

-- | 'hGet' and 'FS.UTF8.decodeUtf8Lenient'.
--
-- @since 0.1
hGetUtf8Lenient ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Int ->
  Eff es Text
hGetUtf8Lenient :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es Text
hGetUtf8Lenient Handle
h = (ByteString -> Text) -> Eff es ByteString -> Eff es Text
forall a b. (a -> b) -> Eff es a -> Eff es b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> Text
FS.UTF8.decodeUtf8Lenient (Eff es ByteString -> Eff es Text)
-> (Int -> Eff es ByteString) -> Int -> Eff es Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> Int -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es ByteString
hGet Handle
h

-- | 'hGet' and 'FS.UTF8.decodeUtf8ThrowM'.
--
-- @since 0.1
hGetUtf8ThrowM ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Int ->
  Eff es Text
hGetUtf8ThrowM :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es Text
hGetUtf8ThrowM Handle
h = Handle -> Int -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es ByteString
hGet Handle
h (Int -> Eff es ByteString)
-> (ByteString -> Eff es Text) -> Int -> Eff es Text
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ByteString -> Eff es Text
forall (m :: * -> *).
(HasCallStack, MonadThrow m) =>
ByteString -> m Text
FS.UTF8.decodeUtf8ThrowM

-- | 'hGetSome' and 'FS.UTF8.decodeUtf8'.
--
-- @since 0.1
hGetSomeUtf8 ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Int ->
  Eff es (Either UnicodeException Text)
hGetSomeUtf8 :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es (Either UnicodeException Text)
hGetSomeUtf8 Handle
h = (ByteString -> Either UnicodeException Text)
-> Eff es ByteString -> Eff es (Either UnicodeException Text)
forall a b. (a -> b) -> Eff es a -> Eff es b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> Either UnicodeException Text
FS.UTF8.decodeUtf8 (Eff es ByteString -> Eff es (Either UnicodeException Text))
-> (Int -> Eff es ByteString)
-> Int
-> Eff es (Either UnicodeException Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> Int -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es ByteString
hGetSome Handle
h

-- | 'hGetSome' and 'FS.UTF8.decodeUtf8Lenient'.
--
-- @since 0.1
hGetSomeUtf8Lenient ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Int ->
  Eff es Text
hGetSomeUtf8Lenient :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es Text
hGetSomeUtf8Lenient Handle
h = (ByteString -> Text) -> Eff es ByteString -> Eff es Text
forall a b. (a -> b) -> Eff es a -> Eff es b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> Text
FS.UTF8.decodeUtf8Lenient (Eff es ByteString -> Eff es Text)
-> (Int -> Eff es ByteString) -> Int -> Eff es Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> Int -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es ByteString
hGetSome Handle
h

-- | 'hGetSome' and 'FS.UTF8.decodeUtf8ThrowM'.
--
-- @since 0.1
hGetSomeUtf8ThrowM ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Int ->
  Eff es Text
hGetSomeUtf8ThrowM :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es Text
hGetSomeUtf8ThrowM Handle
h = Handle -> Int -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es ByteString
hGetSome Handle
h (Int -> Eff es ByteString)
-> (ByteString -> Eff es Text) -> Int -> Eff es Text
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ByteString -> Eff es Text
forall (m :: * -> *).
(HasCallStack, MonadThrow m) =>
ByteString -> m Text
FS.UTF8.decodeUtf8ThrowM

-- | 'hGetNonBlocking' and 'FS.UTF8.decodeUtf8'.
--
-- @since 0.1
hGetNonBlockingUtf8 ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Int ->
  Eff es (Either UnicodeException Text)
hGetNonBlockingUtf8 :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es (Either UnicodeException Text)
hGetNonBlockingUtf8 Handle
h = (ByteString -> Either UnicodeException Text)
-> Eff es ByteString -> Eff es (Either UnicodeException Text)
forall a b. (a -> b) -> Eff es a -> Eff es b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> Either UnicodeException Text
FS.UTF8.decodeUtf8 (Eff es ByteString -> Eff es (Either UnicodeException Text))
-> (Int -> Eff es ByteString)
-> Int
-> Eff es (Either UnicodeException Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> Int -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es ByteString
hGetNonBlocking Handle
h

-- | 'hGetNonBlocking' and 'FS.UTF8.decodeUtf8Lenient'.
--
-- @since 0.1
hGetNonBlockingUtf8Lenient ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Int ->
  Eff es Text
hGetNonBlockingUtf8Lenient :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es Text
hGetNonBlockingUtf8Lenient Handle
h = (ByteString -> Text) -> Eff es ByteString -> Eff es Text
forall a b. (a -> b) -> Eff es a -> Eff es b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> Text
FS.UTF8.decodeUtf8Lenient (Eff es ByteString -> Eff es Text)
-> (Int -> Eff es ByteString) -> Int -> Eff es Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Handle -> Int -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es ByteString
hGetNonBlocking Handle
h

-- | 'hGetNonBlocking' and 'FS.UTF8.decodeUtf8ThrowM'.
--
-- @since 0.1
hGetNonBlockingUtf8ThrowM ::
  ( HandleReader :> es,
    HasCallStack
  ) =>
  Handle ->
  Int ->
  Eff es Text
hGetNonBlockingUtf8ThrowM :: forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es Text
hGetNonBlockingUtf8ThrowM Handle
h = Handle -> Int -> Eff es ByteString
forall (es :: [Effect]).
(HandleReader :> es, HasCallStack) =>
Handle -> Int -> Eff es ByteString
hGetNonBlocking Handle
h (Int -> Eff es ByteString)
-> (ByteString -> Eff es Text) -> Int -> Eff es Text
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ByteString -> Eff es Text
forall (m :: * -> *).
(HasCallStack, MonadThrow m) =>
ByteString -> m Text
FS.UTF8.decodeUtf8ThrowM