# Chapter 1: Getting Started

Deimos can be run both interactively via a read-eval-print loop (REPL) or by compiling and running a given source file.

## REPL

The REPL allows interactive programming similar to classic functional languages as well as Ruby. To start the REPL, run:

```
dm repl
```

### Basics

All statements and expressions in the REPL are scoped under a synthetic function; in other words, variables persist 
through each input:

```
> let x = 2
> x
2
> let y = 3
> x + y
5
```

In addition to statements and expressions, functions can be defined in scope:

```
> fn double(x: Int) x * 2 end
> double(4)
8
```

Note that variables in the "top" scope are not available inside defined functions:

```
> let x = 7
> fn doubleX() x * 2 end
Error: Symbol x could not be found.
```

This requires the use of closures, which can "capture" variables in their containing scope:

```
> let x = 42
> let doubleX = { x * 2 }
> doubleX()
84
```

Note the difference in syntax between function declarations and closure declarations. As we will later see, closures are
powerful constructs.

### Introduction to Classes

Classes can also be defined in the REPL:

```
> class Dog \
  pub name: String \
  pub ctor(name: String) \
    self.name = name \
  end \
end
```

A few things are going on here. First, note the use the backslash to indicate that we are not done with our input
(normally, a newline without a preceding backslash will cause the interpreter to consume everything input so far). Next,
note our syntax for declaring a class, with hints of Rust and Ruby:

- `class` keyword: the usual meaning
- `pub` keyword: makes a property or method available outside the class (i.e., non-private)
- `: Type` annotations: indicates the type of a property, parameter, or variable.
- `ctor` keyword: marks a constructor. *Note: Classes can only have **one** constructor*.
- `self` keyword, followed by property name: like the usual construct in OOP languages.

Once we've defined our class, we can use it:

```
> let bear = Dog("Bear")
> let skye = Dog("Skye")
> bear.name
Bear
> skye.name
Skye
```

Note above how we construct instances of the class by "calling" the class, exactly like we do in Kotlin.

#### Class Declaration Short Form

The above class example is a bit verbose; Deimos offers the following equivalent, inspired by Kotlin:

```
class Dog(pub name: String) end
```

This is especially useful in the REPL, where we may just want to declare a data type for doing some data processing.

```
> class Point(pub x: Int, pub y: Int) end
> fn double(p: Point) Point(p.x * 2, p.y * 2) end
> let a = Point(3, 4)
> double(a)
Point(6, 8)
> let b = Point(5, 6)
> double(double(b))
Point(20, 24)
```

## Compiling and Running Files

To compile and run a file, do:

```
dm run <your file name here>.dm
```

Note that the `.dm` extension is required in the command name (unlike `java`).

The above command will compile and immediately run the file. In order for a Deimos file to be executable, it must
contain a `main` function like the following:

```
fn main()
  println("Hello, Deimos!")
end
```

Unlike the REPL, statements and expressions are not allowed in the top-level scope; they must be contained in a function
or method:

```
let x = 10 // ERROR! Will not parse.
```

However, functions, classes, and other top-level constructs are allowed:

```
fn double(p: Point) -> Point
  Point(p.x * 2, p.y * 2)
end

class Point(x: Int, y: Int) end

fn main()
  let a = Point(1, 2)
  let b = Point(3, 4)
  println(double(a)) // Point(2, 4)
  println(double(b)) // Point(6, 8)
end
```

```
let f = { a, b -> a + b } << 4
let x = f(5)
println(x) // 9
```