# meow

most awesome language, mainly because it's not object-oriented and it's called meow.

Multiple dispatch!

Weird syntax!

Implicit interfaces, except we call them constraints! whyyyy did I do this?





```
<imports>

<declarations>
```





### imports

```
import "std:strings" as str // standard library
import "std:strings/ext" as strext // nested 
import "foo:bar" as fb // file bar from project foo
import ":foo/bar" // relative to project root
import "foo" // relative to current file
import "./foo" as whatever // relative to current file
import "../foobar" // relative to current file
```

access public thingies from imports with `:`

```
import foo;

foo:somefunction();
foo:SomeType
foo:SomeConstraint
```


### functions
Functions are by default private to the current file, functions with `pub` are accessible from other files/projects.
```
fn x() {}
pub fn y() {}
```

Functions can take the `[c_export]` attribute to make them callable when compiled as a static library, and to generate C headers for them. 
```
[c_export] pub fn foo(a: int, b: Foo, c: Bar): int {

}

[c_export("renamed_foo2")] pub fn foo2(a: int, b: Foo, c: Bar): int, int {

}
```

Functions can be overloaded on parameter and return types
```
fn a(): s32 {
    return -1;
}
fn a(): u32 {
    return 1;
}

fn a(x: i32, y: i32): (i32, i32) {
    return y, x;
}

fn a(x: u32): u32 {
    return x + 1;
} 
```

### constraints
constraints are kind of weird because they 
 - can have multiple types, like, a constraint can constrain multiple types together
 - can be used both as a constraint on generic types and as a type themselves
   - but only can be used as a type when they constrain only one type, and then they're kinda like an interface?
 - fuck this is weird

```
// this one can be used only as a constraint for generic type parameters
constraint Foo on A B {
    some_func(A, B);
    some_other_func(A): B;
}

// this one can be used both as a constraint for generic type parameters or as an interface type 
constraint Bar on A {
    f1(A): A;
    f2(A): i32;
}
```

```
// usage as type parameter constraints
fn foo<T1, T2>(T1 x) 
    where Foo T1 T2
{
    T2 y = some_other_func(x);
    some_func(x, y);
}

fn bar<T>(T a): i32
    where Bar T
{
    T b = f1(a);
    return f2(b);
}

// usage as interface types

Bar x = getSomeTypeThatIsBar();
Bar y = f1(x);
```

constraints can be embedded in other constraints like this:
```
constraint Arithmetic on A {
    operator+ (A, A) -> A;
    operator- (A, A) -> A;
    operator* (A, A) -> A;
    operator/ (A, A) -> A;
}

constraint Foo on A {
    Arithmetic A;
    some_func(A) -> A;
}

```


### literals
#### numeric
Numeric literals are untyped but literals with a decimal point can not be used as integers. 
They can contain underscores between digits which are ignored, e.g. `1_000` or `1_0_0_0`.
Unprefixed numeric literals are decimal, prefixes exist for hexadecimal (`0x`), octal (`0o`) and binary (`0b`).

#### character
The character literal is a single unicode character enclosed in single quotes, its value is the character's unicode code point. 

#### bool
`true` and `false`

#### string
String literals are enclosed in double quotes (e.g. `"hello world"`). 
Their type is an `u8` array with length of the string in bytes. 


### types
#### basic types
 - bool: `bool`
 - signed integer types: `s8`, `s16`, `s32`, `s64`, `s128`
 - unsigned integer types: `u8`, `u16`, `u32`, `u64`, `u128`
 - floating point types: `f32`, `f64` (possibly more?)
 - decimal type? `decimal`
 - complex types? `c64`, `c128` (does this refer to the total size or the size of each component?)


#### compound types
##### array & slice
###### declaration
```
// array
[u8; 10]
// slice
[u8]
```
###### use
```


let a: [u8] = "foo";
let b: u8 = a[1]; 
let d: [s32; 4] = []{1,2,3,4};
let e = [u8]{1,2,3,4};

let f = d[1:3]; // f has type [s32] (slice) now


type Arr = [u8];
let g = Arr[]{1,2,3};

```
##### struct
###### declaration
```
struct Point {
    x: s32;
    y: s32;
    z: s32;
}
type Point = struct {
    x: s32;
    y: s32;
    z: s32;
}


type Options = struct {
    api: struct {
        int foo;
    };
}
```
##### use
```
let p1 = Point{
    x: 1,
    y: 2,
    z: 3,
};
let p2: Point = {
    x: 2,
    y: 3,
    z: 4,
};

let x = p1.x;

p1.x = 2;

let opt = Options{
    api: {
        foo: 1
    }
};

let a: Options@api = opt.api; // yeah this is weird, try to avoid it

```

##### enum
###### declaration
```
enum A {
    Foo,
    Bar(u8)
}

type A = enum {
    Foo,
    Bar(u8)
}

type B = enum {
    X,
    Y(enum { // this is terrible but you can do it if you want for consistency reasons
        A,
        B
    })
}

```
###### use
```
let x = A'Foo;
let y = A'Bar(10);
let z = B'Y(B@Y'A); // don't do this why would you do this
```

##### tuple
###### declaration
```
type X = (s8, s8);
tuple X(s8, s8);
type Y = (struct {int a; int b}, enum {A, B}); // why would you do this aaaaa
```
###### use
```
let a: X = (1,2);
let b = a.0;
let c = a.1;
let d = Y({a: 1, b: 2}, Y@1'A); // oh no
let e: Y@1 = d.1;
```






#### pointers
Pointers are taken with the `&` operator and dereferenced with the `*` operator. They are mostly similar to C I think.
Pointer types have a `*` appended to the type they point to.

```
let a: int = 1;
let b: int* = &a;
let c = *b;
```

A special `void*` type exists???? does it really? maybe? kinda yes? aaaaaaa


Pointer arithmetic works the same as in C, except that arithmetic on void pointers is allowed?

```
let a: [u8; 2] = {0,1};
let b: u8* = &a[0];
let c: u8* = b + 1;
let d: u8 = *b; // 0
let e: u8 = *c; // 1
*(&a[0]+1) = 2; // a is now {0,2} 
```



## operator precedence

```
. (struct member access), [] array subscripting
    
 unaries: + - ! ~, pointer dereference *, pointer reference &, 
 binary operators:
 * / %
 + -
 << >>
 > >= < <=
 == !=
 &
 ^
 |
 &&
 ^^
 ||
 lowest precedence, assignment:
 =
 +=
 -=
 /=
 *=
 %=
 &=
 |=
 ^=
 <<=
 >>=

```