NXT programming Language.

/**
 * Multi-line NextDocs.
 */

/**
 * Multi-line comments.
 */

// Single line comments

/**
 * Next Programming Language, NXT or NPL for short.
 * Null Pointer Language for jest.
 *
 * Every example will include the Java equivalent.
 * JE:
 */

// Packages are declared using a directory structure of some 'domain'.
// Packages are also required, every file must be in a domain.
// No default domains are allowed.
// JE: package next.lang.test;
domain next/lang/test

// Imports are the same as the package declarations in style.
// JE: import next.lang.test.SomeClass;
use next/lang/test/SomeClass

// Keyword 'also' is used since it's easier/faster to type than implements
// JE: public abstract class Person implements Biped {
public abstract class Person also Biped, Talker, Singer {
    // string is just a primitive keyword of object type String
    string name
    // Much like Go and other languages semicolons are completely optional on new lines.
    // Comma separators are also optional.
    int age height weight
    Gender gender
    // var is also just a primitive Object
    // arrays are lazily initialized as: array = new Object[0];
    var[] attributes

    // Types are inferred for any untyped method and constructor parameters.
    // Generates: public Person(string name, int height, int weight) on compile.
    // If types cannot be inferred then a compiler error is thrown must be explicitly typed.
    // JE: public Person(String name, int height, int weight) {
    public Person(name height weight) {
        this.name = name
        this.height = height
        this.weight = weight
        age = 32
        // Natural ordering is given to unspecified index insert of an array.
        attributes[] = name // Extend array by 1, Insert at index array.length - 1.
        attributes[] = age // Extend array by 1, Insert at index array.length - 1.
    }

    // No return type was given so this is void.
    // No () is needed for empty arguments, this removes the need for unneeded typing.
    // JE: public void speak() {
    public speak {
        System.io.println(greetings())
    }

    // This is a method since it has a block and not a value
    // JE: String greetings() {
    string greetings {
        // string concatenation will use the addition operator +
        return "Hello, my name is " + name
    }

    // This is a field since it has declared a value
    string greetings = "Hello, my name is " + name

    // Keyword instance is used in place of protected since it's easier to type.
    instance var getAttribute(index) {
        return attributes[index]
    }

    public doThing {
        // Since more type information is known at runtime (this will be a string) it
        // will be overloaded to thing(string)
        // Overload to most specific type first
        thing(getAttribute(0))
        // Most specific type for an integer will be thing(var) at runtime.
        thing(getAttribute(1))
    }

    private thing(var variable) {
        System.io.println(variable + ": is a " + variable.getClass())
    }

    private thing(string str) {
        System.io.println(str + ": is a string")
    }
}

// Keyword 'is' is used in place of extends since it's easier/faster to type.
Man is Person {
    // The default block is for lazy initialization of fields in the superclass chain.
    // These are run after memory allocation, before construction.
    // JE: None. But much like static block for instance variables.
    default {
        gender = Gender.Male
    }

    // Typical override, optional @Override annotation.
    // JE: Same
    @Override
    string greetings() {
        return "Morning! I'm " + name
    }
}

// JE: Same
enum Gender {
    Male Female None
}

// JE: Same
interface Biped {
    // JE: void walk();
    walk
}