## MLton 20241230+git20251029+dfsg-5

# Features

MLton has the following features.

## Robustness

- Supports the full SML 97 language as given in The Definition of Standard ML (Revised).

  If there is a program that is valid according to the Definition that is rejected by MLton, or a program that is invalid according to the Definition that is accepted by MLton, it is a bug. For a list of known bugs, see UnresolvedBugs.

- A complete implementation of the Basis Library.

  MLton’s implementation matches latest Basis Library specification, and includes a complete implementation of all the required modules, as well as many of the optional modules.

- Generates standalone executables.

  No additional code or libraries are necessary in order to run an executable, except for the standard shared libraries. MLton can also generate statically linked executables.

- Compiles large programs.

  MLton is sufficiently efficient and robust that it can compile large programs, including itself (over 190K lines). The distributed version of MLton was compiled by MLton.

- Support for large amounts of memory (up to 4G on 32-bit systems; more on 64-bit systems).

- Support for large array lengths (up to 231-1 on 32-bit systems; up to 263-1 on 64-bit systems).

- Support for large files, using 64-bit file positions.

## Performance

- Executables have excellent runtime performance.

- Generates small executables.

  MLton takes advantage of whole-program compilation to perform very aggressive dead-code elimination, which often leads to smaller executables than with other SML compilers.

- Untagged and unboxed native integers, reals, and words.

  In MLton, integers and words are 8 bits, 16 bits, 32 bits, and 64 bits and arithmetic does not have any overhead due to tagging or boxing. Also, reals (32-bit and 64-bit) are stored unboxed, avoiding any overhead due to boxing.

- Unboxed native arrays.

  In MLton, an array (or vector) of integers, reals, or words uses the natural C-like representation. This is fast and supports easy exchange of data with C. Monomorphic arrays (and vectors) use the same C-like representations as their polymorphic counterparts.

- Multiple garbage collection strategies.

- Fast arbitrary precision arithmetic (`IntInf`) based on GMP.

  For `IntInf` intensive programs, MLton can be an order of magnitude or more faster than Poly/ML or SML/NJ.

## Tools

- Source-level Profiling of both time and allocation.

- MLLex lexer generator

- MLYacc parser generator

- MLNLFFIGen foreign-function-interface generator

## Extensions

- The ML Basis system for programming in the very large, separate delivery of library sources, and more.

- A number of useful language extensions.

- A simple and fast C ForeignFunctionInterface that supports calling from SML to C and from C to SML.

- A number of extension libraries that provide useful functionality that cannot be implemented with the Basis Library. See below for an overview and MLtonStructure for details.

  - continuations

    MLton supports continuations via `callcc` and `throw`.

  - finalization

    MLton supports finalizable values of arbitrary type.

  - interval timers

    MLton supports the functionality of the C `setitimer` function.

  - random numbers

    MLton has functions similar to the C `rand` and `srand` functions, as well as support for access to `/dev/random` and `/dev/urandom`.

  - resource limits

    MLton has functions similar to the C `getrlimit` and `setrlimit` functions.

  - resource usage

    MLton supports a subset of the functionality of the C `getrusage` function.

  - signal handlers

    MLton supports signal handlers written in SML. Signal handlers run in a separate MLton thread, and have access to the thread that was interrupted by the signal. Signal handlers can be used in conjunction with threads to implement preemptive multitasking.

  - size primitive

    MLton includes a primitive that returns the size (in bytes) of any object. This can be useful in understanding the space behavior of a program.

  - system logging

    MLton has a complete interface to the C `syslog` function.

  - threads

    MLton has support for its own threads, upon which either preemptive or non-preemptive multitasking can be implemented. MLton also has support for Concurrent ML (CML).

  - weak pointers

    MLton supports weak pointers, which allow the garbage collector to reclaim objects that it would otherwise be forced to keep. Weak pointers are also used to provide finalization.

  - world save and restore

    MLton has a facility for saving the entire state of a computation to a file and restarting it later. This facility can be used for staging and for checkpointing computations. It can even be used from within signal handlers, allowing interrupt driven checkpointing.

## Portability

- Runs on a wide variety of platforms.

  - ARM:

    - Linux (Debian)

    - FreeBSD

  - Alpha:

    - Linux (Debian)

  - AMD64:

    - Darwin (Mac OS X)

    - FreeBSD

    - Linux (Debian, Fedora, Ubuntu, …​)

    - OpenBSD

    - Solaris (10 and above)

  - HPPA:

    - HPUX (11.11 and above)

    - Linux (Debian)

  - IA64:

    - HPUX (11.11 and above)

    - Linux (Debian)

  - PowerPC:

    - AIX (5.2 and above)

    - Darwin (Mac OS X)

    - Linux (Debian, Fedora, …​)

  - PowerPC64:

    - AIX (5.2 and above)

  - S390

    - Linux (Debian)

  - Sparc

    - Linux (Debian)

    - Solaris (8 and above)

  - X86:

    - Cygwin/Windows

    - Darwin (Mac OS X)

    - FreeBSD

    - Linux (Debian, Fedora, Ubuntu, …​)

    - MinGW/Windows

    - NetBSD

    - OpenBSD

    - Solaris (10 and above)