# Python++

I created this language as a result of my frustrations with Python.

Currently my language is significantly worse than Python, and needs a lot of work before it can be considered functional.

## Hello World

```
print("Hello, World!\n");
```

The following is a non-comprehensive list of stuff that currently works.

## Assignment & Declaration

```
a: str = "Hello, World!\n";
b: int = 0;
c: str; // declared, but not yet assigned
```

## Expressions

```
a: int = 34;
b: int = 35;
c: int = 1;
d: int = a + b * c; // with correct operator precedence
```

## Structs

```
struct MyStruct {
	field1: int,
	field2: str,
	field3: SomeOtherStruct
}

my_struct: MyStruct = MyStruct.{
	field1=1,
	field2="Hello, World!",
	field3=SomeOtherStruct.{...} // whatever SomeOtherStruct takes
};

my_struct.field1 = 2;
plus5: int = my_struct.field1 + 5;
```

## Enums

```
enum Weekday {
	Monday,
	Tuesday,
	Wednesday,
	Thursday,
	Friday,
	Saturday,
	Sunday
}

day: Weekday = Weekday.Tuesday;

match day in {
	case Monday    { ... } // handle Monday
	case Tuesday   { ... } // handle Tuesday
	case Wednesday { ... } // and so on...
	case Thursday  { ... }
	case Friday    { ... }
	case _         { ... } // default
}
```
or
```
enum IntResult {
	Ok(int),
	Err(Error)
}

result: IntResult = IntResult.Ok(5);

match result in {
	case Ok(num) { ... } // num is defined in this scope
	case Err(err) { ... } // similarly err is defined in this scope
}
```
Currently, polymorphic structs/enums are not supported, however I plan to eventually do so.

## Functions

```
func random_number(seed: int) -> int {
	return 42;
}

my_random_number: int = random_number(69);

func min(a: int, b: int) -> int {
	if a < b return a;
	return b;
}

the_min: int = min(5, 10);
```

## Arrays

```
numbers: int[] = [:int, 0, 1, 2, 3, 4]; // array literal must state element type (for now)
numbers = [:int, 2*x for x in numbers]; // list comprehension must also (for now)
```

## For loops

```
// prints numbers 0-9
for i in range(0, 10) {
	print(int_to_str(i)+"\n");
}
```

## While loops

```
a: int = 0;
while a < 10 {
	print(int_to_str(a)+"\n");
	a = a + 1;
}
```

## Reading files

## Importing

## Assertions

## Tuples

```
a: (int, str) = (0, "hello");
print(int_to_str(a.0)+" "+a.1+"\n");
```