GOOD ON YA as increment statement:

I RECKON x = 0;
GOOD ON YA x;
GIMME x;
// Output is 1

PULL YA HEAD IN as decrement statement:

I RECKON x = 1;
PULL YA HEAD IN x;
GIMME x;
// Output is 0

I would expect these to be pre-inc/decrements, where that's relevant

Urgently needs a fix in the GimmeTime function. The sample program time.aussie:

G'DAY MATE!

IMPOHT ME FUNC GimmeTime;

GIMME "the time in sydney is: " + GimmeTime();

produces

the time in sydney is: 10/30/2021, 12:14:29 AM

If I get a chance this weekend I'll have a look at the source and submit a patch.

Inspired by the suggestion in #1 of ComeInSpinner as an alias for ChuckSomeDice, I've written a small example module that demonstrates pattern matching to figure out the result of a two-up coin toss, returning Tails, Heads, or Odds depending upon the values supplied.

With apologies to @timshepherd-academy for mangling his suggestion! 😆

Please double-check and correct my syntax as necessary, this was written in the text editor and I haven't actually tried to compile it.

Right now, both „ and " are valid in upside-down mode, while only the latter are valid in rightside-up mode.

Relatedly, examples/upsidedown.aussie needs to be changed.

This example code:

I RECKON x IS A WALKABOUT FROM [0, 100) <
	GIMME x;
>

Fails with the following errors:

OI MATE! EXPECTED to BUT GOT ','
EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ','
OI MATE! EXPECTED ; BUT GOT ')'
EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ')'

Perhaps a mistyped variable name should give a more readable error message than this?

thread 'main' panicked at 'Unable to resolve var: Var { ident: Ident { name: "h", line: 11 }, scope_distance: 4294967295 }', src/resolver.rs:211:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Hitting "Run" a second time without fixing the issue also yields the thread panicked while panicking. error mentioned in #16.

This short program, which should print nothing:

G'DAY MATE!

I RECKON i IS A WALKABOUT FROM [1 TO 7] <
>

CHEERS C***!

Instead prints:

EXpr is: ExprNode { expr: Literal(Number(7.0)), line: 3 }

G'DAY MATE!

// declare function `f()`
THE HARD YAKKA FOR f IS () <
    GIMME "No args";
>

// intended to be an overload, ends up being a silent redefinition
THE HARD YAKKA FOR f IS (x) <
    GIMME x;
>

f(); // <- OI MATE, CAN YA FUCKIN' COUNT?? EXPECTED 1 ARGUMENTS BUT GOT 0

CHEERS C***!

That feels like the wrong error for that context. If the language doesn't support overloading, you shouldn't be able to redefine a function with the same name.

Apparently ChuckSomeDice really doesn't like non-integers, as this code:

G'DAY MATE!
IMPOHT ME FUNC ChuckSomeDice;
ChuckSomeDice(0, 0.5);
CHEERS C***!

outputs the following error:

thread 'main' panicked at 'cannot sample empty range', /Users/zackradisic/.cargo/registry/src/github.com-1ecc6299db9ec823/rand-0.8.4/src/rng.rs:134:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

For the following program:

G'DAY MATE!

GIMME 5 + "foo";
GIMME "foo" + 5;
GIMME "" + 5 + "foo";

CHEERS C***!

I would expect this output:

5foo
foo5
5foo

However, the actual output is:

foo5
foo5
5foo

This program:

G'DAY MATE!

YA RECKON x IS A <
    y ~ BAIL NAH, YEAH!;
    z ~ GIMME z;
>

CHEERS C***!

Gives the expected errors:

[line 5] TOO MANY DEFAULT BRANCHES IN MATCH STATEMENT, YA DAFT BUGGER
[line 6] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT '>'

However, if you change it from z to other:

G'DAY MATE!

YA RECKON x IS A <
    y ~ BAIL NAH, YEAH!;
    other ~ GIMME other;
>

CHEERS C***!

It now gives a much more confusing error message:

[line 8] OI MATE! EXPECTED [Number(420.0), String("any string literal"), True, False, BuggerAll, Ident("any identifier")] BUT GOT 'EOF'

Should we consider bitwise operators? I imagine << and >> will run into parsing issues, but |, &, ^, and ~ should be doable. Alternatively, we could use words for all six. (I have no suggestions for what.)

Why does !0 == !1? They both evaluate to YEAH, NAH! which doesn't make sense to me. Typically, 0 corresponds to one boolean and all other integers to the other. This isn't always completely accurate -- for example, Objective-C does this mod 256 -- but I'd say it's pretty uncontroversial that 0 and 1 should have different boolean values.

Should we have literals for NaN and Infinity? It is possible to get them (0 / 0 and 1 / 0 respectively) but I'd prefer them to have names. They currently print as NaN and inf respectively, so if we give them names then the string conversion has to be updated to match.

The syntax highlighting shows literals like 1e9 as if they're numbers, but they don't work: OI MATE! EXPECTED ; BUT GOT 'e9'. It would be nice to be able to express large or small numbers using scientific notation, or have an exponentation operation (like pow() or **) -- preferably both.

I noticed here that you appear to have chosen an MIT license for the website. It's also wise to add a LICENSE to the repository to disambiguate and clearly document the license in use; people are much more likely to contribute to (or use) projects that have a clear licence that they understand.

GitHub allows for you to do this easily 👍 Alternatively, if the MIT license wasn't an active choice, it's worth considering what license might suit, for example https://choosealicense.com/ and other similar sites might be of help. 😊