It is very similar to Python, and has similar syntax to the language Cheddar, hence there are some clever tricks you can use in order to reduce your byte count. Let's get those cool tricks listed here. As usual, please post one tip per answer and avoid obvious things (e.g. remove spaces). If you have any further questions about any of the tips listed, there is a dedicated chat room for Proton.
Use currying when you need a lambda with 2 arguments
If you want a function with 2 arguments, currying syntax always saves 1 byte. For example:
Is one byte longer than:
The first function can be called with
f(number_1, number_2), whilst the latter is called using
Take advantage of the fun features: operator functions
(+) for all binary operators where the
+ is evaluates to a function that performs the exact same task as the operator itself. Where you'd use
int.__add__ when golfing in Python, use
(+) for many bytes saved.
Instead of using
range(lower_bound, upper_bound), use
lower_bound..upper_bound. For unary ranges, use
0..number instead of
range(number). Some examples:
Can be replaced by (-6 bytes):
Can be replaced by (-4 bytes):
Consider the following two:
You can use inline assignments (where you treat an assignment as an expression) in Proton. The value given will be the right side of the assignment. This can sometimes help you take off a few bytes; more the longer the repeated expression, and especially if it has brackets already (because you need the brackets around the expression).
Use point-free notation
Even though lambda notation has a much shorter overhead than Python (
lambda a:), point-free notation is still often shorter, where you define a function as a composition of other functions. For example, consider the following chain of golfing:
a=>b=>dict(a)[b] a=>dict(a).get dict+((.)&get)
The last one currently isn't any shorter than the second last, but it does become shorter in some cases, for example, this:
a=>b=>[dict(a).get(f)for f:b] a=>b=>map(dict(a).get,b) a=>map(dict(a).get) dict+((.)&get)+map
You can get some pretty short code with that.
a & b will return a function
*q => a(*q, b) if
a is a function and otherwise
*q => b(a, *q) if
b is a function, and
a + b will return a function
*q => b(a(*q)).