Hat.System.IO

Documentation

data IO a

Instances

Monad IO

Methods

(!>>=) :: RefSrcPos -> RefExp -> R (Fun (IO a) (Fun (Fun a (IO b)) (IO b)))

(|>>=) :: R (Fun (IO a) (Fun (Fun a (IO b)) (IO b)))

(!>>) :: RefSrcPos -> RefExp -> R (Fun (IO a) (Fun (IO b) (IO b)))

(|>>) :: R (Fun (IO a) (Fun (IO b) (IO b)))

greturn :: RefSrcPos -> RefExp -> R (Fun a (IO a))

sreturn :: R (Fun a (IO a))

gfail :: RefSrcPos -> RefExp -> R (Fun String (IO a))

sfail :: R (Fun String (IO a))

Functor IO

Methods

gfmap :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun (IO a) (IO b)))

sfmap :: R (Fun (Fun a b) (Fun (IO a) (IO b)))

gfixIO :: RefSrcPos -> RefExp -> R (Fun (Fun a (IO a)) (IO a))

afixIO :: RefAtom

hfixIO :: R (Fun b (IO b)) -> RefExp -> R (IO b)

type FilePath = String

data Handle :: *

Haskell defines operations to read and write characters from and to files, represented by values of type Handle. Each value of this type is a handle: a record used by the Haskell run-time system to manage I/O with file system objects. A handle has at least the following properties:

• whether it manages input or output or both;
• whether it is open, closed or semi-closed;
• whether the object is seekable;
• whether buffering is disabled, or enabled on a line or block basis;
• a buffer (whose length may be zero).

Most handles will also have a current I/O position indicating where the next input or output operation will occur. A handle is readable if it manages only input or both input and output; likewise, it is writable if it manages only output or both input and output. A handle is open when first allocated. Once it is closed it can no longer be used for either input or output, though an implementation cannot re-use its storage while references remain to it. Handles are in the Show and Eq classes. The string produced by showing a handle is system dependent; it should include enough information to identify the handle for debugging. A handle is equal according to == only to itself; no attempt is made to compare the internal state of different handles for equality.

Instances

Eq Handle

Methods

(==) :: Handle -> Handle -> Bool

(/=) :: Handle -> Handle -> Bool

Show Handle

Methods

showsPrec :: Int -> Handle -> ShowS

show :: Handle -> String

showList :: [Handle] -> ShowS

gstdin :: RefSrcPos -> RefExp -> R Handle

gstdout :: RefSrcPos -> RefExp -> R Handle

gstderr :: RefSrcPos -> RefExp -> R Handle

gwithFile :: RefSrcPos -> RefExp -> R (Fun String (Fun IOMode (Fun (Fun Handle (IO r)) (IO r))))

awithFile :: RefAtom

hwithFile :: R String -> R IOMode -> R (Fun Handle (IO b)) -> RefExp -> R (IO b)

gopenFile :: RefSrcPos -> RefExp -> R (Fun String (Fun IOMode (IO Handle)))

aopenFile :: RefAtom

hopenFile :: R String -> R IOMode -> RefExp -> R (IO Handle)

data IOMode

Constructors

ReadMode

WriteMode

AppendMode

ReadWriteMode

Instances

WrapVal IOMode

Methods

wrapVal :: RefSrcPos -> IOMode -> RefExp -> R IOMode

Show IOMode

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun IOMode ShowS))

sshowsPrec :: R (Fun Int (Fun IOMode ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun IOMode String)

sshow :: R (Fun IOMode String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List IOMode) ShowS)

sshowList :: R (Fun (List IOMode) ShowS)

Read IOMode

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS IOMode))

sreadsPrec :: R (Fun Int (ReadS IOMode))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List IOMode))

sreadList :: R (ReadS (List IOMode))

Bounded IOMode

Methods

gminBound :: RefSrcPos -> RefExp -> R IOMode

sminBound :: R IOMode

gmaxBound :: RefSrcPos -> RefExp -> R IOMode

smaxBound :: R IOMode

Enum IOMode

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun IOMode IOMode)

gpred :: RefSrcPos -> RefExp -> R (Fun IOMode IOMode)

ssucc :: R (Fun IOMode IOMode)

spred :: R (Fun IOMode IOMode)

gtoEnum :: RefSrcPos -> RefExp -> R (Fun Int IOMode)

stoEnum :: R (Fun Int IOMode)

gfromEnum :: RefSrcPos -> RefExp -> R (Fun IOMode Int)

sfromEnum :: R (Fun IOMode Int)

genumFrom :: RefSrcPos -> RefExp -> R (Fun IOMode (List IOMode))

senumFrom :: R (Fun IOMode (List IOMode))

genumFromThen :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode (List IOMode)))

senumFromThen :: R (Fun IOMode (Fun IOMode (List IOMode)))

genumFromTo :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode (List IOMode)))

senumFromTo :: R (Fun IOMode (Fun IOMode (List IOMode)))

genumFromThenTo :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode (Fun IOMode (List IOMode))))

senumFromThenTo :: R (Fun IOMode (Fun IOMode (Fun IOMode (List IOMode))))

Ord IOMode

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode Ordering))

scompare :: R (Fun IOMode (Fun IOMode Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode Bool))

(|<) :: R (Fun IOMode (Fun IOMode Bool))

(|<=) :: R (Fun IOMode (Fun IOMode Bool))

(|>=) :: R (Fun IOMode (Fun IOMode Bool))

(|>) :: R (Fun IOMode (Fun IOMode Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode IOMode))

gmin :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode IOMode))

smax :: R (Fun IOMode (Fun IOMode IOMode))

smin :: R (Fun IOMode (Fun IOMode IOMode))

Eq IOMode

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode Bool))

(|==) :: R (Fun IOMode (Fun IOMode Bool))

(|/=) :: R (Fun IOMode (Fun IOMode Bool))

Ix IOMode

Methods

grange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 IOMode IOMode) (List IOMode))

srange :: R (Fun (Tuple2 IOMode IOMode) (List IOMode))

gindex :: RefSrcPos -> RefExp -> R (Fun (Tuple2 IOMode IOMode) (Fun IOMode Int))

sindex :: R (Fun (Tuple2 IOMode IOMode) (Fun IOMode Int))

ginRange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 IOMode IOMode) (Fun IOMode Bool))

sinRange :: R (Fun (Tuple2 IOMode IOMode) (Fun IOMode Bool))

grangeSize :: RefSrcPos -> RefExp -> R (Fun (Tuple2 IOMode IOMode) Int)

srangeSize :: R (Fun (Tuple2 IOMode IOMode) Int)

aReadMode :: RefAtom

aWriteMode :: RefAtom

aAppendMode :: RefAtom

aReadWriteMode :: RefAtom

ghClose :: RefSrcPos -> RefExp -> R (Fun Handle (IO Tuple0))

ahClose :: RefAtom

hhClose :: R Handle -> RefExp -> R (IO Tuple0)

greadFile :: RefSrcPos -> RefExp -> R (Fun String (IO String))

areadFile :: RefAtom

hreadFile :: R String -> RefExp -> R (IO String)

gwriteFile :: RefSrcPos -> RefExp -> R (Fun String (Fun String (IO Tuple0)))

awriteFile :: RefAtom

hwriteFile :: R String -> R String -> RefExp -> R (IO Tuple0)

gappendFile :: RefSrcPos -> RefExp -> R (Fun String (Fun String (IO Tuple0)))

aappendFile :: RefAtom

happendFile :: R String -> R String -> RefExp -> R (IO Tuple0)

ghFileSize :: RefSrcPos -> RefExp -> R (Fun Handle (IO Integer))

ahFileSize :: RefAtom

hhFileSize :: R Handle -> RefExp -> R (IO Integer)

ghSetFileSize :: RefSrcPos -> RefExp -> R (Fun Handle (Fun Integer (IO Tuple0)))

ahSetFileSize :: RefAtom

hhSetFileSize :: R Handle -> R Integer -> RefExp -> R (IO Tuple0)

ghIsEOF :: RefSrcPos -> RefExp -> R (Fun Handle (IO Bool))

ahIsEOF :: RefAtom

hhIsEOF :: R Handle -> RefExp -> R (IO Bool)

gisEOF :: RefSrcPos -> RefExp -> R (IO Bool)

data BufferMode

Constructors

NoBuffering

LineBuffering

BlockBuffering (R (Maybe Int))

Instances

WrapVal BufferMode

Methods

wrapVal :: RefSrcPos -> BufferMode -> RefExp -> R BufferMode

Show BufferMode

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun BufferMode ShowS))

sshowsPrec :: R (Fun Int (Fun BufferMode ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun BufferMode String)

sshow :: R (Fun BufferMode String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List BufferMode) ShowS)

sshowList :: R (Fun (List BufferMode) ShowS)

Read BufferMode

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS BufferMode))

sreadsPrec :: R (Fun Int (ReadS BufferMode))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List BufferMode))

sreadList :: R (ReadS (List BufferMode))

Ord BufferMode

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode Ordering))

scompare :: R (Fun BufferMode (Fun BufferMode Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode Bool))

(|<) :: R (Fun BufferMode (Fun BufferMode Bool))

(|<=) :: R (Fun BufferMode (Fun BufferMode Bool))

(|>=) :: R (Fun BufferMode (Fun BufferMode Bool))

(|>) :: R (Fun BufferMode (Fun BufferMode Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode BufferMode))

gmin :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode BufferMode))

smax :: R (Fun BufferMode (Fun BufferMode BufferMode))

smin :: R (Fun BufferMode (Fun BufferMode BufferMode))

Eq BufferMode

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode Bool))

(|==) :: R (Fun BufferMode (Fun BufferMode Bool))

(|/=) :: R (Fun BufferMode (Fun BufferMode Bool))

aNoBuffering :: RefAtom

aLineBuffering :: RefAtom

aBlockBuffering :: RefAtom

ghSetBuffering :: RefSrcPos -> RefExp -> R (Fun Handle (Fun BufferMode (IO Tuple0)))

ahSetBuffering :: RefAtom

hhSetBuffering :: R Handle -> R BufferMode -> RefExp -> R (IO Tuple0)

ghGetBuffering :: RefSrcPos -> RefExp -> R (Fun Handle (IO BufferMode))

ahGetBuffering :: RefAtom

hhGetBuffering :: R Handle -> RefExp -> R (IO BufferMode)

ghFlush :: RefSrcPos -> RefExp -> R (Fun Handle (IO Tuple0))

ahFlush :: RefAtom

hhFlush :: R Handle -> RefExp -> R (IO Tuple0)

ghGetPosn :: RefSrcPos -> RefExp -> R (Fun Handle (IO HandlePosn))

ahGetPosn :: RefAtom

hhGetPosn :: R Handle -> RefExp -> R (IO HandlePosn)

ghSetPosn :: RefSrcPos -> RefExp -> R (Fun HandlePosn (IO Tuple0))

ahSetPosn :: RefAtom

hhSetPosn :: R HandlePosn -> RefExp -> R (IO Tuple0)

data HandlePosn :: *

Instances

Eq HandlePosn

Methods

(==) :: HandlePosn -> HandlePosn -> Bool

(/=) :: HandlePosn -> HandlePosn -> Bool

Show HandlePosn

Methods

showsPrec :: Int -> HandlePosn -> ShowS

show :: HandlePosn -> String

showList :: [HandlePosn] -> ShowS

ghSeek :: RefSrcPos -> RefExp -> R (Fun Handle (Fun SeekMode (Fun Integer (IO Tuple0))))

ahSeek :: RefAtom

hhSeek :: R Handle -> R SeekMode -> R Integer -> RefExp -> R (IO Tuple0)

data SeekMode

Constructors

AbsoluteSeek

RelativeSeek

SeekFromEnd

Instances

WrapVal SeekMode

Methods

wrapVal :: RefSrcPos -> SeekMode -> RefExp -> R SeekMode

Show SeekMode

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun SeekMode ShowS))

sshowsPrec :: R (Fun Int (Fun SeekMode ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun SeekMode String)

sshow :: R (Fun SeekMode String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List SeekMode) ShowS)

sshowList :: R (Fun (List SeekMode) ShowS)

Read SeekMode

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS SeekMode))

sreadsPrec :: R (Fun Int (ReadS SeekMode))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List SeekMode))

sreadList :: R (ReadS (List SeekMode))

Bounded SeekMode

Methods

gminBound :: RefSrcPos -> RefExp -> R SeekMode

sminBound :: R SeekMode

gmaxBound :: RefSrcPos -> RefExp -> R SeekMode

smaxBound :: R SeekMode

Enum SeekMode

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun SeekMode SeekMode)

gpred :: RefSrcPos -> RefExp -> R (Fun SeekMode SeekMode)

ssucc :: R (Fun SeekMode SeekMode)

spred :: R (Fun SeekMode SeekMode)

gtoEnum :: RefSrcPos -> RefExp -> R (Fun Int SeekMode)

stoEnum :: R (Fun Int SeekMode)

gfromEnum :: RefSrcPos -> RefExp -> R (Fun SeekMode Int)

sfromEnum :: R (Fun SeekMode Int)

genumFrom :: RefSrcPos -> RefExp -> R (Fun SeekMode (List SeekMode))

senumFrom :: R (Fun SeekMode (List SeekMode))

genumFromThen :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode (List SeekMode)))

senumFromThen :: R (Fun SeekMode (Fun SeekMode (List SeekMode)))

genumFromTo :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode (List SeekMode)))

senumFromTo :: R (Fun SeekMode (Fun SeekMode (List SeekMode)))

genumFromThenTo :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode (Fun SeekMode (List SeekMode))))

senumFromThenTo :: R (Fun SeekMode (Fun SeekMode (Fun SeekMode (List SeekMode))))

Ord SeekMode

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode Ordering))

scompare :: R (Fun SeekMode (Fun SeekMode Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode Bool))

(|<) :: R (Fun SeekMode (Fun SeekMode Bool))

(|<=) :: R (Fun SeekMode (Fun SeekMode Bool))

(|>=) :: R (Fun SeekMode (Fun SeekMode Bool))

(|>) :: R (Fun SeekMode (Fun SeekMode Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode SeekMode))

gmin :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode SeekMode))

smax :: R (Fun SeekMode (Fun SeekMode SeekMode))

smin :: R (Fun SeekMode (Fun SeekMode SeekMode))

Eq SeekMode

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode Bool))

(|==) :: R (Fun SeekMode (Fun SeekMode Bool))

(|/=) :: R (Fun SeekMode (Fun SeekMode Bool))

Ix SeekMode

Methods

grange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 SeekMode SeekMode) (List SeekMode))

srange :: R (Fun (Tuple2 SeekMode SeekMode) (List SeekMode))

gindex :: RefSrcPos -> RefExp -> R (Fun (Tuple2 SeekMode SeekMode) (Fun SeekMode Int))

sindex :: R (Fun (Tuple2 SeekMode SeekMode) (Fun SeekMode Int))

ginRange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 SeekMode SeekMode) (Fun SeekMode Bool))

sinRange :: R (Fun (Tuple2 SeekMode SeekMode) (Fun SeekMode Bool))

grangeSize :: RefSrcPos -> RefExp -> R (Fun (Tuple2 SeekMode SeekMode) Int)

srangeSize :: R (Fun (Tuple2 SeekMode SeekMode) Int)

aAbsoluteSeek :: RefAtom

aRelativeSeek :: RefAtom

aSeekFromEnd :: RefAtom

ghTell :: RefSrcPos -> RefExp -> R (Fun Handle (IO Integer))

ahTell :: RefAtom

hhTell :: R Handle -> RefExp -> R (IO Integer)

ghIsOpen :: RefSrcPos -> RefExp -> R (Fun Handle (IO Bool))

ahIsOpen :: RefAtom

hhIsOpen :: R Handle -> RefExp -> R (IO Bool)

ghIsClosed :: RefSrcPos -> RefExp -> R (Fun Handle (IO Bool))

ahIsClosed :: RefAtom

hhIsClosed :: R Handle -> RefExp -> R (IO Bool)

ghIsReadable :: RefSrcPos -> RefExp -> R (Fun Handle (IO Bool))

ahIsReadable :: RefAtom

hhIsReadable :: R Handle -> RefExp -> R (IO Bool)

ghIsWritable :: RefSrcPos -> RefExp -> R (Fun Handle (IO Bool))

ahIsWritable :: RefAtom

hhIsWritable :: R Handle -> RefExp -> R (IO Bool)

ghIsSeekable :: RefSrcPos -> RefExp -> R (Fun Handle (IO Bool))

ahIsSeekable :: RefAtom

hhIsSeekable :: R Handle -> RefExp -> R (IO Bool)

ghIsTerminalDevice :: RefSrcPos -> RefExp -> R (Fun Handle (IO Bool))

ahIsTerminalDevice :: RefAtom

hhIsTerminalDevice :: R Handle -> RefExp -> R (IO Bool)

ghSetEcho :: RefSrcPos -> RefExp -> R (Fun Handle (Fun Bool (IO Tuple0)))

ahSetEcho :: RefAtom

hhSetEcho :: R Handle -> R Bool -> RefExp -> R (IO Tuple0)

ghGetEcho :: RefSrcPos -> RefExp -> R (Fun Handle (IO Bool))

ahGetEcho :: RefAtom

hhGetEcho :: R Handle -> RefExp -> R (IO Bool)

ghShow :: RefSrcPos -> RefExp -> R (Fun Handle (IO String))

ahShow :: RefAtom

hhShow :: R Handle -> RefExp -> R (IO String)

ghWaitForInput :: RefSrcPos -> RefExp -> R (Fun Handle (Fun Int (IO Bool)))

ahWaitForInput :: RefAtom

hhWaitForInput :: R Handle -> R Int -> RefExp -> R (IO Bool)

ghReady :: RefSrcPos -> RefExp -> R (Fun Handle (IO Bool))

ahReady :: RefAtom

hhReady :: R Handle -> RefExp -> R (IO Bool)

ghGetChar :: RefSrcPos -> RefExp -> R (Fun Handle (IO Char))

ahGetChar :: RefAtom

hhGetChar :: R Handle -> RefExp -> R (IO Char)

ghGetLine :: RefSrcPos -> RefExp -> R (Fun Handle (IO String))

ahGetLine :: RefAtom

hhGetLine :: R Handle -> RefExp -> R (IO String)

ghLookAhead :: RefSrcPos -> RefExp -> R (Fun Handle (IO Char))

ahLookAhead :: RefAtom

hhLookAhead :: R Handle -> RefExp -> R (IO Char)

ghGetContents :: RefSrcPos -> RefExp -> R (Fun Handle (IO String))

ahGetContents :: RefAtom

hhGetContents :: R Handle -> RefExp -> R (IO String)

ghPutChar :: RefSrcPos -> RefExp -> R (Fun Handle (Fun Char (IO Tuple0)))

ahPutChar :: RefAtom

hhPutChar :: R Handle -> R Char -> RefExp -> R (IO Tuple0)

ghPutStr :: RefSrcPos -> RefExp -> R (Fun Handle (Fun String (IO Tuple0)))

ahPutStr :: RefAtom

hhPutStr :: R Handle -> R String -> RefExp -> R (IO Tuple0)

ghPutStrLn :: RefSrcPos -> RefExp -> R (Fun Handle (Fun String (IO Tuple0)))

ahPutStrLn :: RefAtom

hhPutStrLn :: R Handle -> R String -> RefExp -> R (IO Tuple0)

ghPrint :: Show a => RefSrcPos -> RefExp -> R (Fun Handle (Fun a (IO Tuple0)))

ahPrint :: RefAtom

hhPrint :: Show a => R Handle -> R a -> RefExp -> R (IO Tuple0)

ginteract :: RefSrcPos -> RefExp -> R (Fun (Fun String String) (IO Tuple0))

ainteract :: RefAtom

hinteract :: R (Fun String String) -> RefExp -> R (IO Tuple0)

gputChar :: RefSrcPos -> RefExp -> R (Fun Char (IO Tuple0))

aputChar :: RefAtom

hputChar :: R Char -> RefExp -> R (IO Tuple0)

gputStr :: RefSrcPos -> RefExp -> R (Fun String (IO Tuple0))

aputStr :: RefAtom

hputStr :: R String -> RefExp -> R (IO Tuple0)

gputStrLn :: RefSrcPos -> RefExp -> R (Fun String (IO Tuple0))

aputStrLn :: RefAtom

hputStrLn :: R String -> RefExp -> R (IO Tuple0)

gprint :: Show a => RefSrcPos -> RefExp -> R (Fun a (IO Tuple0))

aprint :: RefAtom

hprint :: Show a => R a -> RefExp -> R (IO Tuple0)

ggetChar :: RefSrcPos -> RefExp -> R (IO Char)

ggetLine :: RefSrcPos -> RefExp -> R (IO String)

ggetContents :: RefSrcPos -> RefExp -> R (IO String)

greadIO :: Read a => RefSrcPos -> RefExp -> R (Fun String (IO a))

areadIO :: RefAtom

hreadIO :: Read a => R String -> RefExp -> R (IO a)

greadLn :: Read a => RefSrcPos -> RefExp -> R (IO a)