Cursed Indentation Styles

What follows are a collection of cursed programming indentation code styles, because nothing is sacred.

Exponential Indentation

Start at 1 space in the sequence. Double the depth with each level of indentation.

This will naturally discourages nesting indentation too deeply.

#!/usr/bin/env python3
from itertools import cycle, count, islice

def fizzbuzz(turns):
 fizzbuzz_gen = (
  fizz + buzz or number
    for fizz, buzz, number
        in zip(
                cycle([""] * 2 + ["Fizz"]),
                cycle([""] * 4 + ["Buzz"]), 
                count(1)
        )
 )

 for i in islice(fizzbuzz_gen, turns):
  print(i)

if __name__ == "__main__":
 fizzbuzz(30)

If this is too intense of a growth rate for your project's indentation levels, consider instead using the Fibonacci sequence.

Semantic Indentation

Use spaces to indicate control flow. Use tabs to indicate values.

This simple trick leverages indentation to expand its use.

#!/usr/bin/env python3
from itertools import cycle, count, islice

def fizzbuzz(turns):
	fizzbuzz_gen = (
        fizz + buzz or number
            for fizz, buzz, number
                in zip(
					cycle([""] * 2 + ["Fizz"]),
					cycle([""] * 4 + ["Buzz"]), 
					count(1)
                )
	)

    for i in islice(fizzbuzz_gen, turns):
		print(i)

if __name__ == "__main__":
	fizzbuzz(30)

Literal String Indentation

Type out your control characters.

The advantage is there's nothing hidden as whitespace. Normally a programmer cannot possibly tell if code is indented using tabs or spaces. They require the use of an editor to investigate and figure it out. With this style, no tools are required. Hooray for improved readability!

#!/usr/bin/env python3
from itertools import cycle, count, islice

def fizzbuzz(turns):
[tab]fizzbuzz_gen = (
[tab][tab]fizz + buzz or number
[tab][tab][tab]for fizz, buzz, number
[tab][tab][tab][tab]in zip(
[tab][tab][tab][tab][tab]cycle([""] * 2 + ["Fizz"]),
[tab][tab][tab][tab][tab]cycle([""] * 4 + ["Buzz"]), 
[tab][tab][tab][tab][tab]count(1)
[tab][tab][tab])
[tab])

[tab]for i in islice(fizzbuzz_gen, turns):
[tab][tab]print(i)

if __name__ == "__main__":
[tab]fizzbuzz(30)

For convenience, an editor could automatically convert presses of the tab key into `[space][space][space][space]`.

Reverse Indentation

Finally a reason to use exclusively spaces. Right side indentation helps re-enforce a project style's line length limits.

Here, the maximum line length of 80 is obvious.

                                                         #!/usr/bin/env python3
                                     from itertools import cycle, count, islice

                                                           def fizzbuzz(turns):
                                                           fizzbuzz_gen = (    
                                                  fizz + buzz or number        
                                             for fizz, buzz, number            
                                                        in zip(                
                            cycle([""] * 2 + ["Fizz"]),                        
                            cycle([""] * 4 + ["Buzz"]),                        
                                               count(1)                        
                                                              )                
                                                                          )    

                                      for i in islice(fizzbuzz_gen, turns):    
                                                               print(i)        

                                                     if __name__ == "__main__":
                                                               fizzbuzz(30)    

Trailing Indentation

Indentation is placed at the end of the previous line instead of at the start of the current line. This is more inclusive to right-to-left programming languages.

#!/usr/bin/env python3
from itertools import cycle, count, islice

def fizzbuzz(turns):
fizzbuzz_gen = (    
fizz + buzz or number        
for fizz, buzz, number            
in zip(                
cycle([""] * 2 + ["Fizz"]),                        
cycle([""] * 4 + ["Buzz"]),                        
count(1)                        
)                
)    

for i in islice(fizzbuzz_gen, turns):    
print(i)        

if __name__ == "__main__":
fizzbuzz(30)    

Commented Indentation

Since semantic comments are now apparently fine (Python), we can begin using them to define more about our programs. This level of clear and precise communication will greatly improve productivity in the corporate environment.

#!/usr/bin/env python3
from itertools import cycle, count, islice  # indentation: 0
                                            # indentation: 0
def fizzbuzz(turns):                        # indentation: 0
fizzbuzz_gen = (                            # indentation: 1
fizz + buzz or number                       # indentation: 2
for fizz, buzz, number                      # indentation: 3
in zip(                                     # indentation: 4
cycle([""] * 2 + ["Fizz"]),                 # indentation: 5
cycle([""] * 4 + ["Buzz"]),                 # indentation: 5
count(1)                                    # indentation: 5
)                                           # indentation: 4
)                                           # indentation: 1
                                            # indentation: 0
for i in islice(fizzbuzz_gen, turns):       # indentation: 1
print(i)                                    # indentation: 2
                                            # indentation: 0
if __name__ == "__main__":                  # indentation: 0
fizzbuzz(30)                                # indentation: 1

Descriptive Indentation

Each line is a description of what depth the line's indentation should be. Think of it as semantic sugar for commented indentation.

#!/usr/bin/env python3
<0>from itertools import cycle, count, islice
<0>
<0>def fizzbuzz(turns):
<1>fizzbuzz_gen = (
<2>fizz + buzz or number
<3>for fizz, buzz, number
<4>in zip(
<5>cycle([""] * 2 + ["Fizz"]),
<5>cycle([""] * 4 + ["Buzz"]),
<5>count(1)
<2>)
<1>)
<0>
<1>for i in islice(fizzbuzz_gen, turns):
<2>print(i)
<0>
<0>if __name__ == "__main__":
<1>fizzbuzz(30)

An implementation of this could be xml-based to enhance portability.