# Klang: Classes and Math Notation

Just got started with adding classes to Klang. At the moment, only immutable classes can be created and there is no inheritance.

The fields and methods are more separated than usual — the data is defined in the beginning of the class body as a single tuple type. On the other hand, there is a uniform access principle and both field accesses and method calls are represented the same way internally and in syntax. Actually the field access is implemented similarly to an intrinsic method call. Intrinsics in Klang usually translate to a single LLVM instruction and I’m going to expose some of them to users as well.

Here’s a sample program with a class:

```class Vector2 {
data (x: Double, y: Double)

// other methods skipped

def +(v: Vector2) = Vector2(x + v.x, y + v.y)
def length() = √(x² + y²)

alias |…| = length
}

def computeVectorLength(): Double = {
val v1 := Vector2(1, 1)
val v2 := Vector2(2, 3)
| v1 + v2 |
}

def main() = computeVectorLength().toInt
```

`Vector2` is a class whose data is represented as `(x: Double, y: Double)`. Reusing tuples again :) The compiler also generates a no-op function named Vector2 that takes the same tuple type and returns an instance of the class. It’s a no-op because the instances of classes are still held in LLVM registers (LLVM has an infinite number of registers) simply as the data they represent.

### Mathematical syntax

There is also some nice syntax resembling mathematical notation in the example. I want to allow as much mathematical syntax as can be represented in plain Unicode text, but also provide aliases for those who prefer plain English words. I took some ideas from Fortress, but I don’t want to go into that double-syntax stuff where the written syntax is weird, but can be rendered into readable mathematical notation.

I defined some specific characters as left/right braces that when surrounding an expression get turned into a specially named method call on that expression:
`| v1 + v2 |` is turned into `(v1 + v2).|…|` (the ellipsis is a single character, not three dots).

Unfortunately, I think using `|` as a left/right brace makes it hard to use `|` in the `or` meaning or allowing it as a regular identifier. Maybe it’s possible, but I’m not yet good enough with grammars to know for sure. Anyway, I think actual words `and` and `or` might be better than `&` and `|`. Certainly `^` as `xor` doesn’t make much sense. Of course, since I want to enable mathematical syntax, `∧`, `∨` and `⊻` are aliases for `and`, `or` and `xor` as well.

The above code example doesn’t actually parse yet — until I improve the parser and the lexer, there is some additional spacing and parentheses needed. For example `√((x ²) + y ²)` would compile.

If you know any programming languages which are good at mathematical notation in plain text, let me know in the comments.