diff options
Diffstat (limited to 'doc/api/libstd/index.txt')
| -rw-r--r-- | doc/api/libstd/index.txt | 711 |
1 files changed, 0 insertions, 711 deletions
diff --git a/doc/api/libstd/index.txt b/doc/api/libstd/index.txt deleted file mode 100644 index f154f09..0000000 --- a/doc/api/libstd/index.txt +++ /dev/null @@ -1,711 +0,0 @@ -{ - 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)) - - ;; |