wu-lang / wu

🐉 A practical game and data language

Wu

An expression oriented, gradually typed and mission-critical programming language.

Syntax

A full walk-through of the language can be found over at the wu-lang documentation.

Details

Wu strives to be a decently useful language with focus on control, readability and scalability. The syntax of Wu is heavily inspired by the strong and safe one of Rust, while keeping the advantages of being high-level and gradually typed. The language is meant and designed to be a solid alternative to Python, Lua and MoonScript, while being superior on control and maintainability.

Example

Selling points

• Compiles to Lua
• Gradual typing
• Rust-like trait system
• Expression oriented design
• Perfect Lua interoperability
• Match patterns
• Cool logo
• You are using it

Libraries

• lover: Type-safe bindings for the Love2D game engine.
• std: Wrapper for the Lua standard library.

Disclaimer

Wu is built and maintained by a minimal team of people and was primarily developed during boring primary school classes, to help make time pass faster. At the current point in time it is not actively maintained due to work and studies all of us are occupied with, this may change in the future. However, you can still make suggestions, report bugs and open pull requests, one of us will definitely review them.

Contributors

• nilq

• evolbug

• fuzzylitchi

License

MIT License

wu's Issues

[bug] trait implementation failure

Trait implement does not seem to accept user types in signatures

Data: struct {}
Data_T: trait {
    clone: fun(self) -> Data
}
implement Data: Data_T {
    clone: extern fun(self) -> Data
}

error:

wrong: expected implemented type `fun() -> deid(Data)` for `clone`
     --> main.wu
      │
    5 │ implement Data: Data_T {
      │           ^^^^

[bug] import still doesn't behave predictably

When compiling imports should behave by this system:

compile file:       all imports are relative to initial file
compile directory:  all imports are relative to initial directory
build project:      all imports are relative to src/

The resulting require statements should also use . to separate path elements instead of / and should not contain a ./ prefix

project/
    src/
        lib/
            init.wu
            mylib.wu
        main.wu
    wu.toml

Contents:

# main.wu
import lib { mylib }

# init.wu
import mylib { MyType }

# mylib.wu
MyType: struct {}

Building project: ~/project$ wu build
Expected contents:

-- main.wu
local lib = require "lib"
local mylib = lib["mylib"]

-- init.wu
local mylib = require "lib.mylib"

-- mylib.wu
<empty>

Building directory: ~/project$ wu src/lib
Expected contents:

-- init.wu
local mylib = require "mylib"

-- mylib.wu
<empty>

Building file: ~/project$ wu src/lib/init.wu
Expected contents:

-- init.wu
local mylib = require "mylib"

-- mylib.wu
<empty>

[bug] extern module generates an invalid variable stub

love: extern module {}

generates

local love =
return { love=love }

Expected result: no code is generated

[feature] visibility classifiers

Currently every symbol in a module is exported. Symbols should become private by default and export classifiers should be implemented, to be able to hide certain details.

Example:

bar: module {
    pub foo: fun() -> int { 42 }
        oof: fun() -> int { 24 }
}

a := bar foo() # 42
b := bar oof() # error: accessing private function <oof>

# bar.wu
pub foo: fun() -> int { 42 }
    oof: fun() -> int { 24 }

# main.wu
import bar { foo, oof } # error: importing private function <oof>

# main.wu 2
import bar

bar oof() # error: accessing private function <oof>

Consider updating the readme?

It hasn't been changed in over two years. To quote it:

Wu is built and maintained by a minimal team of people and was primarily developed during boring primary school classes, to help make time pass faster. Currently being maintained by an 18-year-old.

I think "currently being maintained by an 18-year-old" sounds very weird in a github repository. Are we meant to treat it as a request to not use it for anything serious? If we are, that's in contradiction with tongue-in-cheek You are using it on the selling points list just above it.
It's the kind of remark that could only hurt adoption of the project, imho. Not to mention that it's not even true anymore since time (sadly) doesn't stay constant. I'd suggest dropping that whole disclaimer altogether, the language works, it's irrelevant how it came to be ^^

REPL for wu

Just like lua has its own REPL(read-eval-print-loop), as in example below:

bash% lua
Lua 5.4.2 Copyright (C) 1994-2020 Lua.org, PUC-Rio

print("hi")
hi

function f1(x)

print("hi")
end

f1()
hi

---

In the same way please implement REPL for wu

Github sponsor issue

Hi,

I was trying to sponsor this very neat project but got prompted with an error

I think the funding.yml is missing a few required fields:

github: [octocat, surftocat]
patreon: octocat
tidelift: npm/octo-package
custom: ["https://www.paypal.me/octocat", octocat.com]

Compile to LuaJIT bytecode?

For speed!

If you think this is is something you can take on, let's talk!

Capitalization

Even though my english isn't that good, I still appreciate if beginning of sentences etc are capitalized. Makes everything a lot easier to read.

add thread type

lua has a thread type, but wu seems to not have one

[feature] Enums

Enums will be simple. My current idea is to have something like the following:

import enemies { Enemy }

Weapon: enum {
  Gun
  Swordfish
  Fist
}

damage_enemy_with: fun(enemy: Enemy, weapon: Weapon) {
  switch weapon {
    Weapon Gun => enemy damage(100)
    Weapon Swordfish => enemy damage(9000)
    Weapon Fist => enemy damage(10)
  }
}

Again; very simple. :)

[compiler] Lua imports don't have relative path.

When importing things in Wu, the output require in the Lua code should use the proper path relative to where the compiler is run.

Cannot import file within the same folder, only from $WU_HOME

I don't know if it's they way it is intended to be, but I expected to be able to import a file from the same folder which the file I'm compiling resides in, but instead I got an error saying that there's no such module. But, if I set $WU_HOME to a directory somewhere and copy the file I'm importing to this folder, it compiles.
Is it intended to work this way, by only importing from $WU_HOME, or is it a bug? I'll copy here some of my terminal output

garcias@PHANTOM:~/src/wu-test$ ls
font  main.wu  wumodule.wu
garcias@PHANTOM:~/src/wu-test$ wu main.wu
Compiling main.wu

wrong: no such module `wumodule`, needed either `wumodule.wu`, `wumodule/init.wu` or in `$WU_HOME`
     --> main.wu
      │
    1 │ import wumodule { ten }
      │ ^^^^^^^^^^^^^^^^^^^^^^^
  Finished things in 0ms
garcias@PHANTOM:~/src/wu-test$

main.wu

import wumodule { ten }

wumodule.wu

ten := 10

Also, neither creating a directory called wumodule and putting a init.wu inside works, only inside $WU_HOME

[bug] trait parse failures

Trait body fails to parse if there's an additional newline or comment

Data_T: trait {

    getFFIPointer:  fun(self) -> any
}

error:

wrong: expected `Identifier`, found `EOL`
thread 'main' panicked at 'byte index 1 is out of bounds of ``', /home/evol/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/src/libcore/str/mod.rs:1920:47
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
     --> main.wu

Data_T: trait {
    getFFIPointer:  fun(self) -> any
    #asd

}

error:

wrong: expected `Identifier`, found `EOL`
thread 'main' panicked at 'byte index 9 is out of bounds of `    #asd`', /home/evol/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/src/libcore/str/mod.rs:1920:47
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
     --> main.wu

Wu needs the non-stable channel of rust?

The intro documentation just mentions having rust and just running the cargo install. However, you need to be on the rust nightly/beta(?) branch I think. I get the following message on the stable release channel.

error[E0554]: #![feature] may not be used on the stable release channel
 --> src\lib.rs:1:1
  |
1 | #![feature(i128)]
  | ^^^^^^^^^^^^^^^^^

error[E0554]: #![feature] may not be used on the stable release channel
 --> src\lib.rs:2:1
  |
2 | #![feature(i128_type)]
  | ^^^^^^^^^^^^^^^^^^^^^^

error: aborting due to 2 previous errors

Just figured I would let you know ;). Cool language btw!

[bug] implement parse failures

Several failures:

• block is ignored if there is a keyword between two user types

Test: struct {}
implement Test if Test {}

• parse fails if there's a newline in implement block body but no method

Test: struct {}
implement Test: Test {
}

• implement accepts Type in place of Trait

Test: struct {}
implement Test: Test {
    foo: fun() {}
}

• parse fails if there's extraneous newlines after method

implement Data: Data_T {
    clone:          extern fun(self) -> Data

}

[improve] Steroids for the type system

Wu should have sum types as well as interface-like type parameters. This will speed up the development process, while also making it even more fun and nice to use the language:

Cat: struct {
  weight: float
}

Dog: struct {
  hat: bool
}

dog_or_cat: Cat | Dog = new Cat {
  weight: 1000
}

# can later be Dog

Then the following:

Vector3: struct {
  x: float, y: float, z: float
}

Vector2: struct {
  x: float, y: float
}

move2D: fun(thing: { x: float, y: float}, dx: float, dy: float) {
  thing x += dx
  thing y += dy
}

how to escape quotes in a string?

i have some code, that looks like this:

print("something \"something\" something else")

but when i compile i get this error:

Compiling init.wu

wrong: bumped into weird character
     --> ./init.wu
      │
    1 │ print("something \"something\" something else")
      │                             ^
  Finished things in 0ms

how can i fix the code?

[feature] Wildcard in imports

This is something we need to have. While it does have some downsides in introducing bad practice behavior, it's pretty useful.

Given lib.wu with the following content:

bob := "BUILDER"
important_number: float = 100.0

The following otherfile.wu ...

import lib { * }

Should automatically generate the following import code in otherfile.lua:

local lib = require('lib')
local bob = lib['bob']
local important_number = lib['important_number']

iter() doesnt works/exists

As said in the title. iter() doesnt works.

conte := ["undertale", "underale"]
for x in iter(conte) {
    std print(conte)
}

Returns:

wrong: can't seem to find `iter`
     --> ./definitions.wu
      │
   32 │ for x in iter(conte) {
      │          ^^^^

[bug] symbol imports are not exported like module imports

Attempting to use Object from love results in an error

# love/types.wu
Object: struct {}

# love/init.wu
import types { Object }

# main.wu
import love

asd : fun() -> love Object {
    new love Object {}
}

error:

wrong: no such module member `Object`
     --> main.wu
      │
    3 │ asd : fun() -> love Object {
      │                     ^^^^^^

[improve] Even better error messages

While the current error messages are good, there is a lot of space for improvement. The error message system should be improved, either by hand or by plugging in something like Codespan.

The new errors should be helpful to the degree of Elm, and easily overviewed to the degree of Rust.

Let's get this.

[visitor] False-positive implicit return in if-expressions

The visitor is marking expressions at the end of if-expressions as implicit returns, even if it isn't the real last expression of the root block.

import lover { grahics }

foo: fun -> int {
  if false {
    # returns here
    graphics setColor(1, 1, 0)
  }

  if true {
    # properly inserts return here too
    200
  }
}

[question] how does the syntax for arrays look?

how does the syntax for arrays look? couldn't find in documentation or examples

how to let the compiler know, that a function exists

hey, i wanna develop dynamic redbean applications with wu. is there a way to let the compiler know a function exists without providing an implementation that will be compiled?

wu.toml not working properly?

I have a wu.toml file like this:

but i get:

Am I meant to use it this way?

[todo] Document the codebase and set up proper tests

Title says it all. Let's go.