# Simple Expressions

## Literal values

The simplest kind of expressions in Ergo are literal values.

```
"John Smith" // a String literal
1 // an Integer literal
3.0 // a Double literal
3.5e-10 // another Double literal
true // the Boolean true
false // the Boolean false
```

Each line here is a separate expression. At the end of the line, the notation `// write something here`

is a *comment*, which means it is a part of your Ergo program which is ignored by the Ergo compiler. It can be useful to document your code.

Every Ergo expression can be *evaluated*, which means it should compute some value. In the case of a literal value, the result of evaluation is simply itself (e.g., the expression `1`

evaluates to the integer `1`

).

You can actually see the result of evaluating expressions by trying them out in the Ergo REPL. You just have to prefix them with

`return`

: for instance, to evaluate the String literal`"John Smith"`

type:`return "John Smith"`

(followed by clicking the button 'Evaluate') in the REPL. This should answer:`Response. "John Smith" : String`

.

## Operators

You can apply operators to values. Those can be used for arithmetic operations, to compare two values, to concatenate two string values, etc.

```
1.0 + 2.0 * 3.0 // arithmetic operators on Double
-1.0
1 + 2 * 3 // arithmetic operators on Integer
-1
1.0 <= 3.0 // comparison operators on Double
1.0 = 2.0
2.0 > 1.0
1 <= 3 // comparison operators on Integer
1 = 2
2 > 1.0
true or false // Boolean disjunction
true and false // Boolean conjunction
!true // Negation
"Hello" ++ " World!" // String concatenation
```

Again, you can try those in the Ergo REPL. For instance, typing

`return true and false`

should answer`Response. false : Boolean`

, and typing`return 1.0 + 2.0 * 3.0`

should answer:`Response. 7.0 : Double`

.

## Conditional expressions

Conditional expressions can be used to perform different computations depending on some condition:

```
if 1.0 < 0.0 // Condition
then "negative" // Expression if condition is true
else "positive" // Expression if condition is false
```

Typing

`return if 1.0 < 0.0 then "negative" else "positive"`

in the Ergo REPL, should answer`Response. "positive" : String`

.

See also the Conditional Expression Reference

## Let bindings

Local variables can be declared with `let`

:

```
let x = 1; // declares and initialize a variable
x+2 // rest of the expression, where x is in scope
```

Let bindings give a name to some intermediate result and allows you to reuse the corresponding value in multiple places:

```
let x = -1.0; // bind x to the value -1.0
if x < 0.0 // if x is negative
then -x // then return the opposite of x
else x // else return x
```

TechNote:let bindings in Ergo are immutable, in a way similar to other functional languages. A nice explanation can be found e.g., in the documentation for let bindings in ReasonML.