Tips for golfing in Proton

Proton is a quite new language created by PPCG user Hyper Neutrino.

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.

• To any potential close voters, tips questions are perfectly on-topic here. Commented Sep 14, 2017 at 14:08

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:

f=(a,b)=>a+b


Is one byte longer than:

f=a=>b=>a+b


The first function can be called with f(number_1, number_2), whilst the latter is called using f(number_1)(number_2).

Try it online!

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.

Use ..-ranges

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:

range(1,10)


Can be replaced by (-6 bytes):

1..10


And:

range(10)


Can be replaced by (-4 bytes):

0..10


Use inline-assignment

Consider the following two:

a=>(a+5)*2/(a+5)
a=>(b=a+5)*2/b


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 (a=> vs 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)).