type Either a b = Left a | Right b

type Optional a = None | Some a

-- This is linked to definitions that are considered tests

unique[e6dca08b40458b03ca1660cfbdaecaa7279b42d18257898b5fd1c34596aac36f] type

IsTest = IsTest

links.isTest = IsTest.IsTest

-- Handles are unique identifiers.

-- The implementation of IO in the runtime will supply Haskell

-- file handles and map those to Unison handles.

-- A pure implementation of I/O might use some kind of pure supply

-- of unique IDs instead.

unique[d4597403ec40fd4fbee57c62b8096f9c3d382dff01f20108546fe3530a927e86] type

io.Handle = Handle Text

-- Ditto for sockets

unique[e1d94401fde8b2546d6dfc54e93f11e6a9285a7ea765d3255da19122a42715d3] type

io.Socket = Socket Text

-- Builtin handles: standard in, out, error

use io Error Mode Handle IO Socket ThreadId HostName FilePath EpochTime

BufferMode SeekMode ServiceName

use io.Handle Handle

namespace io where

stdin : Handle

stdin = Handle "stdin"

stdout : Handle

stdout = Handle "stdout"

stderr : Handle

stderr = Handle "stderr"

-- Throw an I/O error on the left as an effect in `IO`

rethrow : (Either io.Error a) -> {IO} a

rethrow x = case x of

Either.Left e -> io.IO.throw e

Either.Right a -> a

-- Print a line to the standard output

printLine : Text ->{IO} ()

printLine t =

putText stdout t

putText stdout "\n"

-- Read a line from the standard input

readLine : '{IO} Text

readLine = '(getLine stdin)

-- Built-ins

-- Open a named file in the given mode, yielding an open file handle

openFile : FilePath -> Mode ->{IO} Handle

openFile f m = rethrow (io.IO.openFile_ f m)

-- Close an open file handle

closeFile : Handle ->{IO} ()

closeFile f = rethrow (io.IO.closeFile_ f)

-- Check whether a file handle has reached the end of the file

isFileEOF : Handle ->{IO} Boolean

isFileEOF h = rethrow (io.IO.isFileEOF_ h)

-- Check whether a file handle is open

isFileOpen : Handle ->{IO} Boolean

isFileOpen h = rethrow (io.IO.isFileOpen_ h)

-- Get a line of text from a text file handle

getLine : Handle ->{IO} Text

getLine h = rethrow (io.IO.getLine_ h)

-- Get the entire contents of a file as a single block of text

getText : Handle ->{IO} Text

getText h = rethrow (io.IO.getText_ h)

-- Write some text to a file

putText : Handle -> Text ->{IO} ()

putText h t = rethrow (io.IO.putText_ h t)

-- Get epoch system time

systemTime : '{IO} EpochTime

systemTime = '(rethrow (io.IO.systemTime_))

-- Does the file handle support `seek`?

isSeekable : Handle -> {IO} Boolean

isSeekable h = rethrow (io.IO.isSeekable_ h)

-- Seek to a position in a file handle

seek : Handle -> SeekMode -> Int ->{IO} ()

seek h m i = rethrow (io.IO.seek_ h m i)

-- Ask for the position of a file handle

position : Handle ->{IO} Int

position h = rethrow (io.IO.position_ h)

-- Get the buffer mode of a file handle

getBuffering : Handle ->{IO} (Optional BufferMode)

getBuffering h = rethrow (io.IO.getBuffering_ h)

-- Set the buffer mode for a file handle

setBuffering : Handle -> Optional BufferMode ->{IO} ()

setBuffering h bm = rethrow (io.IO.setBuffering_ h bm)

-- Get the path to a temporary directory managed by the operating system

getTemporaryDirectory : '{IO} FilePath

getTemporaryDirectory = '(rethrow (io.IO.getTemporaryDirectory_))

-- Get the current working directory

getCurrentDirectory : '{IO} FilePath

getCurrentDirectory = '(rethrow (io.IO.getCurrentDirectory_))

-- Set the current working directory

setCurrentDirectory : FilePath -> {IO} ()

setCurrentDirectory d = rethrow (io.IO.setCurrentDirectory_ d)

-- List the contents of a directory

directoryContents : FilePath -> {IO} [FilePath]

directoryContents d = rethrow (io.IO.directoryContents_ d)

-- Check if a path exists

fileExists : FilePath -> {IO} Boolean

fileExists d = rethrow (io.IO.fileExists_ d)

-- Check if a path is a directory

isDirectory : FilePath -> {IO} Boolean

isDirectory d = rethrow (io.IO.isDirectory_ d)

-- Create a directory at the given path, including parent directories

createDirectory : FilePath -> {IO} ()

createDirectory d = rethrow (io.IO.createDirectory_ d)

-- Remove the directory at the given path

removeDirectory : FilePath -> {IO} ()

removeDirectory d = rethrow (io.IO.removeDirectory_ d)

-- Move a directory from one path to another

renameDirectory : FilePath -> FilePath -> {IO} ()

renameDirectory from to = rethrow (io.IO.renameDirectory_ from to)

-- Remove a file from the file system

removeFile : FilePath -> {IO} ()

removeFile d = rethrow (io.IO.removeFile_ d)

-- Move a file from one path to another

renameFile : FilePath -> FilePath -> {IO} ()

renameFile from to = rethrow (io.IO.renameFile_ from to)

-- Get the timestamp of a file

getFileTimestamp : FilePath -> {IO} EpochTime

getFileTimestamp d = rethrow (io.IO.getFileTimestamp_ d)

-- Get the size of a file in bytes

getFileSize : FilePath -> {IO} Nat

getFileSize d = rethrow (io.IO.getFileSize_ d)

-- Create a socket bound to the given local port/service.

-- If a hostname is not given, this will use any available host.

serverSocket : Optional HostName -> ServiceName -> {IO} Socket

serverSocket host service = rethrow (io.IO.serverSocket_ host service)

-- Start listening for connections on the given socket.

listen : Socket -> {IO} ()

listen s = rethrow (io.IO.listen_ s)

-- Create a socket connected to the given remote address.

clientSocket : HostName -> ServiceName -> {IO} Socket

clientSocket host service = rethrow (io.IO.clientSocket_ host service)

-- Close a socket and all connections to it.

closeSocket : Socket -> {IO} ()

closeSocket s = rethrow (io.IO.closeSocket_ s)

-- Accept a connection on a socket.

-- Returns a socket that can send and receive data on a new connection

accept : Socket -> {IO} Socket

accept s = rethrow (io.IO.accept_ s)

-- Send some bytes to a socket.

send : Socket -> Bytes -> {IO} ()

send s bs = rethrow (io.IO.send_ s bs)

-- Read the specified number of bytes from a socket.

receive : Socket -> Nat ->{IO} (Optional Bytes)

receive s n = rethrow (io.IO.receive_ s n)

-- Fork a new thread.

fork : '{IO} a -> {IO} ThreadId

fork a = rethrow (io.IO.fork_ a)

-- Kill a running thread.

kill : ThreadId -> {IO} ()

kill t = rethrow (io.IO.kill_ t)

-- Suspend the current thread for a number of microseconds.

delay : Nat -> {IO} ()

delay n = rethrow (io.IO.delay_ n)

-- Safely acquire and release a resource

bracket : '{IO} a -> (a ->{IO} b) -> (a ->{IO} c) -> {IO} c

bracket acquire release what = rethrow (io.IO.bracket_ acquire release what)

-- Run the given computation, and if it throws an error

-- handle the error with the given handler.

-- catch : '{IO} a -> (io.Error ->{IO} a) ->{IO} a

-- catch c h =

-- k io = case io of

-- { IO.throw e } -> h e

-- x -> x

-- handle k in c

-- IO Modes from the Haskell API

type io.Mode = Read | Write | Append | ReadWrite

-- IO error types from the Haskell API

unique[bb57f367a3740d4a1608b9e0eee14fd744ec9e368f1529550cb436ef56c0b268] type

io.ErrorType

= AlreadyExists

| NoSuchThing

| ResourceBusy

| ResourceExhausted

| EOF

| IllegalOperation

| PermissionDenied

| UserError

unique[b5c578f0a9977ed54a5a12b580dc6b0b2ba37bc3f517f48d1b3285a7f3e8c6bc] type

io.ErrorLocation = ErrorLocation Text

unique[e6ca048b6bf540f93617c0ef9506afcbb490427a9581a01d51ffad39cdf2c554] type

io.ErrorDescription = ErrorDescription Text

unique[d5d61b0a65f1d448dbdeed8af688f0bdbab6b3f775400da370eb5bfc34e428d5] type

io.FilePath = FilePath Text

type io.Error = Error io.ErrorType Text

unique[cad7ab802bd143f0b674155c9caf18dde7145d16867a02659534d7bb01a5e287] type

io.SeekMode = Absolute | Relative | FromEnd

-- If the buffer size is not specified,

-- use an implementation-specific size.

unique[e65de145a461a771de93d6c7885acae28552d77f8ae460bc8bf5de6f2a15ff77] type

io.BufferMode = Line | Block (Optional Nat)

unique[e1f48f31982a720ae895c0bf4e6ea9a950f5c00d3a73101ad31e63461b7beded] type

io.EpochTime = EpochTime Nat

-- Either a host name e.g., "unisonweb.org" or a numeric host address

-- string consisting of a dotted decimal IPv4 address

-- e.g., "192.168.0.1".

unique[c7279b501764751edc66f1f7b532e68354fc4704c9eb1ed201f01c894cdd86f4] type

io.HostName = HostName Text

-- For example a port number like "8080"

unique[ee4ff0bda526b0513e4c7b7387b39811ce57938ddb31a77fdb0ff00ee2717c33] type

io.ServiceName = ServiceName Text

unique[a38186de35c9fcd29d2b359b2148f9f890732413d91575af39d025fcded67e89] type

io.ThreadId = ThreadId Text

ability io.IO where

-- Basic file IO

openFile_ : io.FilePath -> io.Mode -> (Either io.Error io.Handle)

closeFile_ : io.Handle -> (Either io.Error ())

isFileEOF_ : io.Handle -> (Either io.Error Boolean)

isFileOpen_ : io.Handle -> (Either io.Error Boolean)

-- Text input and output

--getChar : io.Handle -> Char

getLine_ : io.Handle -> (Either io.Error Text)

-- Get the entire contents of the file as text

getText_ : io.Handle -> (Either io.Error Text)

-- putChar : io.Handle -> Char -> ()

putText_ : io.Handle -> Text -> (Either io.Error ())

-- Throw an error as an `io.IO` effect

throw : io.Error -> a

-- File positioning

isSeekable_ : io.Handle -> (Either io.Error Boolean)

seek_ : io.Handle -> io.SeekMode -> Int -> (Either io.Error ())

position_ : io.Handle -> (Either io.Error Int)

-- File buffering

getBuffering_ : io.Handle -> Either io.Error (Optional io.BufferMode)

setBuffering_ : io.Handle -> Optional io.BufferMode -> (Either io.Error ())

-- Should we expose mutable arrays for byte buffering?

-- Inclined to say no, although that sounds a lot like

-- a decision to just be slow.

-- We'll need a byte buffer manipulation library in that case.

-- getBytes : io.Handle -> Nat -> Bytes

-- putBytes : io.Handle -> Bytes -> ()

-- getBytes : io.Handle -> Nat -> ByteArray -> Nat

-- putBytes : io.Handle -> Nat -> ByteArray -> ()

systemTime_ : (Either io.Error io.EpochTime)

-- File system operations

getTemporaryDirectory_ : (Either io.Error io.FilePath)

getCurrentDirectory_ : (Either io.Error io.FilePath)

setCurrentDirectory_ : io.FilePath -> (Either io.Error ())

directoryContents_ : io.FilePath -> Either io.Error [io.FilePath]

fileExists_ : io.FilePath -> (Either io.Error Boolean)

isDirectory_ : io.FilePath -> (Either io.Error Boolean)

createDirectory_ : io.FilePath -> (Either io.Error ())

removeDirectory_ : io.FilePath -> (Either io.Error ())

renameDirectory_ : io.FilePath -> io.FilePath -> (Either io.Error ())

removeFile_ : io.FilePath -> (Either io.Error ())

renameFile_ : io.FilePath -> io.FilePath -> (Either io.Error ())

getFileTimestamp_ : io.FilePath -> (Either io.Error io.EpochTime)

getFileSize_ : io.FilePath -> (Either io.Error Nat)

-- Simple TCP Networking

-- Create a socket bound to the given local address.

-- If a hostname is not given, this will use any available host.

serverSocket_ : Optional io.HostName ->

io.ServiceName -> (Either io.Error io.Socket)

-- Start listening for connections

listen_ : io.Socket -> (Either io.Error ())

-- Create a socket connected to the given remote address

clientSocket_ : io.HostName ->

io.ServiceName -> (Either io.Error io.Socket)

closeSocket_ : io.Socket -> (Either io.Error ())

--socketToio.Handle : Socket -> Mode -> (Either io.Error io.Handle)

--handleToSocket : io.Handle -> (Either io.Error Socket)

-- Accept a connection on a socket.

-- Returns a socket that can send and receive data on a new connection

accept_ : io.Socket -> (Either io.Error io.Socket)

-- Send some bytes to a socket.

send_ : io.Socket -> Bytes -> (Either io.Error ())

-- Read the spefified number of bytes from the socket.

receive_ : io.Socket -> Nat -> (Either io.Error (Optional Bytes))

-- scatter/gather mode network I/O

-- sendMany : Socket -> [Bytes] -> Int

-- Threading --

-- Fork a thread

fork_ : '{io.IO} a -> (Either io.Error io.ThreadId)

-- Kill a running thread

kill_ : io.ThreadId -> (Either io.Error ())

-- Suspend the current thread for a number of microseconds.

delay_ : Nat -> (Either io.Error ())

-- Safely acquire and release a resource

bracket_ : '{io.IO} a -> (a ->{io.IO} b) -> (a ->{io.IO} c) ->{io.IO} (Either io.Error c)