Neuron Language Reference¶
Objects and Functions¶
Objects and functions can be integrated. Neuronic Objects can hold both properties and methods accessable to itself and to other objects, providing it with a dynamic foundation for script execution. Objects and functions are defined in the following syntax:
myObject {
property: value;
method(parameters);
}
Objects can hold both properties and methods, accessible to itself and to other objects:
myObject {
width: 1px;
height: 1px;
position: 10px 10px;
log(this.position);
}
log(myObject.position);
Objects containing HTML- and CSS-specific properties should be invoked as such:
invoke(myObject);
Functions can be called as methods:
myObject(parameters)
Functions with return values can be called as inline functions:
[myObject => parameters]
Functions can also take parameters, prefixed with #
and followed by their parameter number:
absoluteValue {
return([math.abs => #0]); // #0 defines the first parameter passed
}
log([absoluteValue => 0]);
// logs '0'
Functions can be executed with the following syntax as well:
add {
log(#0 + #1 is [#0 + #1]);
}
add(0, 1);
// logs '0 + 1 is 1'
Bracket Notation¶
Groupings, literals, and inline functions are all preceded by and followed by brackets. Bracket notation is defined by the following syntax:
[function => parameters]
[function parameters]
[literal]
[grouping]
Bracket notation can be embedded in parameters or values:
log([function => parameters]px, [grouping]px)
Groupings¶
Parameters are seperated by commas or spaces. Bracket notation can escape parameter seperators, and pass a single parameter.
log(Hello, World!) // The parameter seperator is not escaped
// logs 'Hello' and 'World!' in 'Hello World!'
log([Hello, World!]) // Bracket notation
// logs 'Hello, World!'
Literals¶
Literals evaluate its contents.
log(0 + 1) // Evaluated as a string
// logs '0 + 1'
log([0 + 1]) // Evaluated as a literal
// logs '1'
Inline Functions¶
Inline functions can pass parameters to a function with a return value, seperated by spaces.
[function => parameters]
log([math.sqrt => 1]px);
Variables and Assignments¶
Variables can be defined with the following syntax:
#myVar = value
Variables can then be referenced or reassigned:
log(#myVar);
#myVar = value;
Object properties can be referenced and reassigned as well:
log(myObject.position);
myObject.position = value;
Conditionals¶
Conditionals can be defined with the following syntax:
if (condition) {
// contents
}
The conditional will execute if the condition returns true
. Conditionals are capable of being embedded in executable objects.
Iterators¶
Iterators can be defined with the following syntax:
for (var in/=> value) {
// contents
}
The iterator will iterate through the value, executing its contents. The variable can then be used with the prefixed #
notation.
for (var => value) {
log(#var);
}
Iterators are capable of being embedded in executable objects.
Operators¶
Arithmetic Operators¶
+
Addition operator
-
Subtraction operator
/
Division operator
*
Multiplication operator
%
Remainder operator
**
Exponentiation operator
Relational Operators¶
<
Less than operator
>
Greater than operator
<=
Less than or equal to operator
>=
Greater than or equal to operator
==
Equality operator
!=
Inequality operator
===
Identity operator
!==
Nonidentity operator
Assignment Operators¶
=
Assignment operator
Inheritance¶
Expressions preceded by a tilde ~
are recognized as inheritance. Inheritance can be defined with the following syntax:
~value