# LPython Tutorial: 1

This is the first tutorial of LPython compiler.

## Installation

Please follow the steps mentioned in the
[LPython's installation instructions](https://github.com/lcompilers/lpython#installation).

After installation, verify it using:
```
% lpython --version
LPython version: 0.20.0
Platform: macOS ARM
Default target: arm64-apple-darwin22.1.0
```


## Getting started with lpython

Let's begin by compiling the very first code example using `lpython`.
Copy the contents of `hello.py`.

```
% cat hello.py
def main():
    print("Hello LPython!")

main()
```

Compile and run it using:

```
% lpython hello.py
Hello LPython!
```

`lpython` is designed to work exactly in the same way as `python`. LPython
is designed such that it is the **subset** of CPython and with the aim of
whatever works in LPython should also work in CPython!

Now, if we want to compile and run separately, we can do:

```
% lpython hello.py -o hello.out # just compile it!
% ./hello.out # run the binary!
Hello LPython!
```

### Variables

LPython is a strictly typed python compiler, meaning, each variable must
have a type just like C, or C++. Some of the basic supported types are

| Types    | Description |
| -------- | ------- |
| i1, i8, i16, i32, i64  | Integer type supporting 1, 8, 16, 32, and 64 bits |
| u8, u16, u32, u64 | Unsigned Integer type supporting 8, 16, 32, and 64 bits |
| str | String type|
| bool | Boolean type |
| f32, f64    | Real type supporting 32 and 64 bits  |
| c32, c64    | Real type supporting 32 and 64 bits |
| CPtr | C Pointer type |
| Const[T] | Constant type |
| Callable| Callable type |
| Allocatable | Allocatable type |
| Pointer | Pointer type |
| S | Symbolic type |

Try the following variable example
```
% cat var1.py
from lpython import i32, i64

def variable_function_1():
    x: i32 = 1
    y: i32 = 2
    print("x + y is", x + y)

    x1: i64 = i64(10)
    y1: i64 = i64(20)
    print("x1 + y1 is", x1 + y1)

variable_function_1()
```

Compile and run it

```
% lpython var1.py
x + y is 3
x1 + y1 is 30
```

Note that while instantiating `x1`, we have to **explicit casting** as
default integer type in LPython is `i32`. Implicit casting is
not supported to avoid any magic happening in your code and easy debugging.
Look at the nice error thrown below if we haven't added explicit cast.

```
% cat var2.py
from lpython import i32, i64

def variable_function_error_1():
    x1: i64 = 10
    y1: i64 = 20
    print("x1 + y1 is", x1 + y1)

variable_function_error_1()
```

Compile and try to run it
```
% lpython var2.py
semantic error: Type mismatch in annotation-assignment, the types must be compatible
 --> var2.py:4:5
  |
4 |     x1: i64 = 10
  |     ^^        ^^ type mismatch ('i64' and 'i32')


Note: Please report unclear or confusing messages as bugs at
https://github.com/lcompilers/lpython/issues.
```

Similarly, please note that the default type of float is `f64`.

### Functions

Functions in LPython are also strictly typed, meaning, each function
argument should have a type. The function also needs to have a return
type (if it returns a value).

Consider the following example of how function looks
```
% cat func1.py
from lpython import i32

def function_void_example():
    print("This function has no args and return type.")

def function_with_args_and_ret(a: i32) -> i32:
    # Function having i32 as return type
    return a + 1

def function_with_args(a: i32, b: str):
    print("Hello", b)
    c: i32 = function_with_args_and_ret(a)
    print("You just got", c)

function_void_example()
function_with_args(2, "lpython")
```

Running this we get

```
% lpython func1.py
This function has no args and return type.
Hello lpython
You just got 3
```

### Loops

LPython provide loop in the same way as in python. The only extra
condition is that the loop variable must be a typed and declared
beforehand. Take a look at the `for` loop example to understand it better

```
% cat loop1.py
from lpython import i32, i64

def loop_for():
    i: i32
    res: i64 = i64(0)
    for i in range(0, 10000):
        res += i64(i)
    print("for loop result:", res)

def loop_while():
    i: i32 = 1
    res: i64 = i64(0)
    while i < 10000:
        res += i64(i)
        i += 1
    print("while loop result:", res)

loop_for()
loop_while()
```