MetadataErr
Path > MetadataErr
Path
Path > Path
DirEntry
Path > DirEntry
ReadErr
Path > ReadErr
WriteErr
Path > WriteErr
DirErr
Path > DirErr
write
Path, val, fmt -> Task {} [FileWriteErr Path WriteErr] where val implements Encoding, fmt implements EncoderFormatting
Path > write
writeBytes
Path, List U8 -> Task {} [FileWriteErr Path WriteErr]
Path > writeBytes
writeUtf8
Path, Str -> Task {} [FileWriteErr Path WriteErr]
Path > writeUtf8
fromStr
Str -> Path
Path > fromStr
fromBytes
List U8 -> Path
Path > fromBytes
display
Path -> Str
Path > display
isDir
Path -> Task Bool [PathErr MetadataErr]
Path > isDir
isFile
Path > isFile
isSymLink
Path > isSymLink
type
Path -> Task [ IsFile, IsDir, IsSymLink ] [PathErr MetadataErr]
Path > type
withExtension
Path, Str -> Path
Path > withExtension
delete
Path -> Task {} [FileWriteErr Path WriteErr]
Path > delete
readUtf8
Path -> Task Str [ FileReadErr Path ReadErr, FileReadUtf8Err Path ]
Path > readUtf8
readBytes
Path -> Task (List U8) [FileReadErr Path ReadErr]
Path > readBytes
listDir
Path -> Task (List Path) [DirErr DirErr]
Path > listDir
deleteEmpty
Path -> Task {} [DirErr DirErr]
Path > deleteEmpty
deleteAll
Path > deleteAll
createDir
Path > createDir
createAll
Path > createAll
list
{} -> Task (List Str) *
Arg > list
parse
CliParser state -> Task state [ Exit I32 Str, StdoutErr Stdout.Err ]
Arg > parse
Err
Path.DirErr
Dir > Err
Path.DirEntry
Dir > DirEntry
Str -> Task (List Path) [DirErr Err]
Dir > list
Str -> Task {} [DirErr Err]
Dir > deleteEmpty
Dir > deleteAll
create
Dir > create
Dir > createAll
cwd
Task Path [CwdUnavailable]
Env > cwd
setCwd
Path -> Task {} [InvalidCwd]
Env > setCwd
exePath
Task Path [ExePathUnavailable]
Env > exePath
var
Str -> Task Str [VarNotFound]
Env > var
decode
Str -> Task val [ VarNotFound, DecodeErr DecodeError ] where val implements Decoding
Env > decode
dict
{} -> Task (Dict Str Str) *
Env > dict
platform
Task { arch : ARCH, os : OS } *
Env > platform
tempDir
{} -> Task Path *
Env > tempDir
Path.ReadErr
File > ReadErr
Path.WriteErr
File > WriteErr
Str, val, fmt -> Task {} [FileWriteErr Path WriteErr] where val implements Encoding, fmt implements EncoderFormatting
File > write
Str, List U8 -> Task {} [FileWriteErr Path WriteErr]
File > writeBytes
Str, Str -> Task {} [FileWriteErr Path WriteErr]
File > writeUtf8
Str -> Task {} [FileWriteErr Path WriteErr]
File > delete
Str -> Task (List U8) [FileReadErr Path ReadErr]
File > readBytes
Str -> Task Str [ FileReadErr Path ReadErr, FileReadUtf8Err Path ]
File > readUtf8
Str -> Task Bool [PathErr MetadataErr]
File > isDir
File > isFile
File > isSymLink
Str -> Task [ IsFile, IsDir, IsSymLink ] [PathErr MetadataErr]
File > type
Reader
File > Reader
openReader
Str -> Task Reader [GetFileReadErr Path ReadErr]
File > openReader
openReaderWithCapacity
Str, U64 -> Task Reader [GetFileReadErr Path ReadErr]
File > openReaderWithCapacity
readLine
Reader -> Task (List U8) [FileReadErr Path Str]
File > readLine
FileMetadata
FileMetadata > FileMetadata
bytes
FileMetadata -> U64
FileMetadata > bytes
isReadonly
FileMetadata -> Bool
FileMetadata > isReadonly
FileMetadata -> [ File, Dir, Symlink ]
FileMetadata > type
mode
FileMetadata -> [ Unix U32, NonUnix ]
FileMetadata > mode
Request
Http > Request
Method
Http > Method
Header
Http > Header
TimeoutConfig
Http > TimeoutConfig
Response
Http > Response
Http > Err
errorBodyToBytes
Http > errorBodyToBytes
defaultRequest
Http > defaultRequest
header
Str, Str -> Header
Http > header
handleStringResponse
Response -> Result Str Err
Http > handleStringResponse
errorToString
Err -> Str
Http > errorToString
send
Request -> Task Response [HttpErr Err]
Http > send
get
Str, fmt -> Task body [ HttpErr Http.Err, HttpDecodingFailed ] where body implements Decoding, fmt implements DecoderFormatting
Http > get
Stderr > Err
line
Str -> Task {} [StderrErr Err]
Stderr > line
Stderr > write
Stdin > Err
Task Str [StdinErr Err]
Stdin > line
{} -> Task (List U8) *
Stdin > bytes
readToEnd
{} -> Task (List U8) [StdinErr Err]
Stdin > readToEnd
Stdout > Err
Str -> Task {} [StdoutErr Err]
Stdout > line
Stdout > write
Stream
Tcp > Stream
ConnectErr
Tcp > ConnectErr
StreamErr
Tcp > StreamErr
connect
Str, U16 -> Task Stream ConnectErr
Tcp > connect
readUpTo
Stream, U64 -> Task (List U8) [TcpReadErr StreamErr]
Tcp > readUpTo
readExactly
Stream, U64 -> Task (List U8) [ TcpReadErr StreamErr, TcpUnexpectedEOF ]
Tcp > readExactly
readUntil
Stream, U8 -> Task (List U8) [TcpReadErr StreamErr]
Tcp > readUntil
Stream -> Task Str [ TcpReadErr StreamErr, TcpReadBadUtf8 ]
Tcp > readLine
Stream, List U8 -> Task {} [TcpWriteErr StreamErr]
Tcp > write
Stream, Str -> Task {} [TcpWriteErr StreamErr]
Tcp > writeUtf8
connectErrToStr
ConnectErr -> Str
Tcp > connectErrToStr
streamErrToStr
StreamErr -> Str
Tcp > streamErrToStr
Url
Url > Url
reserve
Url, U64 -> Url
Url > reserve
Str -> Url
Url > fromStr
toStr
Url -> Str
Url > toStr
append
Url, Str -> Url
Url > append
appendParam
Url, Str, Str -> Url
Url > appendParam
withQuery
Url > withQuery
query
Url > query
hasQuery
Url -> Bool
Url > hasQuery
fragment
Url > fragment
withFragment
Url > withFragment
hasFragment
Url > hasFragment
Utc
Utc > Utc
now
{} -> Task Utc *
Utc > now
toMillisSinceEpoch
Utc -> I128
Utc > toMillisSinceEpoch
fromMillisSinceEpoch
I128 -> Utc
Utc > fromMillisSinceEpoch
toNanosSinceEpoch
Utc > toNanosSinceEpoch
fromNanosSinceEpoch
Utc > fromNanosSinceEpoch
deltaAsMillis
Utc, Utc -> U128
Utc > deltaAsMillis
deltaAsNanos
Utc > deltaAsNanos
millis
U64 -> Task {} *
Sleep > millis
Cmd
Cmd > Cmd
Cmd > Err
outputErrToStr
( Output, Err ) -> Str
Cmd > outputErrToStr
Output
Cmd > Output
new
Str -> Cmd
Cmd > new
arg
Cmd, Str -> Cmd
Cmd > arg
args
Cmd, List Str -> Cmd
Cmd > args
env
Cmd, Str, Str -> Cmd
Cmd > env
envs
Cmd, List ( Str, Str ) -> Cmd
Cmd > envs
clearEnvs
Cmd -> Cmd
Cmd > clearEnvs
output
Cmd -> Task Output [ CmdOutputError ( Output, Err ) ]
Cmd > output
status
Cmd -> Task {} [CmdError Err]
Cmd > status
exec
Str, List Str -> Task {} [CmdError Err]
Cmd > exec
enableRawMode
{} -> Task {} *
Tty > enableRawMode
disableRawMode
Tty > disableRawMode
Sleep for at least the given number of milliseconds. This uses rust's std::thread::sleep.