Introduction

No implied string comparisons! No:
- Non-Unicode filenames
- Unicode normalization
- Case sensitivity
- Windows special-case path parsing
- Filename length limits
- ...

Putting it all together

Typed Main programs are just programs.

With signatures, they're also just functions.

We can use this to compose multiple programs together.

Compatibility with existing code

We have three options.

Option A: Out of the box

For porting an existing application with no changes, things work like they do in WASI today:

Everything is strings
User needs to use --dir preopens

This uses Typed Main, but with a fixed signature.

List-of-strings for the args
List-of-(handle,string) for the preopens

Option B: Provide a witx description

In this option, the Developer writes a witx file to describe their application.

This option involves no changes to the program itself.

The main program will still take strings and use preopens, but it can be wrapped in a wasm interface generated form witx.

Example:

;; Typed main example: a simple grep

(module $grep
  ;;; Main entrypoint for grep.
  (@interface func (export "main")
    ;;; The string to search for.
    (param $pattern string)

    ;;; The output to write to.
    (param $output $output_byte_stream)

    ;;; The inputs to search for it in.
    (param $inputs (list $input_byte_stream))

    ;;; The result: Just indicate if any I/O failed.
    (result $error (expected unit (error $input_byte_stream_error)))
  )
)

Option C: Typed Main in the source language

What if programming languages let you just write a main function which took arbitrary types?

Nameless

Nameless is a Rust crate prototyping Option C, for native code:

https://github.com/sunfishcode/nameless

https://crates.io/crates/nameless

Nameless today works for native code by doing everything itself. But once we hook it up to Typed Main in WASI, it'll be a very thin API.

/// # Arguments
///
/// * `pattern` - The regex to search for
/// * `inputs` - Input sources
#[kommand::main]
fn main(
    pattern: Regex,
    output: LazyOutput<OutputTextStream>,
    inputs: Vec<InputTextStream>,
) -> anyhow::Result<()> {
    let mut output = output.materialize(Type::text())?;

    let print_inputs = inputs.len() > 1;

    for input in inputs {
        let pseudonym = input.pseudonym();
        for line in BufReader::new(input).lines() {
            let line = line?;
            if pattern.is_match(&line) {
                if print_inputs {
                    output.write_pseudonym(&pseudonym)?;
                    write!(output, ":")?;
                }
                writeln!(output, "{}", line)?;
            }
        }
    }

    Ok(())
}

Wrap up

Current Status

The witx syntax shown here is supported by the witx parser in the WASI tree.

New-style commands, a toolchain feature that can be one of the building blocks:

Interface types are in phase 1, and there is prototyping underway at a few different levels.

Typed Main uses in WASI

wasi-clocks

Clocks should be capabilities, rather than ambient authorities.

wasi-random

Entropy sources should be capabilities, rather than ambient authorities.

New WASI proposals

Serial ports
Audio devices
Database connections
etc.

A big question for all capability systems is how a program obtains the first capability. Typed Main is a way to do this.

Typed Main for WASI