diff options
Diffstat (limited to 'doc/api/libstd/index.txt')
| -rw-r--r-- | doc/api/libstd/index.txt | 711 |
1 files changed, 711 insertions, 0 deletions
diff --git a/doc/api/libstd/index.txt b/doc/api/libstd/index.txt new file mode 100644 index 0000000..f154f09 --- /dev/null +++ b/doc/api/libstd/index.txt @@ -0,0 +1,711 @@ +{ + title: libstd + description: libstd: Summary +} + +Libstd Summary +--------------- + +This is a summary page listing all of the functions and types available +in libstd, sorted by category. The library is a bit of a grab bag of +functionality, but a good chunk of what is needed will be built in to +the library. + + +#### [Memory Allocation](alloc) + +Memory allocation is a function that nearly every program needs +to be able to do. Myrddin's generics allow for relatively easy +to use and typesafe functions for this to be written. + + pkg std = + generic mk : (val : @a -> @a#) + generic alloc : ( -> @a#) + generic zalloc : ( -> @a#) + generic free : (v:@a# -> void) + generic slalloc : (len : size -> @a[:]) + generic slzalloc : (len : size -> @a[:]) + generic slgrow : (sl : @a[:]#, len : size -> @a[:]) + generic slzgrow : (sl : @a[:]#, len : size -> @a[:]) + generic slfree : (sl : @a[:] -> void) + const bytealloc : (sz:size -> byte#) + const zbytealloc : (sz:size -> byte#) + const bytefree : (m:byte#, sz:size -> void) + ;; + +#### [Error Handling](err) + +Myrddin provides a number of types and operations for propagating errors +for later handling. + +It also provides operations for throwing up your hands, setting yourself on +fire, and screaming, if that's more appropriate. + + pkg std = + type option(@a) = union + `Some @a + `None + ;; + pkg std = + type result(@a, @b) = union + `Ok @a + `Fail @b + ;; + ;; + + $noret const fatalv : (fmt : byte[:], ap : valist# -> void) + $noret const fatal : (fmt : byte[:], args : ... -> void) + const assert : (cond : bool, fmt : byte[:], args : ... -> void) + const suicide : ( -> void) + + generic try : (v : result(@a, @b) -> @a) + generic tryv : (v : result(@a, @b), d : @a -> @a) + generic get : (v : option(@a) -> @a) + generic getv : (v : option(@a), d : @a -> @a) + ;; + +#### [OS Interfaces](os) + +The OS interfaces cover some portable primitives for handling processes +and OS errors. It restricts itself to a set of portable wrappers for OS +functionality. + +For complete interfaces, the `sys` library is your friend, providing +all OS functionality that can be provided. + + pkg std = + type sysinfo = struct + system : byte[:] + version : byte[:] + release : byte[:] + arch : byte[:] + uname : sys.utsname /* storage */ + ;; + + type waitstatus = union + `Wsuccess + `Wfailure + `Wsignalled + `Waiterror + ;; + + const Enone : errno + const Erange : errno + const Ebadf : errno + const Eexist : errno + const Einval : errno + const Efault : errno + const Eio : errno + const Emisc : errno + + const getsysinfo : (si : sysinfo# -> void) + const execvp : (cmd : byte[:], args : byte[:][:] -> int64) + const execvpe : (cmd : byte[:], args : byte[:][:], env : byte[:][:] -> int64) + const getenv : (name : byte[:] -> option(byte[:])) + const getenvv : (name : byte[:], default : byte[:] -> byte[:]) + const getpid : ( -> pid) + const fork : (-> pid) + const exec : (cmd : byte[:], args : byte[:][:] -> int64) + const execve : (cmd : byte[:], args : byte[:][:], env : byte[:][:] -> int64) + const waitpid : (pid:pid, loc:int32#, opt : int64 -> int64) + const spork : (cmd : byte[:][:] -> result((pid, fd, fd), int)) + const sporkfd : (cmd : byte[:][:], infd : fd, outfd : fd -> result(pid, int)) + const exit : (status:int -> void) + const wait : (pid : pid -> waitstatus) + ;; + +#### [File Handling](files) + +Many programs do file i/o by default. This package provides a portable +interface to the common subset that most programs need and most OSes provide. + + pkg std = + type dir = struct + ;; + + /* seek options */ + const Seekset : whence + const Seekcur : whence + const Seekend : whence + + /* open options */ + const Ordonly : fdopt + const Owronly : fdopt + const Ordwr : fdopt + const Otrunc : fdopt + const Ocreat : fdopt + const Oappend : fdopt + const Odir : fdopt + + /* directory handling */ + const diropen : (p : byte[:] -> std.result(dir#, byte[:])) + const dirread : (d : dir# -> std.option(byte[:])) + const dirclose : (d : dir# -> void) + const dirname : (p : byte[:] -> byte[:]) + const mkdir : (path : byte[:], mode : int64 -> int64) + const mkpath : (p : byte[:] -> bool) + const chdir : (path : byte[:] -> bool) + + /* file handling */ + const open : (path : byte[:], opts : fdopt -> fd) + const openmode : (path : byte[:], opts : fdopt, mode : int64 -> fd) + const close : (fd : fd -> int64) + const creat : (path : byte[:], mode : int64 -> fd) + const read : (fd : fd, buf : byte[:] -> size) + const write : (fd : fd, buf : byte[:] -> size) + const seek : (fd : fd, delta : off, whence : whence -> off) + const pipe : (fds : fd[2]# -> int64) + const dup2 : (ofd : fd, nfd : fd -> fd) + const remove : (path : byte[:] -> bool) + const unlink : (path : byte[:] -> int) + + /* path manipulation */ + const basename : (p : byte[:] -> byte[:]) + const pathcat : (a : byte[:], b : byte[:] -> byte[:]) + const pathjoin : (p : byte[:][:] -> byte[:]) + const pathnorm : (p : byte[:] -> byte[:]) + const getcwd : (-> byte[:]) + + /* file properties */ + const fmtime : (f : byte[:] -> option(time)) + const fsize : (f : byte[:] -> option(off)) + const fexists : (f : byte[:] -> bool) + const fisdir : (f : byte[:] -> bool) + + /* convenience functions */ + const slurp : (path : byte[:] -> result(byte[:], byte[:])) + const fslurp : (path : fd -> result(byte[:], byte[:])) + const blat : (path : byte[:], buf : byte[:], perm : int64 -> bool) + const fblat : (f : fd, buf : byte[:] -> bool) + ;; + +#### [Networking](networking) + +The networking related functionality in libstd provides the ability to +quickly and easily open file descriptors to a server, as well as to +resolve servers and handle IP parsing. + +Currently, there is a large hole in functionality for announcing and +serving, where raw system specific network APIs neeed to be used +from the `sys` library. + + pkg std = + type rectype = union + `DnsA /* host address */ + `DnsNS /* authoritative name server */ + `DnsCNAME /* canonical name for an alias */ + `DnsSOA /* marks the start of a zone of authority */ + `DnsWKS /* well known service description */ + `DnsPTR /* domain name pointer */ + `DnsHINFO /* host information */ + `DnsMINFO /* mailbox or mail list information */ + `DnsMX /* mail exchange */ + `DnsTXT /* text strings */ + `DnsAAAA /* ipv6 host address */ + ;; + + type resolveerr = union + `Badhost + `Badsrv + `Badquery + `Badresp + ;; + + type hostinfo = struct + fam : sys.sockfam + stype : sys.socktype + ttl : uint32 + addr : ipaddr + ;; + + type ipaddr = union + `Ipv4 byte[4] + `Ipv6 byte[16] + ;; + + /* network connections */ + const dial : (dialstr : byte[:] -> result(fd, byte[:])) + const resolve : (host : byte[:] -> result(hostinfo[:], resolveerr)) + const resolvemx : (host : byte[:] -> result(hostinfo[:], resolveerr)) + const resolverec : (host : byte[:], t : rectype -> result(hostinfo[:], resolveerr)) + + /* ip parsing */ + const ipparse : (ip : byte[:] -> option(ipaddr)) + const ip4parse : (ip : byte[:] -> option(ipaddr)) + const ip6parse : (ip : byte[:] -> option(ipaddr)) + + generic hosttonet : (v : @a -> @a) + generic nettohost : (v : @a -> @a) + ;; + +#### [Command Line Parsing](cli) + +Simple command line parsing is offered, designed to meet the needs of most +programs quickly and easily. There isn't much to say here. + + pkg std = + type optdef = struct + argdesc : byte[:] /* the description for the usage */ + minargs : std.size /* the minimum number of positional args */ + maxargs : std.size /* the maximum number of positional args (0 = unlimited) */ + noargs : std.bool /* whether we accept args at all */ + opts : optdesc[:] /* the description of the options */ + ;; + type optdesc = struct + opt : char + arg : byte[:] + desc : byte[:] + optional : bool + ;; + type optparsed = struct + opts : (char, byte[:])[:] + args : byte[:][:] + ;; + + const optparse : (optargs : byte[:][:], def : optdef# -> optparsed) + const optusage : (prog : byte[:], def : optdef# -> void) + ;; + +#### [Formatted Output](fmt) + +libstd supports a number of simple, easy to use formatting functions, +which can provide a sane format for any type out of the box, but also +support custom formatters for specific types, so that they can be pretty +printed. Many of the builtin types, such as bigints, install custom +formatters by default. + + pkg std = + /* output to file descriptors */ + const put : (fmt : byte[:], args : ... -> size) + const fput : (fd : fd, fmt : byte[:], args : ... -> size) + const putv : (fmt : byte[:], ap : valist# -> size) + const fputv : (fd : fd, fmt : byte[:], ap : valist# -> size) + + /* formatting values */ + const fmt : (fmt : byte[:], args : ... -> byte[:]) + const fmtv : (fmt : byte[:], ap : valist# -> byte[:]) + const bfmt : (buf : byte[:], fmt : byte[:], args : ... -> byte[:]) + const bfmtv : (buf : byte[:], fmt : byte[:], ap : valist# -> byte[:]) + const sbfmt : (buf : strbuf#, fmt : byte[:], args : ... -> size) + const sbfmtv : (buf : strbuf#, fmt : byte[:], ap : valist# -> size) + + /* custom formatting */ + const fmtinstall : (ty : byte[:], \ + fn : (sb : strbuf#, \ + ap : valist#, \ + opts : (byte[:],byte[:])[:] \ + -> void), \ + optdesc : (byte[:], bool)[:] \ + -> void) + ;; + +#### [Iteration Utilities](iterutil) + +Support for some common iteration patterns is provided. There are many kinds +of iteration that are done, and some of the most common ones are directly +supported by libstd. + +There are a few syntactic(!) issues in the language preventing these from +taking arbitrary iterators as parameters, but when this is resolved, that +restriction will be lifted. + + pkg std = + type zipiter(@a, @b) + type reverseiter(@a) + type enumiter(@a) + + impl iterable zipiter(@a, @b) -> (@a, @b) + impl iterable enumiter(@a) -> (size, @a) + impl iterable reverseiter(@a) -> @a + + generic byzip : (a : @a[:], b : @b[:] -> zipiter(@a, @b)) + generic byenum : (a : @a[:] -> enumiter(@a)) + generic byreverse : (sl : @a[:] -> reverseiter(@a)) + ;; + + +#### [Variadic Arguments](varargs) + +Myrddin supports variadic arguments for functions, and allows you +to walk over them, similar to the varargs functions in C, but safer. + +In addition, the Myrddin compiler generates type information for the types +that are compiled into a program. This code provides a rather awkward API +for iterating over them, and inspecting their values. + + pkg std = + type typedesc = union + `Tynone + + /* atomic types */ + `Tyvoid + `Tybool + `Tychar + + `Tyint8 + `Tyint16 + `Tyint + `Tyint32 + `Tyint64 + + `Tybyte + `Tyuint8 + `Tyuint16 + `Tyuint + `Tyuint32 + `Tyuint64 + `Tyflt32 + `Tyflt64 + `Tyvalist + + /* compound types */ + `Typtr byte[:] + `Tyfunc typecursor + `Tyslice byte[:] + `Tyarray (size, byte[:]) + + /* aggregate types */ + `Tytuple typecursor + `Tystruct typecursor + `Tyunion typecursor + /* name info */ + `Tyname (byte[:], byte[:]) + ;; + type typecursor = struct + nelt : size + rem : byte[:] + isnamed : bool + isiter : bool + ;; + type typeinfo = struct + size : size + align : size + ;; + generic typeof : (v : @a -> byte[:]) + const typeenc : (p : ...# -> typecursor) + const typeenccursor : (e : byte[:] -> typecursor) + const typedesc : (e : byte[:] -> typedesc) + const typeinfo : (e : byte[:] -> typeinfo) + const tcnext : (t : typecursor# -> byte[:]) + const tcpeek : (t : typecursor# -> byte[:]) + const ncpeek : (t : typecursor# -> (byte[:], byte[:])) + const ncnext : (t : typecursor# -> (byte[:], byte[:])) + + const vastart : (args : ...# -> valist) + const vatype : (ap : valist# -> byte[:]) + const vabytes : (ap : valist# -> byte[:]) + const vaenter : (ap : valist# -> valist) + generic vanext : (ap : valist# -> @a) + ;; + +#### [Slice manipulation](slices) + +Slices are used everywhere within Myrddin code, so clearly we have +some functions to manipulate them. They're listed here. Boopity boopity +boo. + + pkg std = + generic sleq : (a : @a[:], b : @a[:] -> bool) + generic slcp : (a : @a[:], b : @a[:] -> void) + generic slput : (sl : @a[:], idx : size, elt : @a -> @a[:]) + generic slpush : (sl : @a[:]#, elt : @a -> @a[:]) + generic sldup : (sl : @a[:] -> @a[:]) + generic slfill : (sl : @a[:], v : @a -> @a[:]) + generic sljoin : (dst : @a[:]#, src : @a[:] -> @a[:]) + ;; + +#### [String Manipulation](strings) + +String manipulation also tends to show up in code sometimes. Here are some +functions that do that. These are all unicode aware, and will not corrupt +utf8 data. + + pkg std = + /* string buffers */ + type strbuf = struct + ;; + + const mksb : (-> strbuf#) + const mkbufsb : (buf : byte[:] -> strbuf#) + const sbfin : (sb : strbuf# -> byte[:]) + const sbfree : (sb : strbuf# -> void) + const sbpeek : (sb : strbuf# -> byte[:]) + const sbputc : (sb : strbuf#, v : char -> bool) + const sbputs : (sb : strbuf#, v : byte[:] -> bool) + const sbputb : (sb : strbuf#, v : byte -> bool) + const sbtrim : (sb : strbuf#, len : size -> void) + + /* string searching */ + const strfind : (haystack : byte[:], needle : byte[:] -> option(size)) + const strrfind : (haystack : byte[:], needle : byte[:] -> option(size)) + const strhas : (haystack : byte[:], needle : byte[:] -> bool) + const hasprefix : (s : byte[:], pre : byte[:] -> bool) + const hassuffix : (s : byte[:], suff : byte[:] -> bool) + + /* C strings */ + const cstrlen : (buf : byte[:] -> size) + const cstrconv : (buf : byte[:] -> byte[:]) + const cstrconvp : (p : byte# -> byte[:]) + + /* tokenizing and splitting */ + const strsplit : (s : byte[:], delim : byte[:] -> byte[:][:]) + const strtok : (s : byte[:] -> byte[:][:]) + + /* string joining and stripping */ + const strcat : (a : byte[:], b : byte[:] -> byte[:]) + const strjoin : (strings : byte[:][:], delim : byte[:] -> byte[:]) + const strstrip : (str : byte[:] -> byte[:]) + const strfstrip : (str : byte[:] -> byte[:]) + const strrstrip : (str : byte[:] -> byte[:]) + + /* parsing numbers out of strings */ + generic intparsebase : (s : byte[:], base : int -> option(@a::(integral,numeric))) + generic intparse : (s : byte[:] -> option(@a::(integral,numeric))) + generic charval : (c : char, base : int -> @a::(integral,numeric)) + ;; + +#### [Unicode](unicode) + +A bunch of predicates and conversions to handle unicode. This only +provides simple functionality. For canonicalization, collation, and +all of the other UAX algorithms, go look in.. oh, who am I kidding. +I haven't had a chance to write them yet. + + pkg std = + const Badchar : char + const Maxcharlen : size + const Maxcharval : char + + /* utf8 information */ + const charlen : (chr : char -> size) + const encode : (buf : byte[:], chr : char -> size) + const decode : (buf : byte[:] -> char) + const striter : (str : byte[:] -> (char, byte[:])) + + /* character class predicates */ + const isalpha : (c : char -> bool) + const isdigit : (c : char -> bool) + const isxdigit : (c : char -> bool) + const isnum : (c : char -> bool) + const isalnum : (c : char -> bool) + const isspace : (c : char -> bool) + const isblank : (c : char -> bool) + const islower : (c : char -> bool) + const isupper : (c : char -> bool) + const istitle : (c : char -> bool) + + /* character class conversions */ + const tolower : (c : char -> char) + const toupper : (c : char -> char) + const totitle : (c : char -> char) + ;; + +#### [Pervasive Data Structures](datastruct) + +There are some data structures that basically every program seems to use: +Sets, and hash tables. Libstd includes them for that reason. + + pkg std = + type bitset = struct + ;; + + type htab(@k, @v) = struct + ;; + + type htkviter(@k, @v) + impl iterable htkviter + + type bsiter = struct + impl iterable bsiter + + /* bit sets */ + const mkbs : (-> bitset#) + const bsdup : (bs : bitset# -> bitset#) + const bsfree : (bs : bitset# -> void) + const bsmax : (a : bitset# -> size) + const bscount : (a : bitset# -> size) + generic bsput : (bs : bitset#, v : @a::(integral,numeric) -> bool) + generic bsdel : (bs : bitset#, v : @a::(integral,numeric) -> bool) + generic bshas : (bs : bitset#, v : @a::(integral,numeric) -> bool) + const bsdiff : (a : bitset#, b : bitset# -> void) + const bsintersect : (a : bitset#, b : bitset# -> void) + const bsunion : (a : bitset#, b : bitset# -> void) + const bseq : (a : bitset#, b : bitset# -> bool) + const bsissubset : (a : bitset#, b : bitset# -> bool) + const bsclear : (bs : bitset# -> bitset#) + const bybsvalue : (bs : bitset# -> bsiter) + + /* hash tables */ + generic mkht : (h : (k : @k -> uint32), eq : (a : @k, b : @k -> bool) -> htab(@k, @v)#) + generic htfree : (ht : htab(@k, @v)# -> void) + generic htput : (ht : htab(@k, @v)#, k : @k, v : @v -> void) + generic htdel : (ht : htab(@k, @v)#, k : @k -> void) + generic htget : (ht : htab(@k, @v)#, k : @k -> option(@v)) + generic htgetv : (ht : htab(@k, @v)#, k : @k, fallback : @v-> @v) + generic hthas : (ht : htab(@k, @v)#, k : @k -> bool) + generic htkeys : (ht : htab(@k, @v)# -> @k[:]) + generic byhtkeyvals : (ht : htab(@k, @v)# -> htkviter(@k, @v)) + + /* prepackaged hashing and equality tests */ + const strhash : (s : byte[:] -> uint32) + const streq : (a : byte[:], b : byte[:] -> bool) + generic ptrhash : (p : @a# -> uint32) + generic ptreq : (a : @a#, b : @a# -> bool) + generic inthash : (v : @a::(integral,numeric) -> uint32) + generic inteq : (a : @a::(integral,numeric), b : @a::(integral,numeric) -> bool) + generic slhash : (sl : @a[:] -> uint32) + ;; + + +#### [Pervasive Algorithms](algorithms) + +Many programs also use sorting and searching, so this is also provided by +libstd. In addition, we package some useful comparison and hashing functions + + pkg std = + /* the result of a comparison */ + type order = union + `Before + `Equal + `After + ;; + + /* sorting and searching */ + generic sort : (sl:@a[:], cmp:(a:@a, b:@a -> order) -> @a[:]) + generic lsearch : (sl : @t[:], val : @t, cmp : (a : @t, b : @t -> order) -> option(@idx::(integral,numeric))) + generic bsearch : (sl : @t[:], val : @t, cmp : (a : @t, b : @t -> order) -> option(@idx::(integral,numeric))) + generic swap : (a : @a#, b : @a# -> void) + + /* prepackaged comparisons */ + generic numcmp : (a : @a, b : @a -> order) + const strcmp : (a : byte[:], b : byte[:] -> order) + const strncmp : (a : byte[:], b : byte[:], n : size -> order) + + /* extrema and absolute values */ + generic min : (a : @a::numeric, b : @a::numeric -> @a::numeric) + generic max : (a : @a::numeric, b : @a::numeric -> @a::numeric) + generic clamp : (a : @a::numeric, min : @a::numeric, max : @a::numeric -> @a::numeric) + generic abs : (a : @a::numeric -> @a::numeric) + ;; + +#### [Randomness](randomness) + +And of course, you can't go without being a little random at times. + + pkg std = + const mksrng : (seed : uint32 -> rng#) + const freerng : (rng : rng# -> void) + generic rand : (lo : @a::(numeric,integral), hi : @a::(numeric,integral) -> @a::(numeric,integral)) + generic rngrand : (rng : rng#, lo : @a::(numeric,integral), hi : @a::(numeric,integral) -> @a::(numeric,integral)) + generic rngrandnum : (rng : rng# -> @a::(numeric,integral)) + const rngrandbytes : (rng : rng#, buf : byte[:] -> size) + ;; + +#### [Bigint Operations](bigint) + +While bigint usage in most programs is relatively rare, libstd needs them +internally for handling floats, and several other widely used pieces of +functionality also need them. + +As they are a significant amount of code, I decided it made sense to +expose them in the public API. + + pkg std = + type bigint = struct + ;; + + generic mkbigint : (v : @a::(numeric,integral) -> bigint#) + const bigfree : (a : bigint# -> void) + const bigdup : (a : bigint# -> bigint#) + const bigassign : (d : bigint#, s : bigint# -> bigint#) + const bigmove : (d : bigint#, s : bigint# -> bigint#) + const bigparse : (s : byte[:] -> option(bigint#)) + const bigclear : (a : bigint# -> bigint#) + const bigbfmt : (b : byte[:], a : bigint#, base : int -> size) + const bigtoint : (a : bigint# -> @a::(numeric,integral)) + const bigiszero : (a : bigint# -> bool) + const bigeq : (a : bigint#, b : bigint# -> bool) + const bigcmp : (a : bigint#, b : bigint# -> order) + const bigadd : (a : bigint#, b : bigint# -> bigint#) + const bigsub : (a : bigint#, b : bigint# -> bigint#) + const bigmul : (a : bigint#, b : bigint# -> bigint#) + const bigdiv : (a : bigint#, b : bigint# -> bigint#) + const bigmod : (a : bigint#, b : bigint# -> bigint#) + const bigdivmod : (a : bigint#, b : bigint# -> (bigint#, bigint#)) + const bigshl : (a : bigint#, b : bigint# -> bigint#) + const bigshr : (a : bigint#, b : bigint# -> bigint#) + const bigmodpow : (b : bigint#, e : bigint#, m : bigint# -> bigint#) + const bigpow : (a : bigint#, b : bigint# -> bigint#) + generic bigeqi : (a : bigint#, b : @a::(numeric,integral) -> bool) + generic bigaddi : (a : bigint#, b : @a::(integral,numeric) -> bigint#) + generic bigsubi : (a : bigint#, b : @a::(integral,numeric) -> bigint#) + generic bigmuli : (a : bigint#, b : @a::(integral,numeric) -> bigint#) + generic bigdivi : (a : bigint#, b : @a::(integral,numeric) -> bigint#) + generic bigshli : (a : bigint#, b : @a::(integral,numeric) -> bigint#) + generic bigshri : (a : bigint#, b : @a::(integral,numeric) -> bigint#) + const bigpowi : (a : bigint#, b : uint64 -> bigint#) + ;; + + +#### [Closures](closures) + +There are functions for heapifying closures, too. + + pkg std = + generic fndup : (fn : @fn::function -> @fn::function) + generic fnfree : (fn : @fn::function -> void) + ;; + +#### [Misc](misc) + +Well, I said it was a grab bag. These don't really fit into any overarching +category. + + pkg std = + generic KiB : @a::(integral,numeric) + generic MiB : @a::(integral,numeric) + generic GiB : @a::(integral,numeric) + generic TiB : @a::(integral,numeric) + generic PiB : @a::(integral,numeric) + generic EiB : @a::(integral,numeric) + generic ZiB : @a::(integral,numeric) + generic YiB : @a::(integral,numeric) + + generic Sec : @a::(integral,numeric) + generic Msec : @a::(integral,numeric) + generic Usec : @a::(integral,numeric) + + /* time */ + const now : (-> time) + + /* packing integers */ + generic putle64 : (buf : byte[:], v : @a::(numeric,integral) -> size) + generic putbe64 : (buf : byte[:], v : @a::(numeric,integral) -> size) + generic putle32 : (buf : byte[:], v : @a::(numeric,integral) -> size) + generic putbe32 : (buf : byte[:], v : @a::(numeric,integral) -> size) + generic putle16 : (buf : byte[:], v : @a::(numeric,integral) -> size) + generic putbe16 : (buf : byte[:], v : @a::(numeric,integral) -> size) + generic putle8 : (buf : byte[:], v : @a::(numeric,integral) -> size) + generic putbe8 : (buf : byte[:], v : @a::(numeric,integral) -> size) + + /* unpacking integers */ + generic getle64 : (buf : byte[:] -> @a::(numeric,integral)) + generic getbe64 : (buf : byte[:] -> @a::(numeric,integral)) + generic getle32 : (buf : byte[:] -> @a::(numeric,integral)) + generic getbe32 : (buf : byte[:] -> @a::(numeric,integral)) + generic getle16 : (buf : byte[:] -> @a::(numeric,integral)) + generic getbe16 : (buf : byte[:] -> @a::(numeric,integral)) + generic getle8 : (buf : byte[:] -> @a::(numeric,integral)) + generic getbe8 : (buf : byte[:] -> @a::(numeric,integral)) + + /* exploding and stitching floats */ + const flt64bits : (flt : flt64 -> int64) + const flt32bits : (flt : flt32 -> int32) + const flt64frombits : (bits : uint64 -> flt64) + const flt32frombits : (bits : uint32 -> flt32) + const flt64explode : (flt : flt64 -> (bool, int64, int64)) + const flt32explode : (flt : flt32 -> (bool, int32, int32)) + const flt64stitch : (flt : flt64 -> (bool, int64, int64)) + const flt32stitch : (flt : flt32 -> (bool, int32, int32)) + + ;; |