Seed7 is an extensible general-purpose programming language designed by Thomas Mertes. It is syntactically similar to Pascal and Ada. Along with many other features, it provides an extension mechanism. Seed7 supports introducing new syntax elements and their semantics into the language, and allows new language constructs to be defined and written in Seed7. For example, programmers can introduce syntax and semantics of new statements and user defined operator symbols. The implementation of Seed7 differs significantly from that of languages with hard-coded syntax and semantics.
Seed7 supports the programming paradigms: imperative, object-oriented (OO), and generic. It also supports features such as call by name, multiple dispatch, function overloading, operator overloading, exception handling and arbitrary-precision arithmetic.
Major features include:
User defined statements and operators
Abstract data types
Templates without special syntax
Object-oriented with interfaces and multiple dispatch
Static typing
May be interpreted or compiled
Source code portability
Runs under BSD, Linux, Mac OS X, Unix, Windows
Several programming language concepts are generalized:
Type declarations (which assign a name to a type) and function definitions take the form of constant definitions.
Compile-time expressions can execute user-defined functions.
Overloading and object-orientation (with multiple dispatch) are seen as common concepts. They just happen at different times: compile time and run time, respectively.
Type names and type descriptions can be used as parameter and function result.
Functions, which are executed at compile time, can be used to define objects.
Templates are written as compile time functions with type parameters.
Arrays, hash maps and structs are not a hard-coded feature. Instead they are defined as abstract data type in libraries.
Parser and interpreter are part of the runtime library.
UTF-32 Unicode support. This avoids problems of variable-length encodings like UTF-8 and UTF-16.
This page is automatically generated and may contain information that is not correct, complete, up-to-date, or relevant to your search query. The same applies to every other page on this website. Please make sure to verify the information with EPFL's official sources.
Goto (goto, GOTO, GO TO, GoTo, or other case combinations, depending on the programming language) is a statement found in many computer programming languages. It performs a one-way transfer of control to another line of code; in contrast a function call normally returns control. The jumped-to locations are usually identified using labels, though some languages use line numbers. At the machine code level, a goto is a form of branch or jump statement, in some cases combined with a stack adjustment.
In computer programming, operators are constructs defined within programming languages which behave generally like functions, but which differ syntactically or semantically. Common simple examples include arithmetic (e.g. addition with +), comparison (e.g. "greater than" with >), and logical operations (e.g. AND, also written && in some languages). More involved examples include assignment (usually = or :=), field access in a record or object (usually .), and the scope resolution operator (often :: or .).
In some programming languages, function overloading or method overloading is the ability to create multiple functions of the same name with different implementations. Calls to an overloaded function will run a specific implementation of that function appropriate to the context of the call, allowing one function call to perform different tasks depending on context. For example, and are overloaded functions. To call the latter, an object must be passed as a parameter, whereas the former does not require a parameter, and is called with an empty parameter field.
Programming languages are increasingly compiled to multiple runtimes, each featuring their own rich structures such as their object model.
Furthermore, they need to interact with other languages targeting said runtimes.
A language targeting only one runtim ...
Open multithreaded transactions constitute building blocks that allow a developer to design and structure the execution of complex distributed systems featuring cooperative and competitive concurrency in a reliable way. In this paper we describe an optimiz ...