Tips for golfing in Jolf

Question

Jolf is a procedural golfing language made by @CᴏɴᴏʀO'Bʀɪᴇɴ.

What tips do you have for golfing in Jolf?

Please post one tip per answer.

These tips should be at least somewhat specific to Jolf, e.g. remove comments is an answer, but not a very good one.

Answer 1

JavaScript fall back

If for some strange reason Jolf isn't golfy enough, or simply cannot cope, it may be of use to use JavaScript eval. This can happen in one of two ways.

1. Designed eval

Anything inside of $...$ is literally carried over to the JS transpilation. For example, +3$~$5 transpiles to add(3, ~5). Equivalently, +3:~5.

2. Array eval

You can use JS arrays in Jolf! Mostly. It's kind of a bug, but I'm not going to fix it. For example:

u[3*5,5/6,(3+4)/5]

Transpiles to:

sum([2 * 3, 5 / 3, (3 + 4) / 5]);

Answer 2

Know your auto-assigning variables!

Jolf has many ways to "auto assign" variables. The standard one is γ, which takes the value of the next expression. Β is the same thing, but converts the next expression to a number.

Also, ζ (zeta) is a variable initialized to -1/12 (guess why), and can be re-assigned with Ζ (Zeta).

For example, let's say you want to compare I (the input string) to an operation over itself. For now, let's see if I + I = reverse(I + I). This is written as, conventionally:

=+II_+II

But this can be golfed down to:

=γ+II_γ

Answer 3

Use @

@ is a command that takes the next character in the source code and returns that character's code point. (For example, @X returns 88.) This is often very useful since you can express any number between 0 and 255 in two bytes.

Answer 4

Read the source

As of right now, there are a lot of undocumented things -- the mysterious m module among them, which has a lot of builtins. However, they do exist in the source, and it's really not hard to read once you get the hang of it, so read the source.

Answer 5

Increase Function Arity

Every function has an arity. For example, + has an arity of 2. If you want to (say) add 5 elements, you could use 5 +s... or do +θ12345. Specifically:

• θ incrases the arity of the function by 3.
• ~θ increases the arity of the parent function by 3. (So *+~θ345678 increases the arity of the * by 3)
• M increases the arity of the function by 2.
• ~M increases the arity of the parent function by 2.
• ; increases the arity of the function by 1.
• ~; increases the arity of the parent function by 1.
• η decreases the arity of the function by 1.
• ~η decreases the arity of the parent function by 1.
• \xad sets the arity of the parent function to the next character's charcode.

Answer 6

Take advantage of implicit input

If a function does not have enough arguments, it will look to the input for the remainder of the arguments. For example:

+uz

Would transpile to:

add(sum(unaryRange(x)), x)

It's equivalent to

+uzxx

Answer 7

Use o to store values

Similar to how other languages can assign variables for easy/short referencing, Jolf has o.

For example, oThx prints the input plus 1.

This is a useless example, but when the expression is more complicated than hx, it can save some serious byteage.

Also, v"var name"<val> allows for a multi-char variable name, and V"var name" gets a variable from the scope.

Thanks to Conor for explaining this to me, and giving the previous sentence.