# 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
```