ref: d0ffb958c7247028223c7e53253249d52a47a324
dir: /doc/api/libstd/index.txt/
{
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))
;;