Given a module that imports code from another module, and public types (or functions) using that type, e.g.

import gleam/otp/node.{Node}
import gleam/otp/actor.{StartError}

pub type ApplicationStartMode {
  Normal
  Takeover(Node)
  Failover(Node)
}

pub fn worker(
  start: fn(argument) -> Result(Sender(msg), StartError),
) -> ChildSpec(msg, argument, argument) {
// ...

Support rust style attributes;

#[hello]
fn test() {
}

#[hello]
struct Foo {
}

This will be invoked as macros with the ast of the thing that it annotates as input, and anything produced by the macro will be appended to the source (to work the same as Rust procedural macros).

• Implement parsing (#83).
• Add compiler support to process attributes.

Implementa

At some point we should probably upgrade the argument parser to use nom version 5. They got rid of most of the macro magic. I am not familiar with nom (although interested), but there is an upgrade guide that should hopefully make the transition a bit more smooth: https://github.com/Geal/nom/blob/master/doc/upgrading_to_nom_5.md

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:

In quite a few places in the code, you have panic!() or unwarp(). This is frowned upon in the Rust community. We should have dedicated error types instead

Currently we can use any reserved word/token (such as var, if, etc) as identifier in naskah which won't be valid JS. The simplest thing we can do is add underscore before printing the identifier if it's a reserved word in JS

So that:

misal x = 3;
misal var = 2;

jika while benar {
} 

should be compiled to

var x = 3;
var _var = 2;

if (_while == true) {
}

It was originally something else (don't really remember what), but now it's just a thin wrapper around Ast, and it does nothing but get in the way. There's a lot of random converting back and forth between Ty and Ast currently that would get deleted in the process.