Namespaces

Namespaces act as containers for type declarations and implementations. Each Freya source file consists in a sequence of namespace declarations.

Namespaces as logical containers for types

There's no entity in the Common Language Runtime (CLR) that directly matchs with a namespace definition. The main effect of namespaces is providing a full qualified path for the types declared inside their scopes. As a consequence you can declare types as if they belong to an already existing namespace, and a namespace declaration can be repeated both inside the same project and even the same file:

namespace System;

    // Though System is used by predefined types,
    // there's no problem defining new types in that namespace.

namespace Freya.Demos

    // ...

namespace Freya.Demos

    // Repeating a namespace declaration is not a problem.

end.

Namespace sections

A namespace is composed by an optional using clause with local scope, and several namespace sections. Allowed section types are:

This example shows a typical namespace declaration, including the global using clause from the file, and a local using clause:

using System, System.Text;

namespace Freya.Examples

using System.Collections.Generic;

public

    MyEnum = ( { ... } );

    MyClass = class
        // ...
    end;

    MyRecord = record
        // ...
    end;

implementation for MyClass is

    // ...

implementation for MyRecord is

    // ...

end.

There are several points to note:

• Though there's only one namespace in this example, the global using clause would affect any other namespace included in this file.
• On the contrary, the second using clause would have no effect on any other namespace included in the file.
• As a matter of fact, we could have merged both using clauses in this example.
• There are three public types declared in the example: an enumeration, a class type and a record type.
• The enumerative type needs no separate implementation section.
• Classes and records declaring methods and properties require an implementation section. When a class or record declares no executable concrete members, the implementation section can be omitted. However, the compiler would accept an empty implementation section for that record or class.

Namespaces are optional

Though it's not a recommended practice, you can declare types in the global scope, without any enclosing namespace:

// Not recommended.
using System;

MyProgram = class
    // ... etc ...
end;

end.

This can be useful for quick test applications, but the cost is the pollution of the global scope.

See also

The Freya Programming Language
Program and file structure
Lexical structure
Projects and source files
Implementation sections
using clauses
The entry point
Type declarations