I have been doing a lot of under-the-hood refactors recently. The context system for emission has been completely redesigned.
- Previously there was one instance of `IR::Context` that handled all AST & scope specific information to be used in the emission phase
- This got really clunky as features grew and language matured
- Now, there is `EmitCtx` that can created on the fly with the relevant information by the top-level entities, to be used by their children for emission. This makes it possible to do trivial context-switching for emission in a different scope.
- While I have been wanting to do this for long for ergonomic reasons, this mainly paves way for prerun functions (compile-time functions)

EmitCtx instead of IR::Context for maintaining state of emission

Methods can now be conditionally defined. In this example, the `transpose` variation exists for a variant of Matrix only if it is a square matrix (rows == columns)
![Conditional Method Example](image:waj9pnqcvs5nefx)

Conditional methods

I have started working on a register based VM for the language. The design of the foundation of the VM is not finalised, but I have decided to go forward with explicit instructions for each variant of an operation.
For example, 
- `add_i32_reg` for adding i32 in 2 registers
- `add_i32_reg_pre` for adding an i32 in a register with a constant (prerun) value
- `add_i32_pre_reg` for the reverse order of the previous instruction

This is to avoid additional conditions and reduce time for dispatch. And also for reducing bytecode size.

Beginning of the VM project

I have been recently working on FFI, SIMD vectorized types and other ergonomics and bugfixes
- I made bindings to GLEW, SDL2 and have successfully been able to create windows and draw items on the window using sdl. This was done as an exercise and also as a test project. Several bugs have been caught as part of this and fixed for good. The GLEW interface is about 5000 lines of code and SDL is about 3000
- SIMD vectorized types are now built-in to the language. `vec:[4, i8]` is a fixed vector type, and `vec:[?, 4, i8]` is a scalable vector type. Scalable vector types cannot be allocated and only exist as a value
- Introducing value methods. Methods that operate on the value of the parent type, instead of a reference to it. These methods can be defined only for types that are trivially copyable and trivially movable. This makes it possible to call method for data on virtual registers

SIMD vectorized types

I am doing some research in register based VMs. I am thinking of creating one for compile time execution and debug builds of the language

Research on register based VMs

My PC specs:
CPU: AMD Ryzen 9 5900x 12-core 24 Threads @ 3.7 GHz, Zen3
RAM: DDR4 24GB
Storage: NVME m.2 SSD
But I believe here, only single core performance matters, as the compiler is not parallelised yet

My PC specs

I am working on advanced const-expression features and const-generics

Working on advanced const generics

@everyone 
The latest release is out `v0.7.0`. Try online in the playground at <https://qat.dev/playground> Or download right now for your platform:
https://github.com/qatlang/qat/releases/tag/v0.7.0
**So many awesome features...** This release consists of 2 month worth of work and improvements

Latest release 0.7.0

The llvm maintainers were suggesting that something was wrong with my build config or I have memory corruption that propagated to the LLVM debug and release builds

Suggestion from LLVM maintainers

I am out of town for 2 days, so cannot work on anything till I return

Out of town

Now in generics, templated type can have a default type
```qat
type SomeTy'<T = i64> {
    pub elem :: T.

    pub from (''elem) [
        say "Created SomeTy".
    ]
}

main -> i32
(#[+ cstring ?] cliArgs) [
    new v = SomeTy'<> from (10_i64).
    give 0.
]
```

Default type for templated types

Also I don't know if anyone noticed, but the website at https://qat.dev has been majorly overhauled to be responsive and thereby support mobile devices. Also removed inline and normal css to integrate tailwindcss

Website rehaul and added TailwindCSS

@everyone 
The cost of the website https://qat.dev is getting high
The domain was just renewed for another year for INR 10000, and the server costs about INR 4500 per month. So, about INR 64000 every year to keep the site live. The site is not a simple one. You can compile code using the latest version of the language, but that requires a dedicated server to function.
I am currently transitioning jobs. Didn't have income for the past 2 months.
So if this has to be sustainable, there should at least be about $787 per year of funding, which means about $65 per month in total, which honestly doesn't sound that bad at all. Equivalent to about 13 per-month nitro boosts. If we have more members in this server, it's definitely doable.
**What can you do?**
Either considering sponsoring the project on Github: https://github.com/sponsors/aldrinmathew
Or do a one-time donation here: https://paypal.me/aldrinsartfactory or https://ko-fi.com/aldrinmathew
If you can't contribute financially, don't worry. You can always get the word of mouth going on and let others know about the language.

Cost of the website

Speedup update - The compilation & linking phase is now `15% to 20%` faster.
The compilation of LLVM IR files (.ll) to Object files is one phase.
The bundling of object files to libraries and linking to executable is another phase.
- So first, all llvm files are compiled to object files in parallel for all modules. Then the compiler waits for this phase to complete
- Then, libraries and executables are linked from the object files, in parallel, and compiler waits for all to finish
I think this change is going to be significant in larger codebases, as the current test project is only about 4 files. So the improvement is only 15% to 20%
If these phases were not parallel, in a larger codebase, the total time taken would have been so high, so the speedup from parallelisation would be higher

Compilation & linking speedup

I have created a region allocator for internal use in the compiler, to be intended for use in the parser as the parser have several allocations for the AST. With the region, the allocations will decrease in number significantly there

Region allocator for internal use in the compiler

String slice comparisons are optimised to be always inlined, to prevent unnecessary allocations, loads and stores. Currently, string slice comparison only works in `match`, but it will be added to work with the `==` operator

Optimisations for string slice comparisons

This addition makes static & automatic memory management possible

@everyone  I forgot to mention that 13th December 2022 was the first year anniversary of the compiler.

Forgot first year anniversary

https://github.com/qatlang/qat/releases/tag/0.6.0-alpha

The filesystem based library system has been updated. Previously, if the folder contained a file named `lib.qat`, it was detected as a filesystem library. But now the name of the library has to be present in the filename. Now the filename has to be `std.lib.qat`. There is also a check to prevent keywords of the language being library names, achieved by moving a part of the logic of the tokeniser, to a static function

Update to the filesystem based library system

Also, multi pointers also makes it easy to loop over the elements in a sequence, without an index.
```qat
new mPtr : #[+ u64?] = getMPtr().
loop over (mPtr) : new Elem [
    say "Number is: ", Elem.
]
```

Multi-pointers & looping over elements

The syntax and IR support for multi pointers have been added `#[+ u64]`. Now, all pointers can be indexed, but soon, only multi pointers can be indexed

Syntax & IR support for multi-pointers

Syntax for creating string slices have been changed to `str{pointer, length}`

Previously it was `str from (pointer, length)`

Syntax change for string slice creation

When you usually call `malloc`, it always requests memory with size the multiple of the PAGE_SIZE. For most systems, this is 4KB or 4096 bytes. So, regions are implemented by making use of all that memory, which would otherwise be not used at all. Also, after one call to the `malloc` by the region at the start, further allocations are not needed unless the new object is going to need more than what's left in the block. So for practical use cases, majority of allocations in a region are just adding an offset to an existing pointer, so the overhead of calling `malloc` every time is gone

Implementation of regions, malloc and page size

I will be working on the docs site to make it friendlier and more populated for new members

I watched the best football match of my life, which if I remember correctly, is the first World Cup match I watched in full ever. Congrats to **Argentina** for winning the FIFA World Cup 2022. Seriously, It was 3 hours of awesome!!!

Best football match of my life

I know that the docs at https://docs.qat.dev has nothing in it besides installation instructions and hello world, but it will soon be populated.

Added `--release` flag to the CLI configuration to change the build mode
Added `log` to the language. This uses the exact same AST representation as `say`, but only will be compiled in debug mode
```qat
say "Hello world". // Will always be compiled
log "Hello world". // Will only be compiled in debug mode
```

Added release flag and log sentence

By the way, you might have already noticed, but we have a new guest here <@1031034828348469249> 
Currenly posts updates on push events from the repositories, but soon will be able to do more

New guest in the server

I removed parenthesis from loops and if-else and managed to slow down the parser by ~50%
Without parenthesis, the tokens have to be peaked to recognise the nature of `[ ... ]` and `{ ... }` blocks as these can be in expressions as well.
Being modern has a huge cost, even for programming languages.
I will keep the syntax for loops and if-else without parenthesis for now, and will explore opportunities to speed up the parser somewhere else. I might add back the previous syntax.
For now, as far as speed is concerned, compilation and linking is biggest worry.

Cost of being modern

I use discord rarely anymore which is the reason for the lack of updates, but I don't want to abandon the server altogether
For the past 2 months, I have been super focused into the language. The compiler is closer to being stable. Rehaul of some clunky syntax has been done, Lots of refactors, Added prerun expressions (compile time metaprogramming), Generic type definitions, Foreign Function Interface (mostly for C, partly C++ as well), Removed old async-await to pave way for the updated `spawn` concept, C compatible primitive types, Prototype for `skill`s (like interfaces in Java or traits in Rust), Integrated libclang to get target information, thread-level `panic`s (as of now internal, AST support is ongoing), and so many more changes that will take 2 or 3 pages to list...
**I have started working on the Standard Library as well**

Compiler updates & break from discord

The const generic system is finally done, with support for default type for generic type parameters, and default expression for const generic parameters

```qat
type SomeTy'<T = i64, const K :: str = "Hello", const U :: str = "K"> {
    pub elem :: T.

    pub from (''elem) [
        say "Created SomeTy".
    ]
}

main -> i32
(#[+ cstring ?] cliArgs) [
    new v = SomeTy'<> from (10_i64).
    new k = SomeTy'<i32, default, "4"> from (5).
    give 0.
]
```

Finished const-generics system

Added `MemoryTracker` to the compiler, which also consists of an overloaded `new` & `delete` operators. The MemoryTracker keeps track of the number of active objects on the heap and the total size of all heap allocations in the project. The number of active objects by the end of the main function has been confirmed to be 0. However, there is also a negativeCounter to keep track of extra `delete`s happening and it is at 19 for the test program. The compiler is no more leaking memory. The cause of the extra deletes seems to be that the overloaded delete operator is called for pointers allocated using the default new operator. This doesn't throw errors since ultimately both are calls to the `free` C function

Added Memory Tracker to track memory data

The `let` keyword has been changed to `new` and declaration syntax has been changed
```qat
new a = 10.     // Constant
new var b = 20. // Variable
new c : u32 = 10.
new var d : str = "Hello, World!".
```
`new` does not mean heap allocated or custom allocated value, it's just a declaration

Changed let keyword to new

Added ownership to raw pointers. Currently, there are 4 types of ownership
```qat
#[u8]                 // Owned by the parent function or parent type
#[u8 'heap]           // Owned by heap (custom region)
#[u8 'type]           // Owned by the parent type (can be used inside member functions, hence dedicated syntax)
#[u8 'type(SomeTy)]   // Owned by SomeTy
#[u8 ?]               // Anonymous Ownership
```
- Only the owner can free the memory pointed to by the pointer. In fact, pointers owned by functions & types are automatically freed at the end of their lifetime
- Heap owned pointers can be freed by anyone. This is so as to facilitate manual memory management.
- Anonymous pointers cannot be freed. These pointers are not created like that. It is just understood as anonymous in a context different from that of the owner.

Added ownership to raw pointers

The problem with compile time definitions on windows is resolved.
I tried to get the build working on the clang64 variant in msys, but now it is being built in mingw64, so everything including `qat version` and similar commands are working

The entity dependency system is only for top level entities like types, functions... Statements and expressions by nature are handled by their parent entity as the dependencies are known

Entity dependency system

There have been some major updates to the compiler. The repo has been moved to Gitlab and that's why there are no updates about the compiler repository in the <#932510699454861352>  channel

The arrow used in match blocks have been changed to `->`

Pattern matching for string literals have landed. Previously it only worked for values with choice types & mix types

Pattern matching string literals

Matching values of mix types, also supports multiple values for a case. If multiple values are used, the matched value cannot be requested for use.
```qat
choice A { a, b, c }

mix MyMix {
   a :: i32,
   b :: u64,
   c :: str,
   d :: A,
}

match (myMixVal) [
   ::b, ::d -> [
      say "Mix n matched".
   ]
   ::a(mval) [
      say "Number in mix is: ", mval.
   ]
   else []
]
```

Matching values of Mix types

An option to clear all objects in the region in the middle of the program is also in implementation, for rare cases.

This feature alone makes something like borrow checker and garbage collector absolutely unnecessary and insane. The only overhead you have from regions, is the overhead of cleaning up of resources at the end of the program execution. So you don't pay for this while your program & logic is running

Main function syntax has been updated to be
```qat
main -> i32
(#[+ cstring ?] args)
```
This is so that the args can be iterated using the `loop over` syntax, without exceeding the bounds
The following variants of main function are also supported
```qat
main(#[+ cstring ?] args)
```
```qat
main()
```
```qat
main -> i32
()
```

@everyone  I know that there hasn't been updates for a while now. For the past 2 weeks, I was busy with personal stuff and some family functions. Especially on the last 2 sundays, I had some ceremonies to manage and attend. I already had about 20 files left to be commit, with quite a lot of work done, before pausing work. I have resumed development now.

Here is how matching multiple values for choice types and string slices work
```qat
choice A { a, b, c }

new myStr = "world".
new myCh = A'a.
match (myCh) [
   'b, 'a => [
      say "Choice is matched".
   ] else [
      say "Choice NOT matched".
   ]
]
match (myStr) [
   "Hello", "world" => [
      say "String is matched".
   ] else [
      say "String NOT matched".
   ]
]
```

WASM support has been added to the language. I just compiled the first program to wasm binary with the target triple `wasm-unknown-wasi` and using `wasi-16-sdk`

@everyone  Happy New Year!!! 🎉 🥳 ❤️ 
Let this year bring joy to your life and to those around you. Let yours dreams come true and let your life be better than ever before...

Happy New Year 2023

Regions are intended to be used when the lifetime of an object is required to be large enough for a variety of execution contexts. You can exchange, pass and use an object in a region without worrying about RAII, copy/move, or scope. Also references dereferenced from a pointer in a region, are always guaranteed to exist until the end of the program and solves the problem of objects being destroyed in their scope

Purpose of regions in the language

I know this is not related to the language, but I am too excited and don't have anywhere else to put this

Currently, `maybe`, `future` and `mix` types makes use of this feature

@everyone  The compiler now supports `Linux x64`, `Linux arm64 (AArch64)`, `Windows x64`, `MacOS x64 (Intel)`. There is no public release supporting all of these platforms, but there soon will be. I haven't made a `v0.8.0` release, so am thinking of going straight to `v0.9.0` as there are so many changes. But I guess it doesn't matter which version it is, as we are getting closer to `v1.0.0`.
I have a Raspberry Pi for linux-arm64, my desktop and laptop has linux and windows. I have VM in my desktop that runs MacOS x64. So the builds are done manually and tested properly. Standard library importing is now supported.

Compiler available in new platforms

> The implementation was a bit more difficult than usual, since I had to write the entire allocation and deallocation functions using the LLVM C++ API & IR, with lot of pointer arithmetic and casts.
> Funnily enough, this is the first time I have ever done pointer arithmetic

@everyone The entire compiler is single threaded for now, parallelisation is in planning. But on release mode both Lexing and Parsing speed is about 360000 lines per second, parsing sometimes gets to 400000.
Hand-written lexer and parser has paid off in my opinion
I wrote a custom allocator for speeding up the parser, but didn't even integrate it at all yet. Was timing the lexer, and found out that the parser is fast as well. My surprise was mostly because in debug mode, parsing was slow due to debug logs everywhere (with a macro that is removed in release builds)
The compile speed is not that impressive in my opinion, but that step involves heavy interaction with the LLVM library. I am seriously considering another backend as well for faster compilations, but maybe for later

Lexer and parser benchmarks

Added `==` operator for the `str` type (String slices). Now string slice comparisons are natively supported, as in the operator and also in `match` blocks

Equality operator for string slices

Completely rehauled the emission system. The previous system to generate LLVM IR was loosely similar to the visitor pattern. This has been rehauled.
- Now, before compilation, the dependencies are properly detected and tracked. The emission phase is now not sequential. If all dependencies are resolved, the entity is created and its contents emitted.
- The compiler takes several turns until no new entities are handled. Meaning that the emission cannot go forward as there are conflicting/convoluted dependencies. Majority of use cases are properly handled, unlike in C & C++
- An entity can have multiple phases of emission. A dependency could be for any of these phases. Entities also have status to indicate whether they are partially or completely created, or whether their children are created or not

Rehauled emission system

Currently writing the standard library. Working on the string.qat file right now. Finished implementations for `unsigned_to_string:[T]`, `signed_to_string:[T]` and `float_to_string:[T]` which works for any of the numerical types supported by the language.
That applies to arbitrary bitwidth integers as well. Like `u100`.

Writing the standard library and string conversion functions

Multi pointers point to multiple instances of data

The reason for the delay of the monthly release is that the type system is getting significant and major updates so that non-core types can also have member functions, destructors, copy & move semantics

Version `0.5.0-alpha`
There are binaries for linux and windows
https://github.com/qatlang/qat/releases/tag/0.5.0-alpha

Now, trailing arrow `->` while providing trivial and non-trivial expressions to match are compulsory.
```qat
match (myCh) [
   'a, 'b -> [
      say "Choice: a or b is matched".
   ] myCh -> [
      say "Choice: Expression matched".
   ] 'c -> [
      say "Choice: c is matched".
   ] else [
      say "Choice NOT matched".
   ]
]
```

@everyone  Merry Christmas!! 🎉 🎅 🎄 Just attended the XMas mass at my church and back home. Due to christmas festivities, there won't be as many updates as usual for the next 3 to 5 days or so. Following that, the next version of the compiler will be released with major features and significant updates and fixes.

A dedicated representation for array pointers is in the works, that is for pointers that hold reference to multiple instances of data. This is necessary when static & automatic memory management is implemented

I know it's Christmas, but I worked on the language. Major update for pattern matching. Now pattern matching supports **multiple values** as part of a single case.
This feature works for choice values (enums) and string slices ***Ain't that awesome!!***

This is the syntax for a constructor call that gets pointer to `Hello` 
```qat
own'region(SomeReg) Hello from (5, 20)
```

Now types can have modular destruction, without having a destructor function. The logic will be inlined, therefore preventing unnecessary allocations, loads and stores. This is a significant optimisation that helps cleaning up values of types other than core types, without having to define a destructor function. How awesome is that? 🥳

Now there is an optimisation for constant string comparisons. The result of the comparison is calculated at compile time, which means that in `if-else` chains and `match` expressions, only essential branches of the control flow are emitted in the LLVM IR.

If at least one of the conditions in an `if-else` chain is `true` at compile time, only that branch is emitted. If all values are known to be `false`, then only the `else` branch is emitted.

In `match` blocks, since multiple values are allowed for a single case, there could be constant and non-constant expressions for the same case. If at least one of the the values match, the result is known to be `true` for that case and no other branches or no other match cases are emitted. If one or more values are `false` for a case, but there are other non-constant values, then that branch is emitted as usual, since the final result cannot be calculated at compile time. If all values provided for all cases are constants and the result is known to be `false` for all cases, then the `else` branch is emitted.

Optimisations for constant string comparisons & compile time

Changed the syntax for definition of core types
```qat
type String {
  strt :: #[u8].
  cap  :: usize.
  len  :: usize.
}
```

Changed syntax for core types

The length/count of instances of the multi pointer can be obtained like `mPtr'length`

Just left the `Together C & C++` server as it got too hostile. The mod there named Cassowary is a jerk who attacks people because they don't like the way people talk.
They can have offtopic conversations there, but when you reply to an existing off-topic conversation, you are attacked by a hoard of people who also obsess over semantics and absolutes, and apparently you are off-topic now because you gave examples to illustrate your point

@everyone 
The latest release is out `v0.6.1-alpha`. The playground at <https://qat.dev/playground> works very well now. Try it out!
https://github.com/qatlang/qat/releases/tag/v0.6.1-alpha

Made one minor change and the decrease in parser speed is now 20% from the previous 50%
![Syntax Change for if-else](image:7vyl6j0npz2b4e9)
Now `if` requires `=>` after the condition. The logic to peak tokens have been removed, since there is proper separation of logic

Syntax change for if-else and loops

`qat` will now be in a monthly release schedule. The current public version is `0.5.0-alpha`. The next version will add built-in optionals (maybe) and much more changes

Just solved a tragic issue in the compiler. The directory for output files were created using `fs::create_directory`, but it won't create the directory recursively, that is if the parent directories in the path doesn't exist, this throws error. In testing within the main repository I didn't face any issue since all parent directories existed, until I tried compiling the initial version of the standard library in a different folder altogether and got the error. I apologise if this caused serious issues in your initial experience of the language

Remember that for heap allocations & deallocations, there are the `own` & `disown` keywords

Added `--target` and `-t` parameters to the cli config to provide custom target triplets. Added `--sysroot` parameter to provide custom system root directory

There is a planned feature that lets the user choose whether to disable value semantics for a custom type.
This means that any expression of this type can only be used as a reference and cannot be loaded/passed as a value.
This is useful, when the reference to an instance should not be detached from the data

The issues in the windows toolchain of the compiler is way more than what I initially thought. The issues that are within the compiler is solved. But I am dealing with the requirements of WinMain and several other platform specific problems

Also the floating point issue that the compiler has had for months was fixed. But the fix is the most embarrassing thing in my lifetime. All allocas in LLVM were choosing f128 because there were no breaks in the switch that selected the different floating point types. But for constants, the type retrieval was correct. That was the issue

I got another job, 3 days in and quit again, so it is so stressful again now. Even with a roster of projects to showcase, because of the tech crash, hard to find any good offers.

Quit my new job

Added `bool` as a primitive type without introducing a new type in the IR system. `bool` is now a special case of the unsigned integer type

Glad that the issue has been fixed, nonetheless

Regions are in the ~~prototype~~ Implementation stage. Function to own data in a region is already complete. As of now, the lifetime of objects owned in a region starts when the object is created, and ends at the end of the program. So the destructor of objects in a region are called at the end of the program.

The implementation of regions are finally complete. The tests are successful. Now objects owned in the region in a function, will get automatically cleaned up at the end of the program (end of the main function). If it is a multi pointer, the destructor will be called for each instance. Otherwise only once.
**This a runtime functionality so objects owned in a region, no matter how big or small, will always be cleaned up at the end of the program**. As of now, qat doesn't have exit/abort functions or panics, but when it does, the region owned memory will be cleaned up in such cases too.

Currently `say` segfaults on windows because `printf` is not linked

Removed temporary path parameter in the CLI config. It was never that functional, and executables built in such a directory could never be executed if `qat run` was the command, so this is no more

There is also another variant of region in planning that gives more restricted lifetimes to its objects

Added `say'only` that doesn't append a newline to the output. For the following code,
```qat
say'only "Hello, world!".
say'only "Howdy".
say'only "Hi".
```
the output will be
```
Hello, world!HowdyHi
```
And for the following code,
```qat
say "Hello, world!".
say "Howdy".
say "Hi".
```
the output will be
```
Hello, world!
Howdy
Hi
```

Added `none` keyword that represents a none value for `maybe` types. This can be used inside expressions. A type can also be associated with this. If there is no explicit type mentioned, the type is inferred from the context.
```qat
new var k : maybe i64 = 7.
k = none.
k = 16.
k = none'<i64>.
```

`log` has been changed to `say'dbg` and now log is not a keyword

Added `maybe` type to the language IR that adds built-in support for optionals

I am also working on the website for qat, which is almost done, with a playground, examples, documentation and downloads section

The point of the lexer/parser speed was not only demonstrating the speed of the compiler, which I don't claim is the fastest as I truly don't know.
When I start working on qat, I was not familiar with C++20 and C++ in general. The C++11  learnt in school was not helpful and I had to learn the language from the beginning as I created the compiler.
I chose C++ as I wanted the best performance possible. I realise now that the person writing the code contributes to performance as much as the compiler does. But when I started, I was nooby and unaware. There were several instances where I reconsidered the choice of C++, and several incidents where I had lots of trouble with bugs and dev problems in general. But I persisted nonetheless.
Results like the above is like tiny capsules of joy that happens rarely during the dev cycle of such a project. So I wanted to share

Parser speedup, performance and the choice of C++ for the project

Whenever an implicit copy or move occurs, the user is warned about it, and asked to make the copy/move explicit. Making the copy/move explicit will make it identical to the implicit one.
```qat
var Vec'<str> list = default.
list'push("Hello world").
let var list2 = Vec'<str>{}.
let var list3 = list.
                ^^^^   // User is warned about implicit copy construction
list2 = list3.
        ^^^^^          // Copy assignment happens here and is warned
list3 = copy(list2)    // Explicit copy
list2 = move(list3)    // Explicit move
```

There is now an analyse option in the cli configuration that only does lexing, parsing and LLVM IR generation and analysis. This command will not compile the IR

Now, you can store functions as variables and also call function pointers
```qat
someFn() [
    say "This is some function".
]
main() [
    let #sFn = someFn. // Here, sFn is a pointer to someFn
    sFn().
]
```

Relative mentions, by the way is similar to relative paths.
```qat
type Square {
  pub u32 length.
}

box some {
  type SqTy = ..:Square. // This is a relative mention
  
  pub areaOfSquare -> u32
  (SqTy sq) [
    give sq'length * sq'length.
  ]
}
```

Signed & Unsigned Integer Literals are now responsive. In binary operations, assignment, local declaration, function call and member function calls, this is now supported.
Also added support for default values and null pointer in all the above AST representations.

I had a death in the family and was busy handling the funeral for the past 2 days. I am currently working on `future`, `async` & `await`

This is the copy & move constructors for the string datatype
```qat
copy other [
  if(other'length > 0_u64) [
    ''start = heap'get'<u8>(other'length).
    ''length = other'length.
    ''bufferLength = ''length.
    loop (''length) : alias I [
      ''start[I] = other'start[I].
    ]
  ] else [
    ''start = null.
    ''bufferLength = 0_u64.
    ''length = 0_u64.
  ]
]

move other [
  ''start = other'start.
  ''length = other'length.
  ''bufferLength = other'bufferLength.
  other'start = null.
  other'length = 0_u64.
  other'bufferLength = 0_u64.
]
```
other is the name of the existing value from which the values are copied or moved