jorbdehmel/oak

The Oak Programming Language. Oak is a modern, low-level, statically-typed translated programming language with extreme macro support, built-in packaging and building, and compile-time-modifiable language syntax. Oak's syntax modification makes it a powerful core for the construction of new programming languages.

Buy me a coffee

• @jorbDehmel, Jordan "Jorb" Dehmel.
• [email protected]
• Linux (Debian/Arch)
• Student of CompSci + pure math at Colorado Mesa University
• Currently doing undergraduate research in active matter physics, source code vulnerability analysis
• Experience in Python, C++, Java, Javascript, Rust, HTML/CSS, rmd, md, LaTeX, SQL, RegEx
• Experience creating 2D and 3D rendering engines, machine learning libraries, programming language translators
• Currently researching formal language theory, theoretical computer science

PFP via tuckerbudzyn on instagram

oak's Issues

Add ignored main files in non-entry point source files

Make it so that all main functions which are not
in the entry point file are ignored, and thus do
not cause errors. This would be useful for unit
testing.

Errors w/ implicit type casting reducing precision

acorn will select invalid function candidates which cause
loss of precision, leading to undefined behavior. This can
be solved by a refinement of the candidate selector or by
disallowing precision-lowering implicit casts.

Integrating method call notation

The current method call notation provided by the
std ruleset is broken and slow. This feature is
widely-used enough that it justifies integration into
the canonical syntax.

• Integrate method call notation
• Make method call notation work on nested objects (IE a.b.c.d())

Non-compatible with NixOS

I doubt you'll fix this issue but I wish I could use this on NixOS (via nix flake)

Can't find `std_oak_header.h`

Make traits tracked in the same way structs and enums are

Also add a where-is keyword- IE where t is hashable; <-> hashable<t>;

Bug (I assume) when writing if statement.

package!("std");
use_rule!("std");

let main() -> i32 
{
	let one: u8 = 1;
	if (one != to_u8(1) == false)
	{
		print("Worked!\n");
	}
}

Will compile.

package!("std");
use_rule!("std");

let main() -> i32 
{
	let one: u8 = 1;
	if ((one != to_u8(1)) == false)
	{
		print("Worked!\n");
	}
}

Will not compile.

`using namespace std` is bad practice.

Here's a post on why: https://stackoverflow.com/questions/1452721/why-is-using-namespace-std-considered-bad-practice

Add `mut` keyword for types

This would disambiguate the current const/mut typing situation, in which mutability is denoted via pointer.

• Add mut keyword
• Do checks for mut when attempting to change values

Is there an easy way to compile multiple files?

Is there any easy way to compile multiple files or do I have to write a build script manually?

Massive Memory Leak

// main.oak
package!("std");
use_rule!("std");

include!("linked_list.oak");

let main() -> i32
{
    0
}

// linked_list.oak
package!("std");
use_rule!("std");

let linked_list<t> = struct
{
    next: ^linked_list<t>,
    data: t
}

Causes a giant memory leak (4gb at least).

Add negation, incrementation and decrementation

In the past, unary operators have been avoided in Oak
because only a binary operator substitution pass was initially
written. This should be remedied. The following should be
added during the operation-substitution pass of compilation.

• Add negation operator (IE !a)
• Add increment operator (IE ++a)
• Add decrement operator (IE --a)

Efficiency boosts in `doFile`

The main operations on the input token stream are performed
when it is in a vector. This should be transitioned to a list
instead, for obvious efficiency reasons.