Funky Manual

Funky is a deterministic programming language. If fed the same input data, a Funky program will return the same results on each run and (hopefully!) each platform.

This sounds trivial but isn’t.

But Funky shall make use of modern multi-core CPUs and even of compute-clusters to compute its results.

So Funky programs can execute functions in parallel. But there is no explicit language support for parallelism! Each and every Funky program is logically sequential. It’s up to the compiler and runtime system to run parts of the code in parallel.

This automatic parallelization must not undermine determinism.

Funky is - as the name suggests - a functional programming language.

All results of a called function are explicitely returned and handled by the caller. There are no changes behind the scenes - no global state is changed.

Calls to such functions must be annotated in the source code. Each function calling an I/O-function is itself an I/O-function and so calls to it must be annotated, too.

Funky is also an object oriented programming language.

There are no classes but each value is represented by an object.

To create a new object, one makes a copy of an existing object. After copying, the two objects are completely distinct. There is no such thing as delegation.

For each object any number of methods and attributes can be defined. Both, methods and attributes, implement so-called polymorphic functions.

When an object is copied all its methods and attributes are copied, too.

There is no syntactic difference in accessing lists, attributes, methods and (non-polymorphic) functions.

All objects are immutable. One can create new objects based on existing ones, but one cannot alter an existing object.

There is only a single kind of variable. It has lexical scope but dynamic lifetime.

At any time exactly one object is bound to every variable.

A function can change the bindings of variables, if these variable are in its scope. On return from the function all these bindings are undone and the previous bindings are restored.

Funky has built-in support for symbol versioning. Every exported symbol has an attached version number in a major.minor-scheme. If no version is explicitly specified, the version defaults to "1.0".

Several versions of a symbol can coexist. Older versions should not be removed. Any existing application program will thus be able to link against future versions of a library.

Versioning is done via namespaces. In the simplest (and most common) case one only specifies the desired version of each namespace to be used once in every source code module.

Once published, a specific namespace-version should never change. No changes, no additions - only bug fixes are allowed.

To add a symbol to an already published namespace the minor version number of the namespace is incremented. To change the semantics of an existing symbol, the major version number is incremented and the minor version number is reset to 0.

Each version of the namespace also includes all older symbols that were not redefined in a version less or equal to the desired one.

Source code files that are referred from other Funky source code files must adhere to strict rules:

For source code files that are used as scripts, none of the above rules applies. The can be given any convenient name.

All source code files must be UTF-8-encoded (ASCII is a subset of UTF-8) and must not start with a byte-order-marker.

Line-feed-characters are used to terminate lines. The last line needs to be terminated, too.

The tab-width is assumed to be 8 spaces.

Tab-characters may only appear at the start of a line; they are not allowed within a line.

Empty lines must not contain whitespace and whitespace at the end of a line is disallowed, too.

Syntactic units are separated by exactly one space character.

Other whitespace-characters (including carriage returns) are not allowed.

Here is the Funky source code for the "classical" hello-world-program:

Every statement in Funky is a function call. The caller calls the callee. The functor is the "name of the function" - a variable that stores a "function-object", but remember that every object in Funky is a function!

An argument is an object that is passed from the caller to the callee.

A parameter is a variable in the callee’s context that is used to store an argument passed by the caller.

A result is an object that is returned from the callee to the caller.

A destination is a variable in the caller’s context that is used to store a result returned from the callee.

The grammar rules for a simplified statement:

A destination that is prefixed with a "$"-sign defines a new variable.

A destination that is prefixed with a "!"-sign redefines an existing variable.

A statement consists of a functor followed by any number of destinations and then any number of arguments. Functor, destinations and arguments are separated by a single space from one another. (There are no commas, semicolons or parentheses used for separation).

If functor, destinations and arguments fit on one line they are written like this:

If they do not fit onto a single line (or do contain a function-literal), then functor, destinations and arguments are spread onto multiple lines; the destinations and arguments are indented (all by the same amount) relative to the functor:

Each identifier describes a single variable. An environment is a table that holds a value for each variable. At any time there is exactly one active environment.

When the execution of a Funky program starts, there exists a single environment which is at the same time the active environment. All variables that were explicitely top-level-initialized hold their respective values. All other variables are initialized to a specific value that triggers an error when used. (All variables must be initialized upon definition in Funky, but local variables are not initialized at the top-level.)

When a function is called, an exact copy of the caller’s environment is created and becomes the active environment. At any time only the active enviroment is accessed (read or modified). Non-active environments are never accessed!

Before the function’s statements are executed all the caller’s arguments are copied into the appropriate parameters of the callee (in the now active environment). (For more details see the section Functions).

Then the function’s statements are executed one after the other.

The last statement is treated specially. It is a tail call. In a tail call no destinations are specified. Instead, the results are directly returned to the function’s caller.

On return from the function (every function will eventually return in Funky) its copy of the environment is destroyed and the caller’s environment becomes the active environment again.

Every variable is defined exactly once. A variable is defined by using it as a destination and prefixing its name with a dollar sign.

The scope of a variable spans all following statements of the function in which it is defined and all function literals embedded in this function - even if they are placed textually before the definition of the variable.

If the variable is assigned a constant expression and is never redefined then its scope starts at the beginning of the function where it is defined.

If a variable is defined outside of any function (at the top level) its scope is the whole source code module.

If it is defined within a namespace it can be accessed from absolutely everywhere (even from other modules).

Variables defined at the top-level must be initalized with literals or constant expressions.

A constant expression is a literal or a function call whose functor evaluates to one of several built-in functions allowed within constant expressions and whose arguments are themself constant expressions.

On the top-level every unknown symbol is treated as a constant by the compiler.

Functions allowed in constant expressions are:

Some examples:

There is an exception for the top-level of the main module: it can contain other function calls, too. It’s some kind of an implicit "main"-function.

A variable can be redefined within its scope any number of times.

To redefine a variable is is used as a destination and prefixed with an exclamation mark.

At the global scope the definition of a variable can be split into several separate definitions. In the case of a namespaced identifier these definitions can be distributed over several source code modules.

An example:

is equal to

See the section about attribute-value-pairs for a detailed description of the syntax used here.

The runtime linker is a very important part of Funky. It does its job whenever a Funky-executable is executed and before the first statement of the program is executed.

Its job is to collect all distributed definitions and to initialize all variables of the environment.

All objects stem from three so-called root objects:

All "normal" objects are derived from std_types::object.

std_types::undefined is a one-of-a-kind object.

All error-objects are derived from std_types::error.

An object consists of

Such internal fields are used to store the numeric values of integers, the characters that build a string, and things like that.

All "normal objects" are of one of the following kinds or directly or indirectly derived from std_types::object.

Numbers, booleans, unique items and characters are scalar values. Tuples, lists and arrays are compound values; strings are a bit of both. Functions contain no data but are called to execute their embedded statement sequences.

These value types will be described in the following sections. Functions play such an important part that the whole next chapter is dedicated to this topic.

A function can have any number of parameters. A parameter is a variable. (The scope of a parameter is the function and all embedded functions.)

A function can have any number of mandatory and optional parameters as well as a single rest parameter.

The caller of the function must supply an argument for every mandatory parameter of the called function.

The caller can supply an argument for each optional parameter of the called function.

If there is no rest parameter the caller must not supply any excess arguments to the called function.

A function call consists of a function name (a variable) and the appropriate number of (input) arguments for the called function. It also expects one or more results (I/O-functions can expects no results).

The canonical form of a function calls looks like this:

If the variable to store the result is defined here the exclamation mark ("!") is replaced by a dollar sign ("$").

The destinations and arguments can be spread over multiple lines. They are separated with a single space from the function_name and beyond each other. The follow-up lines are all indented (by the same amount of whitespace) relative to the first line of the function call.

So the above call could be written like this:

Results and arguments can me mixed in any way as long as the relative order of destinations and the relative order of arguments is not altered.

So the following calls are all identical:

Polymorphic functions are the way object oriented programming works in Funky.

When declaring a polymorphic function two things happen

For each object this slot can hold an attribute or a method.

An identifier consists of an (optional) namespace and a name.

The rules for namespaces and names are the same:

They consist of one or more "words". A word consists of one or more ASCII letters or digits. Words are separated by a single underscore-symbol ("_"). The first word must start with a letter.

Letters can be upper or lower case. Case is relevant, so identifiers differing only in letter case are different identifiers.

The require-instruction is used to include a specific source code module into an application or library.

The syntax is streightforward:

The module_name ist the filename of the source code module without the ".fky"-extension.

If the filename starts with a dot-character (".") then the filename is relative to the requiring module’s directory.

If the filename starts with a letter then the filename specifies a module in a library. The absolute location of library files is system dependent. The environment variable FUNKY_LIBRARY_PATH can be used to overwrite this system dependent location and to use one’s own version of library modules.

The rules for naming source code files are the same as the rules for naming identifiers.

Some examples:

If an application program (not a library) does not require a single module then the module “basic/stdlib” is automatically included.

In Funky it’s common that only the main module of an application program requires other modules. The Funky standard libraries do not require other libraries by themselves! There are special library modules that require a set of other modules, e,g. basic/stdlib.

So the application writer can choose to use other implementations for functions than the default implementations supplied by the standard library.

In Funky namespaces have two responsibilities:

Every namespace (and its major versions) needs to be declared exactly once in an application.

It’s an error to forget to declare a namespace or to declare a namespace twice.

An unspecified version number always defaults to "1.0".

The version unstable is special and denotes the most current version that is still under development and functions defined with this version number can change their behaviour at any time without further notice.

An unstable namespace should only be used for testing new functionality.

There must be a namespace declaration for each major-version number of a namespace. The respective minor-version number declares the highest minor version that is available for the corresponding major version number.

E.g.:

makes the following namespaces available:

When defining a namespaced variable it is necessary to explicitly specify the version number of the namespace. using- and resolve-directives are ignored when a variable is defined, but alias-directives are obeyed.

It is optional to specify a namespace when reading a namespaced variable. A using-directive can be used to resolve the namespace automatically:

For a single namespace each source code module can only contain one using-directive.

Whenever a variable is redefined or read that is not locally defined and without the explicit use of a namespace the using-directive is used by the runtime linker to find the corresponding variable.

It the runtime linker cannot resolve it unambigously it refuses to start the program and terminates with an appropriate error message.

It is possible to specify a namespace when reading or redefining a namespaced variable but it is not possible to explicitly specify a version number of a namespace.

The version number for a specific namespace can be selected for the whole module using a resolve-directive:

To use a namespace under a different name an alias-directive can be used:

alias-directives are used for variable definitions as well as for redefinitions and reads.

is equivalent to

The compiler associates remarks with syntactic expressions.

Remarks are either

An indentifier does not become a function call, when it contains only remark pseudo arguments.

A return statement containing only remark pseudo arguments is invalid.

There are two ways to associate a remark with a function:

or if the function has no parameter list:

To associate a remark with an expression:

or

An example to associate a remark with a parameter:

or