module Lazy.Scope.Io where

import Control.DeepSeq (NFData)
import Control.Monad.Trans.Class (MonadTrans(lift))
import Data.ByteString qualified as S
import Data.ByteString.Lazy qualified as L
import Foreign.Ptr (Ptr)
import Lazy.Scope.Type (LazyT(..), HandlePosn(..), Handle(..), Bs, Scoped(Scoped))
import Relude
    ( ($), ($!), (<$>),
      Bool(..),
      ByteString,
      Char,
      Show,
      String,
      Maybe (..),
      Integer,
      Int,
      MonadIO(..),
      FilePath,
      IOMode )
import System.IO qualified as IO
import System.IO (SeekMode (..), BufferMode, TextEncoding, NewlineMode)
import UnliftIO (MonadUnliftIO (..))
import UnliftIO.IO qualified as U

class WithFile a where
  withFile       :: (NFData r, MonadUnliftIO m) =>
    a -> IOMode -> (forall s. Handle s -> LazyT s m r) -> m r
  withBinaryFile :: (NFData r, MonadUnliftIO m) =>
    a -> IOMode -> (forall s. Handle s -> LazyT s m r) -> m r

instance WithFile FilePath where
  {-# INLINE withFile #-}
  withFile :: forall {k} r (m :: * -> *).
(NFData r, MonadUnliftIO m) =>
FilePath
-> IOMode -> (forall (s :: k). Handle s -> LazyT s m r) -> m r
withFile FilePath
fp IOMode
mode forall (s :: k). Handle s -> LazyT s m r
cb =
    FilePath -> IOMode -> (Handle -> m r) -> m r
forall (m :: * -> *) a.
MonadUnliftIO m =>
FilePath -> IOMode -> (Handle -> m a) -> m a
U.withFile FilePath
fp IOMode
mode (\Handle
h -> LazyT (ZonkAny 0) m r -> m r
forall {k1} {k2} (s :: k1) (m :: k2 -> *) (a :: k2).
LazyT s m a -> m a
unLazy (Handle (ZonkAny 0) -> LazyT (ZonkAny 0) m r
forall (s :: k). Handle s -> LazyT s m r
cb (Handle -> Handle (ZonkAny 0)
forall {k} (s :: k). Handle -> Handle s
Handle Handle
h)))
  {-# INLINE withBinaryFile #-}
  withBinaryFile :: forall {k} r (m :: * -> *).
(NFData r, MonadUnliftIO m) =>
FilePath
-> IOMode -> (forall (s :: k). Handle s -> LazyT s m r) -> m r
withBinaryFile FilePath
fp IOMode
mode forall (s :: k). Handle s -> LazyT s m r
cb =
    FilePath -> IOMode -> (Handle -> m r) -> m r
forall (m :: * -> *) a.
MonadUnliftIO m =>
FilePath -> IOMode -> (Handle -> m a) -> m a
U.withBinaryFile FilePath
fp IOMode
mode (\Handle
h -> LazyT (ZonkAny 1) m r -> m r
forall {k1} {k2} (s :: k1) (m :: k2 -> *) (a :: k2).
LazyT s m a -> m a
unLazy (Handle (ZonkAny 1) -> LazyT (ZonkAny 1) m r
forall (s :: k). Handle s -> LazyT s m r
cb (Handle -> Handle (ZonkAny 1)
forall {k} (s :: k). Handle -> Handle s
Handle Handle
h)))

hSeek :: MonadIO m => Handle s -> SeekMode -> Integer -> LazyT s m ()
hSeek :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> SeekMode -> Integer -> LazyT s m ()
hSeek (Handle Handle
h) SeekMode
sm Integer
n = m () -> LazyT s m ()
forall {k} {k1} (s :: k) (m :: k1 -> *) (a :: k1).
m a -> LazyT s m a
LazyT (m () -> LazyT s m ()) -> m () -> LazyT s m ()
forall a b. (a -> b) -> a -> b
$! Handle -> SeekMode -> Integer -> m ()
forall (m :: * -> *).
MonadIO m =>
Handle -> SeekMode -> Integer -> m ()
U.hSeek Handle
h SeekMode
sm Integer
n
{-# INLINE hSeek #-}

hTell :: MonadIO m => Handle s -> LazyT s m Integer
hTell :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m Integer
hTell (Handle Handle
h) = m Integer -> LazyT s m Integer
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m Integer -> LazyT s m Integer) -> m Integer -> LazyT s m Integer
forall a b. (a -> b) -> a -> b
$! Handle -> m Integer
forall (m :: * -> *). MonadIO m => Handle -> m Integer
U.hTell Handle
h
{-# INLINE hTell #-}

hSetPosn :: MonadIO m => HandlePosn s -> LazyT s m ()
hSetPosn :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
HandlePosn s -> LazyT s m ()
hSetPosn (HandlePosn HandlePosn
hpn) = m () -> LazyT s m ()
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$! HandlePosn -> IO ()
IO.hSetPosn HandlePosn
hpn)

hGetPosn :: MonadIO m => Handle s -> LazyT s m (HandlePosn s)
hGetPosn :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m (HandlePosn s)
hGetPosn (Handle Handle
h) = m (HandlePosn s) -> LazyT s m (HandlePosn s)
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO (HandlePosn s) -> m (HandlePosn s)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (HandlePosn s) -> m (HandlePosn s))
-> IO (HandlePosn s) -> m (HandlePosn s)
forall a b. (a -> b) -> a -> b
$! HandlePosn -> HandlePosn s
forall {k} (s :: k). HandlePosn -> HandlePosn s
HandlePosn (HandlePosn -> HandlePosn s) -> IO HandlePosn -> IO (HandlePosn s)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Handle -> IO HandlePosn
IO.hGetPosn Handle
h)

hFlush :: MonadIO m => Handle s -> LazyT s m ()
hFlush :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m ()
hFlush (Handle Handle
h) = m () -> LazyT s m ()
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Handle -> m ()
forall (m :: * -> *). MonadIO m => Handle -> m ()
U.hFlush Handle
h)

hGetBuffering :: MonadIO m => Handle s -> LazyT s m BufferMode
hGetBuffering :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m BufferMode
hGetBuffering (Handle Handle
h) = m BufferMode -> LazyT s m BufferMode
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Handle -> m BufferMode
forall (m :: * -> *). MonadIO m => Handle -> m BufferMode
U.hGetBuffering Handle
h)

hSetBuffering :: MonadIO m => Handle s -> BufferMode -> LazyT s m ()
hSetBuffering :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> BufferMode -> LazyT s m ()
hSetBuffering (Handle Handle
h) BufferMode
bm = m () -> LazyT s m ()
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Handle -> BufferMode -> m ()
forall (m :: * -> *). MonadIO m => Handle -> BufferMode -> m ()
U.hSetBuffering Handle
h BufferMode
bm)

hIsEOF :: MonadIO m => Handle s -> LazyT s m Bool
hIsEOF :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m Bool
hIsEOF (Handle Handle
h) = m Bool -> LazyT s m Bool
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Handle -> m Bool
forall (m :: * -> *). MonadIO m => Handle -> m Bool
U.hIsEOF Handle
h)

hSetFileSize :: MonadIO m => Handle s -> Integer -> LazyT s m ()
hSetFileSize :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> Integer -> LazyT s m ()
hSetFileSize (Handle Handle
h) Integer
n = m () -> LazyT s m ()
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Handle -> Integer -> m ()
forall (m :: * -> *). MonadIO m => Handle -> Integer -> m ()
U.hSetFileSize Handle
h Integer
n)

hFileSize :: MonadIO m => Handle s -> LazyT s m Integer
hFileSize :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m Integer
hFileSize (Handle Handle
h) = m Integer -> LazyT s m Integer
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Handle -> m Integer
forall (m :: * -> *). MonadIO m => Handle -> m Integer
U.hFileSize Handle
h)

hSetEncoding :: MonadIO m => Handle s -> TextEncoding -> LazyT s m ()
hSetEncoding :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> TextEncoding -> LazyT s m ()
hSetEncoding (Handle Handle
h) TextEncoding
te = m () -> LazyT s m ()
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Handle -> TextEncoding -> IO ()
IO.hSetEncoding Handle
h TextEncoding
te)

hGetEncoding :: MonadIO m => Handle s -> LazyT s m (Maybe TextEncoding)
hGetEncoding :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m (Maybe TextEncoding)
hGetEncoding (Handle Handle
h) = m (Maybe TextEncoding) -> LazyT s m (Maybe TextEncoding)
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO (Maybe TextEncoding) -> m (Maybe TextEncoding)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TextEncoding) -> m (Maybe TextEncoding))
-> IO (Maybe TextEncoding) -> m (Maybe TextEncoding)
forall a b. (a -> b) -> a -> b
$ Handle -> IO (Maybe TextEncoding)
IO.hGetEncoding Handle
h)

hSetBinaryMode :: MonadIO m => Handle s -> Bool -> LazyT s m ()
hSetBinaryMode :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> Bool -> LazyT s m ()
hSetBinaryMode (Handle Handle
h) Bool
b = m () -> LazyT s m ()
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Handle -> Bool -> IO ()
IO.hSetBinaryMode Handle
h Bool
b)

hPutBuf :: MonadIO m => Handle s -> Ptr a -> Int -> LazyT s m ()
hPutBuf :: forall {k} (m :: * -> *) (s :: k) a.
MonadIO m =>
Handle s -> Ptr a -> Int -> LazyT s m ()
hPutBuf (Handle Handle
h) Ptr a
p Int
n = m () -> LazyT s m ()
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Handle -> Ptr a -> Int -> IO ()
forall a. Handle -> Ptr a -> Int -> IO ()
IO.hPutBuf Handle
h Ptr a
p Int
n)

hGetBuf :: MonadIO m => Handle s -> Ptr a -> Int -> LazyT s m Int
hGetBuf :: forall {k} (m :: * -> *) (s :: k) a.
MonadIO m =>
Handle s -> Ptr a -> Int -> LazyT s m Int
hGetBuf (Handle Handle
h) Ptr a
p Int
n = m Int -> LazyT s m Int
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO Int -> m Int
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> m Int) -> IO Int -> m Int
forall a b. (a -> b) -> a -> b
$ Handle -> Ptr a -> Int -> IO Int
forall a. Handle -> Ptr a -> Int -> IO Int
IO.hGetBuf Handle
h Ptr a
p Int
n)

hGetBufSome :: MonadIO m => Handle s -> Ptr a -> Int -> LazyT s m Int
hGetBufSome :: forall {k} (m :: * -> *) (s :: k) a.
MonadIO m =>
Handle s -> Ptr a -> Int -> LazyT s m Int
hGetBufSome (Handle Handle
h) Ptr a
p Int
n = m Int -> LazyT s m Int
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO Int -> m Int
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> m Int) -> IO Int -> m Int
forall a b. (a -> b) -> a -> b
$ Handle -> Ptr a -> Int -> IO Int
forall a. Handle -> Ptr a -> Int -> IO Int
IO.hGetBufSome Handle
h Ptr a
p Int
n)

hPutBufNonBlocking :: MonadIO m => Handle s -> Ptr a -> Int -> LazyT s m Int
hPutBufNonBlocking :: forall {k} (m :: * -> *) (s :: k) a.
MonadIO m =>
Handle s -> Ptr a -> Int -> LazyT s m Int
hPutBufNonBlocking (Handle Handle
h) Ptr a
p Int
n = m Int -> LazyT s m Int
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO Int -> m Int
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> m Int) -> IO Int -> m Int
forall a b. (a -> b) -> a -> b
$ Handle -> Ptr a -> Int -> IO Int
forall a. Handle -> Ptr a -> Int -> IO Int
IO.hPutBufNonBlocking Handle
h Ptr a
p Int
n)

hGetBufNonBlocking :: MonadIO m => Handle s -> Ptr a -> Int -> LazyT s m Int
hGetBufNonBlocking :: forall {k} (m :: * -> *) (s :: k) a.
MonadIO m =>
Handle s -> Ptr a -> Int -> LazyT s m Int
hGetBufNonBlocking (Handle Handle
h) Ptr a
p Int
n = m Int -> LazyT s m Int
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO Int -> m Int
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int -> m Int) -> IO Int -> m Int
forall a b. (a -> b) -> a -> b
$ Handle -> Ptr a -> Int -> IO Int
forall a. Handle -> Ptr a -> Int -> IO Int
IO.hGetBufNonBlocking Handle
h Ptr a
p Int
n)

hSetNewlineMode :: MonadIO m => Handle s -> NewlineMode -> LazyT s m ()
hSetNewlineMode :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> NewlineMode -> LazyT s m ()
hSetNewlineMode (Handle Handle
h) NewlineMode
nlm = m () -> LazyT s m ()
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Handle -> NewlineMode -> IO ()
IO.hSetNewlineMode Handle
h NewlineMode
nlm)

hPrint :: (MonadIO m, Show a) => Handle s -> a -> LazyT s m ()
hPrint :: forall {k} (m :: * -> *) a (s :: k).
(MonadIO m, Show a) =>
Handle s -> a -> LazyT s m ()
hPrint (Handle Handle
h) a
a = m () -> LazyT s m ()
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Handle -> a -> IO ()
forall a. Show a => Handle -> a -> IO ()
IO.hPrint Handle
h a
a)

hGetChar :: MonadIO m => Handle s -> LazyT s m Char
hGetChar :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m Char
hGetChar (Handle Handle
h) = m Char -> LazyT s m Char
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO Char -> m Char
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Char -> m Char) -> IO Char -> m Char
forall a b. (a -> b) -> a -> b
$ Handle -> IO Char
IO.hGetChar Handle
h)

hReady :: MonadIO m => Handle s -> LazyT s m Bool
hReady :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m Bool
hReady (Handle Handle
h) = m Bool -> LazyT s m Bool
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Handle -> m Bool
forall (m :: * -> *). MonadIO m => Handle -> m Bool
U.hReady Handle
h)

hWaitForInput :: MonadIO m => Handle s -> Int -> LazyT s m Bool
hWaitForInput :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> Int -> LazyT s m Bool
hWaitForInput (Handle Handle
h) Int
n = m Bool -> LazyT s m Bool
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Handle -> Int -> m Bool
forall (m :: * -> *). MonadIO m => Handle -> Int -> m Bool
U.hWaitForInput Handle
h Int
n)

hShow :: MonadIO m => Handle s -> LazyT s m String
hShow :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m FilePath
hShow (Handle Handle
h) = m FilePath -> LazyT s m FilePath
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m FilePath -> LazyT s m FilePath)
-> m FilePath -> LazyT s m FilePath
forall a b. (a -> b) -> a -> b
$ (IO FilePath -> m FilePath
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FilePath -> m FilePath) -> IO FilePath -> m FilePath
forall a b. (a -> b) -> a -> b
$ Handle -> IO FilePath
IO.hShow Handle
h)

hGetEcho :: MonadIO m => Handle s -> LazyT s m Bool
hGetEcho :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m Bool
hGetEcho (Handle Handle
h) = m Bool -> LazyT s m Bool
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Handle -> m Bool
forall (m :: * -> *). MonadIO m => Handle -> m Bool
U.hGetEcho Handle
h)

hSetEcho :: MonadIO m => Handle s -> Bool -> LazyT s m ()
hSetEcho :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> Bool -> LazyT s m ()
hSetEcho (Handle Handle
h) Bool
eb = m () -> LazyT s m ()
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Handle -> Bool -> m ()
forall (m :: * -> *). MonadIO m => Handle -> Bool -> m ()
U.hSetEcho Handle
h Bool
eb)

hIsTerminalDevice :: MonadIO m => Handle s -> LazyT s m Bool
hIsTerminalDevice :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m Bool
hIsTerminalDevice (Handle Handle
h) = m Bool -> LazyT s m Bool
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Handle -> m Bool
forall (m :: * -> *). MonadIO m => Handle -> m Bool
U.hIsTerminalDevice Handle
h)

hIsSeekable :: MonadIO m => (Handle s) -> LazyT s m Bool
hIsSeekable :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m Bool
hIsSeekable (Handle Handle
h) = m Bool -> LazyT s m Bool
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Handle -> m Bool
forall (m :: * -> *). MonadIO m => Handle -> m Bool
U.hIsSeekable Handle
h)

hIsWritable :: MonadIO m => Handle s -> LazyT s m Bool
hIsWritable :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m Bool
hIsWritable (Handle Handle
h) = m Bool -> LazyT s m Bool
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Handle -> m Bool
forall (m :: * -> *). MonadIO m => Handle -> m Bool
U.hIsWritable Handle
h)

hIsReadable :: MonadIO m => Handle s -> LazyT s m Bool
hIsReadable :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m Bool
hIsReadable (Handle Handle
h) = m Bool -> LazyT s m Bool
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Handle -> m Bool
forall (m :: * -> *). MonadIO m => Handle -> m Bool
U.hIsReadable Handle
h)

hPutStrLn :: MonadIO m => Handle s -> String -> LazyT s m ()
hPutStrLn :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> FilePath -> LazyT s m ()
hPutStrLn (Handle Handle
h) FilePath
s = m () -> LazyT s m ()
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Handle -> FilePath -> IO ()
IO.hPutStrLn Handle
h FilePath
s)

hPutStr :: MonadIO m => Handle s -> String -> LazyT s m ()
hPutStr :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> FilePath -> LazyT s m ()
hPutStr (Handle Handle
h) FilePath
s = m () -> LazyT s m ()
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Handle -> FilePath -> IO ()
IO.hPutStr Handle
h FilePath
s)

hPutBs :: MonadIO m => Handle s -> Bs s -> LazyT s m ()
hPutBs :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> Bs s -> LazyT s m ()
hPutBs (Handle Handle
h) (Scoped LByteString
lbs) = m () -> LazyT s m ()
forall {k} {k1} (s :: k) (m :: k1 -> *) (a :: k1).
m a -> LazyT s m a
LazyT (IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Handle -> LByteString -> IO ()
L.hPut Handle
h LByteString
lbs)

hPut :: MonadIO m => Handle s -> L.ByteString -> LazyT s m ()
hPut :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LByteString -> LazyT s m ()
hPut (Handle Handle
h) LByteString
lbs = m () -> LazyT s m ()
forall {k} {k1} (s :: k) (m :: k1 -> *) (a :: k1).
m a -> LazyT s m a
LazyT (IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Handle -> LByteString -> IO ()
L.hPut Handle
h LByteString
lbs)

hPutChar :: MonadIO m => Handle s -> Char -> LazyT s m ()
hPutChar :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> Char -> LazyT s m ()
hPutChar (Handle Handle
h) Char
c = m () -> LazyT s m ()
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Handle -> Char -> IO ()
IO.hPutChar Handle
h Char
c)

hLookAhead :: MonadIO m => Handle s -> LazyT s m Char
hLookAhead :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m Char
hLookAhead (Handle Handle
h) = m Char -> LazyT s m Char
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO Char -> m Char
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Char -> m Char) -> IO Char -> m Char
forall a b. (a -> b) -> a -> b
$ Handle -> IO Char
IO.hLookAhead Handle
h)

hGetLine :: MonadIO m => Handle s -> LazyT s m String
hGetLine :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> LazyT s m FilePath
hGetLine (Handle Handle
h) = m FilePath -> LazyT s m FilePath
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO FilePath -> m FilePath
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FilePath -> m FilePath) -> IO FilePath -> m FilePath
forall a b. (a -> b) -> a -> b
$ Handle -> IO FilePath
IO.hGetLine Handle
h)

hGet :: MonadIO m => Handle s -> Int -> LazyT s m ByteString
hGet :: forall {k} (m :: * -> *) (s :: k).
MonadIO m =>
Handle s -> Int -> LazyT s m ByteString
hGet (Handle Handle
h) Int
n = m ByteString -> LazyT s m ByteString
forall (m :: * -> *) a. Monad m => m a -> LazyT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ Handle -> Int -> IO ByteString
S.hGet Handle
h Int
n)