Using unicode characters inside functions to improve readability

[namurphy]

Python 3 has gone full unicode, and it's valid to use a wide range of alphanumeric unicode characters in object names:

>>> β = 5

Typing in unicode characters is kind of a pain. Well, a big pain...unless you're like me and memorize the unicode characters for en dashes (–, U+2013), em dashes (—, U+2014), and ń (U+0144) because I got tired of having to copy and paste them. So, we don't want to have unicode characters in the names of functions or arguments that users would have to interface with.

But using unicode characters for standard plasma symbols internally could at times make our code a lot more readable, in particular for code that is read a lot more times than it is written. If we have a variable named beta, it would likely be more readable to use β instead.

The best option for variable names is often to use the name of the concept, but this can lead to really long and messy equations that are difficult to check against the original source. When we have complicated equations, using unicode characters would probably clean things up...especially if we copy an equation verbatim from the original text.

[rocco8773]

Honestly, I think unicode for representing variables in code is a royal pain and should be avoided. It's a lot easier for me to write beta than it is for me to search out the unicode and implement β. (e.g. just writing this example was a pain) I also don't feel like beta significantly hinders the readability. I would also extend this sentiment when it comes to writing code blocks,

>>> beta
>>> # versus
>>> β

in docstrings.

However, when it comes to writing core documentation I have no problem with using unicode. For example, out of respect, I prefer to write Alfvén instead of Alfven in the docstrings.

[namurphy]

For a single character it doesn't make much of a difference in readability, but there are times when it can make a difference when representing math in code...in particular when you're coding in an equation from a book. There's

>>> p = rho ** gamma  # looks like code

vs.

>>> p = ρ ** γ  # looks like math!

The difference will be greater as the equations get more and more complicated...though for short equations like this, I'd probably write it as

>>> pressure = mass_density ** heat_capacity_ratio  # minimizes chance of confusion

I think my main point is that we should be open to this as a possibility that could at times improve the readability of code, in particular for stable mathematical code that's going to be read a lot more often than it is written.

[StanczakDominik]

I've warmed to this possibility with time, and would be okay with it for dense formulas and internal code; probably not anything user facing for now. I'll note that my new viewpoint is completely based on how easy it is to get vim and Jupyter to do it, so I can completely understand @rocco8773's skepticism if pycharm does not support it.

[namurphy]

Agreed, definitely not in anything user-facing! At the very least, not until/unless ways to do this become easier and much more commonplace.

[namurphy]

Oh...and when we're using Jupyter notebooks or ipython, we can type \beta, press tab, and then get β. I'm curious if there's something like that in PyCharm or other IDEs...

[StanczakDominik]

I've seen https://github.com/JuliaEditorSupport/julia-vim/#latex-to-unicode-substitutions accomplish that in Vim. I wouldn't know about PyCharm, though.

[StanczakDominik]

https://plugins.jetbrains.com/plugin/10413-julia seems to be accomplishing that, based on a quick glance!