October 2022

Week of 2022-10-31

Revised return handling so that a return statement with no expression is syntax sugar for return None. This enables early exits in functions that implicitly return None to be cleaner:
```
def just_return():
    return
```
Added support for parsing more expressions: if-else, bitwise operators, shift operators, comparisons, floor division, remainder, and matmul.
📢 The type of the self argument can now be omitted on member methods.

Week of 2022-10-24

Added parser support for right-associativity and unary ops, like the power operator a ** b ** c and negation operator -a.
Add support for &expr in Mojo, which allows denoting a by-ref argument in functions. This is required because the self type of a struct method is implicitly a pointer.

Implemented support for parametric function declarations, such as:

struct SIMD[dt: DType, width: index]:
    fn struct_method(self: &SIMD[dt, width]):
        pass

def fancy_add[dt: DType, width: index](
    lhs: SIMD[dt, width], rhs: SIMD[dt, width]) -> index:
  return width

Week of 2022-10-17

Added explicit variable declarations with var, for declaring variables both inside functions and structs, with support for type references. Added index as a temporary built-in type.
```
def foo(lhs: index, rhs: index) -> index:
    var result: index = lhs + rhs
    return result
```
Implemented support for parsing struct declarations and references to type declarations in functions! In def, the type can be omitted to signal an object type.
```
struct Foo:
    var member: index

def bar(x: Foo, obj) -> index:
    return x.member
```

Implemented parser support for if statements and while loops!

def if_stmt(c: index, a: index, b: index) -> index:
    var result: index = 0
    if c:
        result = a
    else:
        result = b
    return result

def while_stmt(init: index):
    while init > 1:
        init = init - 1

Significantly improved error emission and handling, allowing the parser to emit multiple errors while parsing a file.

Week of 2022-10-10

Added support for parsing integer, float, and string literals.
Implemented parser support for function input parameters and results. You can now write parametric functions like,
```
def foo[param: Int](arg: Int) -> Int:
    result = param + arg
    return result
```

Week of 2022-10-03

Added some basic parser scaffolding and initial parser productions, including trivial expressions and assignment parser productions.
Implemented basic scope handling and function IR generation, with support for forward declarations. Simple functions like,
```
def foo(x: Int):
```
Now parse! But all argument types are hard-coded to the MLIR index type.
Added IR emission for simple arithmetic expressions on builtin types, like x + y.

Week of 2022-10-31​

Week of 2022-10-24​

Week of 2022-10-17​

Week of 2022-10-10​

Week of 2022-10-03​

Week of 2022-10-31

Week of 2022-10-24

Week of 2022-10-17

Week of 2022-10-10

Week of 2022-10-03