Eliom: A Core ML Language for Tierless Web Programming

Abstract

Eliom is a dialect of OCaml for Web programming in which server and client pieces of code can be mixed in the same file using syntactic annotations. This allows to build a whole application as a single distributed program, in which it is possible to define in a composable way reusable widgets with both server and client behaviors. Our language also enables simple and type-safe communication. Eliom matches the specificities of the Web by allowing the programmer to interleave client and server code while maintaining efficient one-way server-to-client communication. The Eliom language is both sufficiently small to be implemented on top of an existing language and sufficiently powerful to allow expressing many idioms of Web programming.

In this paper, we present a formalization of the core language of Eliom. We provide a type system, the execution model and a compilation scheme.

This work was partially performed at IRILL, center for Free Software Research and Innovation in Paris, France, http://www.irill.org.

A Translation from Eliom \(_{\varepsilon }\) to \({\textsc {ML}}_{\varepsilon }\)

We define two rewriting functions, $\rho _{s}$ and $\rho _{c}$, which take as input an ${\textsc {Eliom}}_{\varepsilon }$ program and output respectively an ${\textsc {ML}}_{s}$ and an ${\textsc {ML}}_{c}$ program.

We define some preliminaries notations. Brackets [ and ] are used as meta-syntactic markers for repeated expressions: $[\dots ]_i$ is repeated for all i. The bounds are usually omitted. Lists are denoted with an overline: $\overline{x_i}$ is the list $[x_0,\dots ,x_{n-1}]$. We allow the use of lists inside substitutions to denote simultaneous independent substitutions. For instance $e[\overline{v_i}/\overline{x_i}]$ is equivalent to $e[v_0/x_0]\dots [v_{n-1}/x_{n-1}]$. We will only consider substitutions where the order is irrelevant.

We also consider two new operations:

• $injections(e_c)$ returns the list of injections in $e_c$.

• $fragments(e_s)$ returns the list of fragments in $e_s$.

The order corresponds to the order of execution for our common subset of ML.

As in Sect. 4.3, we assume that fragments are first rewritten in the following manner:

$$ f{\mathtt {\%}}e_s \longrightarrow \mathtt {fragment}{\mathtt {\%}}({\texttt {decode}}\ f)\ \mathtt {serial}{\mathtt {\%}}({\texttt {encode}}\ f\ e_s) $$

We also assume that expressions inside injections are hoisted out of the local client scope. For example $\{\{~f{\mathtt {\%}}(3+x)~\}\}$ is transformed to $\lambda y . \{\{~f{\mathtt {\%}}y~\}\} \ (3+x)$. More formally, we apply the following transformations:

$$\begin{aligned} \{\{~C[f{\mathtt {\%}}e_s]~\}\}&\longrightarrow (\lambda x . C[f{\mathtt {\%}}x] )\ e_s\\ {\mathtt {let}}_{c}\ y = C[f{\mathtt {\%}}e_s]\ {\mathtt {in}}\ p&\longrightarrow {\mathtt {let}}_{s}\ x = e_s\ {\mathtt {in}}\ {\mathtt {let}}_{c}\ y = C[f{\mathtt {\%}}x]\ {\mathtt {in}}\ p\\&\qquad \ \text {Where}\, x \, \text {is fresh.} \end{aligned}$$

This transformation preserves the semantics, thanks to the validity constraint on programs presented in Sect. 3.1.

We can now define $\rho _{s}$ and $\rho _{c}$ by induction over ${\textsc {Eliom}}_{\varepsilon }$programs. We refer to Sect. 4.3 for a textual explanation.

Since we already translated custom converters, all the converters considered are either $\mathtt {fragment}$ or $\mathtt {serial}$. Here is the definition for client sections:

Here is the definition for server sections. Note the presence of lists of lists, to handle injections inside each fragment.

Finally, the returned expression of an ${\textsc {Eliom}}_{\varepsilon }$program. The translation is similar to client sections: