# Code style
This document describes a code style as applied by the *mofmt*.
## Maximum line length
There is no line length limit. There are plenty of limits already.
## Horizontal spacing
### Spaces
**mofmt** uses a single space as a horizontal separator between tokens.
Spaces are not inserted before:
- semicolons (`;`), except when preceded by `within`
- commas (`,`)
- parentheses and brackets (`()[]{}`)
- dots (`.`) in type specifiers and names
Spaces are not inserted after:
- dots (`.`) in type specifiers and names
- opening brackets (`([{`)
##### Example
```modelica
parameter .Foo.Bar[10] Baz(start = 0, max = 100);
```
### Operators
#### Unary
Two kinds of Modelica unary operators are treated differently:
- `not` operator is always followed by a space
- `+`, `-`, `.+`, `.-` are not followed by a space
##### Example
```modelica
-4
.-A
not is_off
```
#### Binary
All binary operators are surrounded with spaces.
##### Example
```modelica
(-2) * (3 - 1.76)
a <= b or x
1 : 10
```
### Assignments and equalities
`:=` and `=` tokens are surrounded with spaces.
##### Example
```modelica
foo = bar * 2
Real foo(min = 0, max = 2) = 1 / 2
foo := bar(x)
foo := if x < 2 then bar else baz
```
### Arrays, modifications, function calls, expression lists
Every comma (`,`) and semicolon (`;`) is followed by a space. This includes
discarded slots in *output-expression-list*.
##### Example
```modelica
{1.0, 2.0, 3.0}
(foo, , bar) := baz(x, y)
[x, y; a, b]
```
## Vertical spacing
### Indentation
Indentation is two spaces per level.
### Automatic wrapping
Line is automatically wrapped before every:
- class definition
- element
- equation
- statement
- description string
- annotation
- constraining clause
- enumeration item
In case of:
- class definition
- element
- equation
- statement
wrap can be doubled so there is a single blank line instead.
#### Automatic blank lines
Section keywords:
- `public`
- `protected`
- `equation`
- `algorithm`
- `external`
are always preceded and followed by a blank line. Those keywords are placed
without indentation.
Blank lines are also inserted:
- at the beginning and end of the *composition* rule
- before the "lass-wide annotation in the *composition* rule
##### Example
```modelica
within SomePackage;
final model Foo
// AUTO BLANK
Real x;
Real y;
// AUTO BLANK
protected
// AUTO BLANK
Real z;
// AUTO BLANK
equation
// AUTO BLANK
x + y = z;
x * 2 = y;
// OPTIONAL BLANK
z = 3 ^ 2;
// AUTO BLANK
annotation ();
// AUTO BLANK
end foo;
// OPTIONAL BLANK
partial record Bar
// AUTO BLANK
parameter Boolean is_off = false;
// AUTO BLANK
end Bar;
```
#### Descriptions, annotations and constraining clauses
Indentation is increased only one per element.
##### Example
```modelica
replaceable package Medium = Modelica.Media.R134a.R134a_ph
constrainedby Modelica.Media.Interfaces.PartialMedium
"Fluid medium"
annotation(Dialog(tab = "General", group = "Medium"));
```
But not:
```modelica
replaceable package Medium = Modelica.Media.R134a.R134a_ph
constrainedby Modelica.Media.Interfaces.PartialMedium
"Fluid medium"
annotation(Dialog(tab = "General", group = "Medium"));
```
#### Enumeration items
Indentation is increased inside `enumeration()` and at every
description.
```modelica
type BoundaryType = enumeration(
Pressure
"Pressure boundary",
Flow
"Flow boundary")
"Enumeration of possible boundary types";
```
#### Loops and ifs
Indentation is increased once per block.
##### Example
```modelica
if foo == bar then
baz := bark;
bam := bem;
else
if some_condition then
baz := 0;
bam := 1;
else
baz := bam;
end if;
end if;
```
### Manual wrapping
#### Function calls, arrays, matrices, modifications, lists
The main rule here is: be consistent. The following approach is applied:
1. If a line was originally wrapped at any argument in the specific construct,
then wrap at every argument in this construct.
2. If a line was originally wrapped inside a nested construct, then wrap at
every argument in every outer construct.
Indentation is increased accordingly to help visually identify the
scope.
##### Example
```Modelica
// No wrap is fine
h = enthalpy_pT(p, T)
// Outer array is wrapped, but inner ones are kept intact
parameter Real A[2, 3] = {
{1.0, 2.0, 3.0},
{5.0, 6.0, 7.0}}
// In nested function call, if inner call is wrapped, outer call is
// wrapped as well
cp_a = specificHeat_pT(
p = p_a,
T = temperature_ph(
p = p_a,
h = h_a))
// But it is fine to wrap only outer call, keeping inner one intact
cp_b = specificHeat_pT(
p = p_b,
T = temperature_ph(p = p_b, h = h_b));
// Wrapped comprehensions are little bit special
{
a[i] * b[i]
for i in 1 : n}
// Import lists
import Modelica.Constants.{
pi,
inf};
```
#### Expressions
Expressions like arithmetic, logical etc. are handled in a different way,
because **mofmt** doesn't apply autowrapping when it detects a wrap in the
original file. Original wraps are preserved, and indentation is adjusted.
Indentation is increased only once per expression.
Other difference is that instead of commas line may be wrapped before binary
operators.
##### Example
```Modelica
// No wrap
foo := 2 * (bar - baz) / 5
// Single wrap
foo := 2
* (bar - baz) / 5
// Two wraps
foo := 2
* (bar - baz)
/ 5
```