== Why Python can't have a full equivalent of Go's _gofmt_

I mentioned in passing [[here EmacsPythonAutoindentBug]] that people
are working on Python equivalents of Go's _gofmt_ and since then
I've played around a bit with [[yapf https://github.com/google/yapf]],
which was the most well developed one that I could find. Playing
around with _yapf_ (and thinking more about how to deal with [[my
Python autoindent problem EmacsPythonAutoindentBug]]) brought home
a realization, which is that Python fundamentally can't have a full,
true equivalent of _gofmt_.

In Go, you can be totally sloppy in your pre-_gofmt_ code; basically
anything goes. Specifically, *you don't need to indent your Go code
in any particular way or even at all*. If you're banging out a quick
modification to some Go code, you can just stuff it in with either
completely contradictory indentation or no indentation at all. More
broadly, you can easily survive an editor with malfunctioning
auto-indentation for Go code. Sure, you code will look ugly before
you _gofmt_ it, but it'll still work.

With Python, you can't be this free and casual. Since indentation
is semantically meaningful, you must get the indentation correct
right from the start; you can't leave it out or be inconsistent. A
Python equivalent of _gofmt_ can change the indentation level you
use (and change some aspects of indentation style), but it can't
add indentation for you in the way that _gofmt_ does. This means
that malfunctioning editor auto-indent is quite a bit more damaging
(as is not having it at all); since indentation is not optional,
you must correct or add it by hand, all the time.  In Python, either
you or your editor are forced to be less sloppy than you can be in
Go.

(Sure, Go requires that you put in the _{_ and _}_ to denote block
start and end, but those are easy and fast compared to getting
indentation correct.)

Of course, you can start out with minimal, fast to create indentation;
Python will let you do one or two space indents if you really want.
But once you run _yapf_ on your initial code, in many cases you're
going to be stuck matching it for code changes. Python will tolerate
a certain amount of indentation style mismatches, but not too much
(Python 3 is less relaxed here than Python 2). Also, I'm confident
that I don't know just how much sloppiness one can get away with
here, so in practice I think most people are going to be matching
the existing indentation even if they don't strictly have to. I
know that I will be.

I hadn't thought about this asymmetry before my editor of choice
started not getting my Python auto-indentation quite right, but
it's now rather more on my mind.