SL ( Simple Language ) is a small, statically-typed, purely functional programming language. Its keyword-heavy style to structure definitions and expressions is inspired by languages like Opal, its syntax for expressions and data type definitions is close to Haskell's one.
This repositroy provides a front-end implementation for SL which can be used as a starting point for research and teaching purposes in the field of programming languages and compiler construction.
An SL program consists of a sequence of data type definitions, function signatures, and function definitions that may appear in any order.
A data type definition introduces a type name and one or more data constructors. Data types may be recursive and parametric. We can define the type of polymorphic lists with the following piece of code:
DATA List a = Cons a (List a) | Nil
In addition to the types defined by a program's data type definitions, SL has predefined types for integers (Int), characters (Char), and strings (String) respectively. Common functions on these types are defined as built-ins.
Top-level function definitions are pattern based and consist of one or more clauses. The clauses
of a function are tried in top-down order until the first matching pattern is found (first-fit
pattern matching). As an example, we define the well-known map function on lists:
DEF map f Nil = Nil
DEF map f (Cons x xs) = Cons (f x) (map f xs)
In addition to regular function definitions the programmer can define custom binary operators. An operator definition is a regular function definition where the operator name is stated infix.
Note that we do not have to write down types for functions, the SL front-end is able to infer the
most general type for each function — if it is type correct at all. Nevertheless, the programmer
can still provide a type signature for each top-level function definition, i.e., to specialize a
function according to her own choice. Given the map function defined earlier, the programer can
explicitly give a typing for this function by providing a corresponding signature for the function
definitions:
FUN map : (a -> b) -> List a -> List b
On the expression level SL provides lambda-abstractions, application of functions, conditionals, and local definitions.
Function application of a function f to an argument a is written as juxtaposition of f and a
without parentheses: f a. A lambda-abstraction introduces an anonymous function. Like in top-level
definitions, pattern matching is used for the arguments.
SL has two kinds of conditionals: if- and case-expressions. The condition in an if-expression must be
of type Bool (defined in the SL prelude). Case-expressions perform pattern-matching for a single
expression, i.e., we can write a length function for lists in a single clause using a case-expression:
DEF length l = CASE l
OF Nil THEN 0
OF Cons x xs THEN 1 + (length xs)
Similar to pattern-based top-level definitions, pattern matching uses a top-down first-fit strategy.
An expression may contain local definitions using a let-expression, e.,g.
LET
even = \ n. IF n==0 THEN True ELSE odd (n-1)
odd = \ n. IF n==1 THEN True ELSE even (n-1)
IN even 5
The names introduced in a let-expression may be used in the right-hand sides, even mutually recursive. There is, however, an important restriction due to SL's eager evaluation strategy: In a set of mutually recursive definitions, all right-hand sides must be lambda-expressions.