Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Chelsea Voss - Oneliner-izer: An Exercise in Co...

Chelsea Voss - Oneliner-izer: An Exercise in Constrained Coding

We'll describe the ideas and implementation behind Oneliner-izer, a "compiler" which can convert most Python 2 programs into one line of code. As we discuss how to construct each language feature within this unorthodox constraint, we'll explore the boundaries of what Python permits and encounter some gems of functional programming – lambda calculus, continuations, and the Y combinator.

https://us.pycon.org/2016/schedule/presentation/2219/

PyCon 2016

May 29, 2016
Tweet

More Decks by PyCon 2016

Other Decks in Programming

Transcript

  1. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Oneliner-izer An Exercise in Constrained Coding Chelsea Voss [email protected] May 31, 2016 Chelsea Voss PyCon 2016 Oneliner-izer
  2. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Writing one-liners Python Bee. Chelsea Voss PyCon 2016 Oneliner-izer
  3. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Writing one-liners Python Bee. Write a function f that takes in a string s and returns True only if that string is composed of the characters 'A' and 'a'. Chelsea Voss PyCon 2016 Oneliner-izer
  4. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Writing one-liners Python Bee. Write a function f that takes in a string s and returns True only if that string is composed of the characters 'A' and 'a'. def f(s): for char in s: if char != 'a' and char != 'A': return False return True Chelsea Voss PyCon 2016 Oneliner-izer
  5. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Writing one-liners Python Bee. Write a function f that takes in a string s and returns True only if that string is composed of the characters 'A' and 'a'. def f(s): for char in s: if char != 'a' and char != 'A': return False return True More fun: solving these in one line. Chelsea Voss PyCon 2016 Oneliner-izer
  6. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Writing one-liners Python Bee. Write a function f that takes in a string s and returns True only if that string is composed of the characters 'A' and 'a'. def f(s): for char in s: if char != 'a' and char != 'A': return False return True More fun: solving these in one line. f = lambda s: False not in [char in 'Aa' for char in s] Chelsea Voss PyCon 2016 Oneliner-izer
  7. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Writing one-liners Python Bee. Write a function f that takes in a string s and returns True only if that string is composed of the characters 'A' and 'a'. def f(s): for char in s: if char != 'a' and char != 'A': return False return True More fun: solving these in one line. f = lambda s: False not in [char in 'Aa' for char in s] f = lambda s: all([char in 'Aa' for char in s]) Chelsea Voss PyCon 2016 Oneliner-izer
  8. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Writing one-liners Python Bee (2). Estimate π by sampling 100000 random points in the square [0,1] × [0,1] and determining whether they lie in the unit circle centered at (0, 0). Chelsea Voss PyCon 2016 Oneliner-izer
  9. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Writing one-liners Python Bee (2). Estimate π by sampling 100000 random points in the square [0,1] × [0,1] and determining whether they lie in the unit circle centered at (0, 0). def pi(): ... Chelsea Voss PyCon 2016 Oneliner-izer
  10. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Writing one-liners Python Bee (2). Estimate π by sampling 100000 random points in the square [0,1] × [0,1] and determining whether they lie in the unit circle centered at (0, 0). def pi(): ... ...or... pi = lambda: sum(1 for t in xrange(100000) if math.sqrt(random.random()**2 + random.random()**2) <= 1) * 4.0 / 100000 Chelsea Voss PyCon 2016 Oneliner-izer
  11. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Writing one-liners Python Bee (2). Estimate π by sampling 100000 random points in the square [0,1] × [0,1] and determining whether they lie in the unit circle centered at (0, 0). def pi(): ... ...or... pi = lambda: sum(1 for t in xrange(100000) if math.sqrt(random.random()**2 + random.random()**2) <= 1) * 4.0 / 100000 ...Can we rewrite any Python code as a one-liner? Chelsea Voss PyCon 2016 Oneliner-izer
  12. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge Can we rewrite any Python code as a one-liner? Chelsea Voss PyCon 2016 Oneliner-izer
  13. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge Can we rewrite any Python code as a one-liner? Technically, yes. x = MyClass(47) result = x.method() print result [...] → exec "x = MyClass(47)\nresult = x.method()\n[...]" Chelsea Voss PyCon 2016 Oneliner-izer
  14. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge Can we rewrite any Python code as a one-liner? Technically, yes. x = MyClass(47) result = x.method() print result [...] → exec "x = MyClass(47)\nresult = x.method()\n[...]" x = MyClass(47); result = x.method(); print result [...] Chelsea Voss PyCon 2016 Oneliner-izer
  15. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge Can we rewrite any Python code as a one-liner? Technically, yes. x = MyClass(47) result = x.method() print result [...] → exec "x = MyClass(47)\nresult = x.method()\n[...]" x = MyClass(47); result = x.method(); print result [...] But that’s no fun! Chelsea Voss PyCon 2016 Oneliner-izer
  16. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge More fun: computing with Python expressions. Some tools: Chelsea Voss PyCon 2016 Oneliner-izer
  17. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge More fun: computing with Python expressions. Some tools: List comprehension. >>> lst = [-2, -1, 0, 1, 2, 3, 4] >>> [i * 10 for i in lst if i > 0] [10, 20, 30, 40] Chelsea Voss PyCon 2016 Oneliner-izer
  18. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge More fun: computing with Python expressions. Some tools: List comprehension. >>> lst = [-2, -1, 0, 1, 2, 3, 4] >>> [i * 10 for i in lst if i > 0] [10, 20, 30, 40] Lambda expression. >>> f = lambda x: x * 10 >>> f(10) 4 Chelsea Voss PyCon 2016 Oneliner-izer
  19. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge Rules Chelsea Voss PyCon 2016 Oneliner-izer
  20. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge Rules One line: no newlines. No semicolons, either. No exec or similar. Chelsea Voss PyCon 2016 Oneliner-izer
  21. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge Rules One line: no newlines. No semicolons, either. No exec or similar. Goal: Implement any Python feature as a Python expression, ideally by abusing lambda and list comprehensions as much as possible. Chelsea Voss PyCon 2016 Oneliner-izer
  22. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge Rules One line: no newlines. No semicolons, either. No exec or similar. Goal: Implement any Python feature as a Python expression, ideally by abusing lambda and list comprehensions as much as possible. Yes, this is terrible. Chelsea Voss PyCon 2016 Oneliner-izer
  23. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge Rules One line: no newlines. No semicolons, either. No exec or similar. Goal: Implement any Python feature as a Python expression, ideally by abusing lambda and list comprehensions as much as possible. Yes, this is terrible. Takeaways: Chelsea Voss PyCon 2016 Oneliner-izer
  24. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge Rules One line: no newlines. No semicolons, either. No exec or similar. Goal: Implement any Python feature as a Python expression, ideally by abusing lambda and list comprehensions as much as possible. Yes, this is terrible. Takeaways: This challenge is solvable. Chelsea Voss PyCon 2016 Oneliner-izer
  25. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge Rules One line: no newlines. No semicolons, either. No exec or similar. Goal: Implement any Python feature as a Python expression, ideally by abusing lambda and list comprehensions as much as possible. Yes, this is terrible. Takeaways: This challenge is solvable. Lambda calculus! Obscure Python features! Chelsea Voss PyCon 2016 Oneliner-izer
  26. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge Rules One line: no newlines. No semicolons, either. No exec or similar. Goal: Implement any Python feature as a Python expression, ideally by abusing lambda and list comprehensions as much as possible. Yes, this is terrible. Takeaways: This challenge is solvable. Lambda calculus! Obscure Python features! Oneliner-izer is a compiler that implements these. Chelsea Voss PyCon 2016 Oneliner-izer
  27. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler The Challenge Rules One line: no newlines. No semicolons, either. No exec or similar. Goal: Implement any Python feature as a Python expression, ideally by abusing lambda and list comprehensions as much as possible. Yes, this is terrible. Takeaways: This challenge is solvable. Lambda calculus! Obscure Python features! Oneliner-izer is a compiler that implements these. Not for use as a software engineering paradigm. Chelsea Voss PyCon 2016 Oneliner-izer
  28. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Overview 1 The Challenge 2 Simple Code Blocks 3 Control Flow 4 Beyond 5 Building the Compiler Chelsea Voss PyCon 2016 Oneliner-izer
  29. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Simple Code Blocks Convert this into a single line? x = 1 y = x + x z = y + y print z + z Chelsea Voss PyCon 2016 Oneliner-izer
  30. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Simple Code Blocks Convert this into a single line? x = 1 y = x + x z = y + y print z + z Won’t work: (exponential blowup) print (1 + 1) + (1 + 1) + (1 + 1) + (1 + 1) Chelsea Voss PyCon 2016 Oneliner-izer
  31. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Simple Code Blocks Convert this into a single line? x = 1 y = x + x z = y + y print z + z Won’t work: (exponential blowup) print (1 + 1) + (1 + 1) + (1 + 1) + (1 + 1) Answer. Chelsea Voss PyCon 2016 Oneliner-izer
  32. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Simple Code Blocks Convert this into a single line? x = 1 y = x + x z = y + y print z + z Won’t work: (exponential blowup) print (1 + 1) + (1 + 1) + (1 + 1) + (1 + 1) Answer. print (z + z) Chelsea Voss PyCon 2016 Oneliner-izer
  33. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Simple Code Blocks Convert this into a single line? x = 1 y = x + x z = y + y print z + z Won’t work: (exponential blowup) print (1 + 1) + (1 + 1) + (1 + 1) + (1 + 1) Answer. print (lambda z: (z + z))(y + y) Chelsea Voss PyCon 2016 Oneliner-izer
  34. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Simple Code Blocks Convert this into a single line? x = 1 y = x + x z = y + y print z + z Won’t work: (exponential blowup) print (1 + 1) + (1 + 1) + (1 + 1) + (1 + 1) Answer. print (lambda z: (z + z))(y + y) Alternate method. [z + z for z in [y + y]][0] Chelsea Voss PyCon 2016 Oneliner-izer
  35. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Simple Code Blocks Convert this into a single line? x = 1 y = x + x z = y + y print z + z Won’t work: (exponential blowup) print (1 + 1) + (1 + 1) + (1 + 1) + (1 + 1) Answer. print (lambda y: (lambda z: (z + z))(y + y) )(x + x) Alternate method. [z + z for z in [y + y]][0] Chelsea Voss PyCon 2016 Oneliner-izer
  36. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Simple Code Blocks Convert this into a single line? x = 1 y = x + x z = y + y print z + z Won’t work: (exponential blowup) print (1 + 1) + (1 + 1) + (1 + 1) + (1 + 1) Answer. print (lambda x: (lambda y: (lambda z: (z + z))(y + y) )(x + x))(1) Alternate method. [z + z for z in [y + y]][0] Chelsea Voss PyCon 2016 Oneliner-izer
  37. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler What about functions? Convert this into a single line? def f(x): return x * 10 print f(3) Chelsea Voss PyCon 2016 Oneliner-izer
  38. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler What about functions? Convert this into a single line? def f(x): return x * 10 print f(3) Answer. Chelsea Voss PyCon 2016 Oneliner-izer
  39. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler What about functions? Convert this into a single line? def f(x): return x * 10 print f(3) Answer. print (lambda f: f(3))(lambda x: x * 10) Chelsea Voss PyCon 2016 Oneliner-izer
  40. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler What about functions? Convert this into a single line? def f(x): return x * 10 print f(3) Answer. print (lambda f: f(3))(lambda x: x * 10) Note that this works as-is with *args and **kwargs! lambda x, y, *args, **kwargs: ... Chelsea Voss PyCon 2016 Oneliner-izer
  41. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler What about operations that don’t assign to a variable? Suppose do something() has side effects. Convert this into a single line? do_something() print 42 Chelsea Voss PyCon 2016 Oneliner-izer
  42. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler What about operations that don’t assign to a variable? Suppose do something() has side effects. Convert this into a single line? do_something() print 42 Answer. Since the output value of do_something() isn’t used, we can funnel it to the unused variable _. Chelsea Voss PyCon 2016 Oneliner-izer
  43. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler What about operations that don’t assign to a variable? Suppose do something() has side effects. Convert this into a single line? do_something() print 42 Answer. Since the output value of do_something() isn’t used, we can funnel it to the unused variable _. print (lambda _: 42)(do_something()) Chelsea Voss PyCon 2016 Oneliner-izer
  44. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler What about operations that don’t assign to a variable? Suppose do something() has side effects. Convert this into a single line? do_something() print 42 Answer. Since the output value of do_something() isn’t used, we can funnel it to the unused variable _. print (lambda _: 42)(do_something()) Or: print (do_something(), 42)[1] Chelsea Voss PyCon 2016 Oneliner-izer
  45. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler What about operations that don’t assign to a variable? Suppose do something() has side effects. Convert this into a single line? do_something() print 42 Answer. Since the output value of do_something() isn’t used, we can funnel it to the unused variable _. print (lambda _: 42)(do_something()) Or: print (do_something(), 42)[1] Now we don’t have to have one print: we can define our own print() function and use it just like do something(). Chelsea Voss PyCon 2016 Oneliner-izer
  46. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler A note on print print 1 return 2 Python 3. print is already a function. (lambda _: 2)(print(1)) works just fine. Chelsea Voss PyCon 2016 Oneliner-izer
  47. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler A note on print print 1 return 2 Python 3. print is already a function. (lambda _: 2)(print(1)) works just fine. Python 2. (lambda _: 2)(print 1) is a syntax error. How can we get a __print() function? Chelsea Voss PyCon 2016 Oneliner-izer
  48. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler A note on print print 1 return 2 Python 3. print is already a function. (lambda _: 2)(print(1)) works just fine. Python 2. (lambda _: 2)(print 1) is a syntax error. How can we get a __print() function? Won’t work: In Python 2, we could use from __future__ import print_function. However, that’s not a real import statement, it’s a compiler directive. Chelsea Voss PyCon 2016 Oneliner-izer
  49. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler A note on print print 1 return 2 Python 3. print is already a function. (lambda _: 2)(print(1)) works just fine. Python 2. (lambda _: 2)(print 1) is a syntax error. How can we get a __print() function? Won’t work: In Python 2, we could use from __future__ import print_function. However, that’s not a real import statement, it’s a compiler directive. Instead: __print = __builtins__.__dict__['print'] Chelsea Voss PyCon 2016 Oneliner-izer
  50. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler What about classes? class Person(object): def __init__(self): ... Chelsea Voss PyCon 2016 Oneliner-izer
  51. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler What about classes? class Person(object): def __init__(self): ... → Person = type('Person', (object,), {'__init__': lambda self: ...}) Chelsea Voss PyCon 2016 Oneliner-izer
  52. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Putting it all together x = 2 + 2 def f(x): return x * 5 print x y = f(x) Chelsea Voss PyCon 2016 Oneliner-izer
  53. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Putting it all together x = 2 + 2 def f(x): return x * 5 print x y = f(x) Chelsea Voss PyCon 2016 Oneliner-izer
  54. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Putting it all together x = 2 + 2 def f(x): return x * 5 print x y = f(x) (lambda y: None)(f(x)) Chelsea Voss PyCon 2016 Oneliner-izer
  55. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Putting it all together x = 2 + 2 def f(x): return x * 5 print x y = f(x) (lambda _: (lambda y: None)(f(x)) )(__print(x)) Chelsea Voss PyCon 2016 Oneliner-izer
  56. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Putting it all together x = 2 + 2 def f(x): return x * 5 print x y = f(x) (lambda f: (lambda _: (lambda y: None)(f(x)) )(__print(x)) )(lambda x: x * 5) Chelsea Voss PyCon 2016 Oneliner-izer
  57. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Putting it all together x = 2 + 2 def f(x): return x * 5 print x y = f(x) (lambda x: (lambda f: (lambda _: (lambda y: None)(f(x)) )(__print(x)) )(lambda x: x * 5) )(2 + 2) Chelsea Voss PyCon 2016 Oneliner-izer
  58. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Putting it all together x = 2 + 2 def f(x): return x * 5 print x y = f(x) (lambda x: (lambda f: (lambda _: (lambda y: None)(f(x)) )(__print(x)) )(lambda x: x * 5) )(2 + 2) Preserves evaluation order. Chelsea Voss PyCon 2016 Oneliner-izer
  59. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler if/else Statements Convert this into a single line? if boolean: x = 5 else: x = 10 print x * 100 Chelsea Voss PyCon 2016 Oneliner-izer
  60. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler if/else Statements Convert this into a single line? if boolean: x = 5 else: x = 10 print x * 100 Answer. Conditional expressions ( if else ), plus continuation passing. Chelsea Voss PyCon 2016 Oneliner-izer
  61. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler if/else Statements Convert this into a single line? if boolean: x = 5 else: x = 10 print x * 100 Answer. Conditional expressions ( if else ), plus continuation passing. (code_block_1 if boolean else code_block_2) Chelsea Voss PyCon 2016 Oneliner-izer
  62. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler if/else Statements Convert this into a single line? if boolean: x = 5 else: x = 10 print x * 100 Answer. Conditional expressions ( if else ), plus continuation passing. (code_block_1 if boolean else code_block_2) Code blocks: if boolean: x = 5 print x * 100 else: x = 10 print x * 100 Chelsea Voss PyCon 2016 Oneliner-izer
  63. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler if/else Statements Convert this into a single line? if boolean: x = 5 else: x = 10 print x * 100 Answer. Conditional expressions ( if else ), plus continuation passing. (code_block_1 if boolean else code_block_2) Code blocks: if boolean: x = 5 print x * 100 else: x = 10 print x * 100 Problem: code duplication. Chelsea Voss PyCon 2016 Oneliner-izer
  64. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler if/else Statements Convert this into a single line? if boolean: x = 5 else: x = 10 print x * 100 Answer. Conditional expressions ( if else ), plus continuation passing. To de-duplicate, all code after the if/else becomes a continuation: Chelsea Voss PyCon 2016 Oneliner-izer
  65. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler if/else Statements Convert this into a single line? if boolean: x = 5 else: x = 10 print x * 100 Answer. Conditional expressions ( if else ), plus continuation passing. To de-duplicate, all code after the if/else becomes a continuation: def continuation(x): print x * 100 if boolean: x = 5 return continuation(x) else: x = 10 return continuation(x) Chelsea Voss PyCon 2016 Oneliner-izer
  66. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler if/else Statements Convert this into a single line? if boolean: x = 5 else: x = 10 print x * 100 Answer. Conditional expressions ( if else ), plus continuation passing. Final result: Chelsea Voss PyCon 2016 Oneliner-izer
  67. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler if/else Statements Convert this into a single line? if boolean: x = 5 else: x = 10 print x * 100 Answer. Conditional expressions ( if else ), plus continuation passing. Final result: (lambda continuation: (lambda x: continuation(x) )(5) if boolean else (lambda x: continuation(x) )(10) )(lambda x: __print(x * 100)) Chelsea Voss PyCon 2016 Oneliner-izer
  68. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler if/else Statements Final result: (lambda continuation: (lambda x: continuation(x) )(5) if boolean else (lambda x: continuation(x) )(10) )(lambda x: __print(x * 100)) Chelsea Voss PyCon 2016 Oneliner-izer
  69. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler while Loops Convert this into a single line? x = 5 while x < 20: x = x + 4 print x Chelsea Voss PyCon 2016 Oneliner-izer
  70. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler while Loops Convert this into a single line? x = 5 while x < 20: x = x + 4 print x Answer. Conditional expressions and continuation passing... again! Chelsea Voss PyCon 2016 Oneliner-izer
  71. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler while Loops Convert this into a single line? x = 5 while x < 20: x = x + 4 print x Answer. Conditional expressions and continuation passing... again! Chelsea Voss PyCon 2016 Oneliner-izer
  72. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler while Loops x = 5 while x < 20: x = x + 4 print x → x = 5 def while_loop(x): if x < 20: x = x + 4 while_loop(x) else: print x while_loop(x) Chelsea Voss PyCon 2016 Oneliner-izer
  73. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler while Loops x = 5 while x < 20: x = x + 4 print x → x = 5 def while_loop(x): if x < 20: x = x + 4 while_loop(x) else: print x while_loop(x) Problem: while loop is recursive! Not an anonymous function! Chelsea Voss PyCon 2016 Oneliner-izer
  74. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler while Loops x = 5 while x < 20: x = x + 4 print x → x = 5 def while_loop(x): if x < 20: x = x + 4 while_loop(x) else: print x while_loop(x) Problem: while loop is recursive! Not an anonymous function! Solution: Y combinator. Chelsea Voss PyCon 2016 Oneliner-izer
  75. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler while Loops x = 5 while x < 20: x = x + 4 print x → x = 5 def while_loop(x): if x < 20: x = x + 4 while_loop(x) else: print x while_loop(x) Problem: while loop is recursive! Not an anonymous function! Solution: Y combinator. Y = (lambda f: (lambda x: x(x)) (lambda y: f(lambda: y(y)()))) Chelsea Voss PyCon 2016 Oneliner-izer
  76. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler while Loops x = 5 while x < 20: x = x + 4 print x → Problem: while loop is recursive! Not an anonymous function! Solution: Y combinator. Y = (lambda f: (lambda x: x(x)) (lambda y: f(lambda: y(y)()))) (lambda x: (lambda while_loop: while_loop(x)) (Y(lambda while_loop: (lambda x: (lambda x: while_loop(x))(x+4) if x<20 else __print(x)))))(5) Chelsea Voss PyCon 2016 Oneliner-izer
  77. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler while Loops x = 5 while x < 20: x = x + 4 print x → Problem: while loop is recursive! Not an anonymous function! Solution: Y combinator. Y = (lambda f: (lambda x: x(x)) (lambda y: f(lambda: y(y)()))) (lambda x: (lambda while_loop: while_loop(x)) (Y(lambda while_loop: (lambda x: (lambda x: while_loop(x))(x+4) if x<20 else __print(x)))))(5) Worked example here: Wikipedia:Fixed-point_combinator#The_factorial_function Chelsea Voss PyCon 2016 Oneliner-izer
  78. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Storing state Old way: (lambda x: return_value)(42) Chelsea Voss PyCon 2016 Oneliner-izer
  79. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Storing state Old way: (lambda x: return_value)(42) Problem: continuation = (lambda x, y, z, kitchen_sink: ...) Chelsea Voss PyCon 2016 Oneliner-izer
  80. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Storing state Old way: (lambda x: return_value)(42) Problem: continuation = (lambda x, y, z, kitchen_sink: ...) New way: [return_value for some_dict['x'] in [42]][0] Chelsea Voss PyCon 2016 Oneliner-izer
  81. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Storing state Old way: (lambda x: return_value)(42) Problem: continuation = (lambda x, y, z, kitchen_sink: ...) New way: [return_value for some_dict['x'] in [42]][0] More concise continuations: continuation = (lambda some_dict: ...) Chelsea Voss PyCon 2016 Oneliner-izer
  82. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Storing state Old way: (lambda x: return_value)(42) Problem: continuation = (lambda x, y, z, kitchen_sink: ...) New way: [return_value for some_dict['x'] in [42]][0] More concise continuations: continuation = (lambda some_dict: ...) Initialize some dict with locals(). Chelsea Voss PyCon 2016 Oneliner-izer
  83. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Storing state Old way: (lambda x: return_value)(42) Problem: continuation = (lambda x, y, z, kitchen_sink: ...) New way: [return_value for some_dict['x'] in [42]][0] More concise continuations: continuation = (lambda some_dict: ...) Initialize some dict with locals(). Bonus: now we can import x from one-lined programs! Chelsea Voss PyCon 2016 Oneliner-izer
  84. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler for Loops Convert this into a single line? total = 0 for item in iterable: total += item print total Chelsea Voss PyCon 2016 Oneliner-izer
  85. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler for Loops Convert this into a single line? total = 0 for item in iterable: total += item print total Reminder. The items of iterable must be consumed one-by-one in order. We can’t always index into it with iterable[i]. Chelsea Voss PyCon 2016 Oneliner-izer
  86. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler for Loops Convert this into a single line? total = 0 for item in iterable: total += item print total Reminder. The items of iterable must be consumed one-by-one in order. We can’t always index into it with iterable[i]. >>> iterable = {10, 20, 30} >>> for item in iterable: ... print item ... 10 20 30 Chelsea Voss PyCon 2016 Oneliner-izer
  87. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler for Loops Convert this into a single line? total = 0 for item in iterable: total += item print total Reminder. The items of iterable must be consumed one-by-one in order. We can’t always index into it with iterable[i]. >>> iterable = {10, 20, 30} >>> for item in iterable: ... print item ... 10 20 30 >>> iterable[2] TypeError: 'set' object does not support indexing Chelsea Voss PyCon 2016 Oneliner-izer
  88. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler for Loops Convert this into a single line? total = 0 for item in iterable: total += item print total Answer. Chelsea Voss PyCon 2016 Oneliner-izer
  89. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler for Loops Convert this into a single line? total = 0 for item in iterable: total += item print total Answer. Convert to a while loop that consumes the iterable using next. total = 0 items = iter(iterable) sentinel = [] while True: item = next(items, sentinel) if item is sentinel: break total += item print total Chelsea Voss PyCon 2016 Oneliner-izer
  90. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Imports import random as rnd print rnd.choice([1, 2, 3, 10]) Chelsea Voss PyCon 2016 Oneliner-izer
  91. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Imports import random as rnd print rnd.choice([1, 2, 3, 10]) Answer. This is equivalent to: rnd = __import__('random') print rnd.choice([1, 2, 3, 10]) Fortunately, __import__ itself doesn’t need to be imported. Chelsea Voss PyCon 2016 Oneliner-izer
  92. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Raising Errors raise Bad() Chelsea Voss PyCon 2016 Oneliner-izer
  93. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Raising Errors raise Bad() → ([] for [] in []).throw(Bad()) Chelsea Voss PyCon 2016 Oneliner-izer
  94. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Raising Errors raise Bad() → ([] for [] in []).throw(Bad()) assert good carry_on() Chelsea Voss PyCon 2016 Oneliner-izer
  95. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Raising Errors raise Bad() → ([] for [] in []).throw(Bad()) assert good carry_on() → carry_on() if good else ([] for [] in []).throw(AssertionError()) Chelsea Voss PyCon 2016 Oneliner-izer
  96. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler try/except Problem: try: foo() except Bad as ev: bar(ev) Chelsea Voss PyCon 2016 Oneliner-izer
  97. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler try/except Problem: try: foo() except Bad as ev: bar(ev) Solution: abuse the context manager protocol! Chelsea Voss PyCon 2016 Oneliner-izer
  98. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler try/except Solution: abuse the context manager protocol! class Handler: def __enter__(self): pass def __exit__(self, et, ev, tb): if et is not None and issubclass(et, Bad): bar(ev); return True return False with Handler(): foo() Chelsea Voss PyCon 2016 Oneliner-izer
  99. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler try/except class Body: def __enter__(self): pass def __exit__(self, et, ev, tb): foo() class Handler: def __enter__(self): pass def __exit__(self, et, ev, tb): if et is not None and issubclass(et, Bad): bar(ev); return True return False with Handler(), Body(): pass Chelsea Voss PyCon 2016 Oneliner-izer
  100. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler try/except class Body: def __enter__(self): pass def __exit__(self, et, ev, tb): foo() class Handler: def __enter__(self): pass def __exit__(self, et, ev, tb): if et is not None and issubclass(et, Bad): bar(ev); return True return False with contextlib.nested(Handler(), Body()): pass Chelsea Voss PyCon 2016 Oneliner-izer
  101. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler try/except class Body: def __enter__(self): pass def __exit__(self, et, ev, tb): foo() # Why __exit__? Python issue 5251. class Handler: def __enter__(self): pass def __exit__(self, et, ev, tb): if et is not None and issubclass(et, Bad): bar(ev); return True return False with contextlib.nested(Handler(), Body()): pass Chelsea Voss PyCon 2016 Oneliner-izer
  102. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler try/except class Body: def __enter__(self): pass def __exit__(self, et, ev, tb): foo() # Why __exit__? Python issue 5251. class Handler: def __enter__(self): pass def __exit__(self, et, ev, tb): if et is not None and issubclass(et, Bad): bar(ev); return True return False ctx = contextlib.nested(Handler(), Body()) ctx.__enter__() ctx.__exit__(None, None, None) Chelsea Voss PyCon 2016 Oneliner-izer
  103. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler try/except Body = type(’Body’, (), ’__enter__’: lambda self: None, ’__exit__’: lambda self, et, ev, tb: foo() ) Handler = type(’Handler’, (), ’__enter__’: lambda self: None, ’__exit__’: lambda self, et, ev, tb: et is not None and issubclass(et, Bad) and (bar(ev), True)[1] ) ctx = contextlib.nested(Handler(), Body()) ctx.__enter__() ctx.__exit__(None, None, None) Chelsea Voss PyCon 2016 Oneliner-izer
  104. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler try/except (lambda ctx: (ctx.__enter__(), ctx.__exit__(None, None, None)) )(contextlib.nested( type(’Handler’, (), { ’__enter__’: lambda self: None, ’__exit__’: lambda self, et, ev, tb: et is not None and issubclass(et, Bad) and (bar(ev), True)[1] })(), type(’Body’, (), { ’__enter__’: lambda self: None, ’__exit__’: lambda self, et, ev, tb: foo() })())) Chelsea Voss PyCon 2016 Oneliner-izer
  105. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler try/except (lambda ctx: (ctx.__enter__(), ctx.__exit__(None, None, None)) )(contextlib.nested( type(’Handler’, (), { ’__enter__’: lambda self: None, ’__exit__’: lambda self, et, ev, tb: et is not None and issubclass(et, Bad) and (bar(ev), True)[1] })(), type(’Body’, (), { ’__enter__’: lambda self: None, ’__exit__’: lambda self, et, ev, tb: foo() })())) Also implemented: else and finally. Chelsea Voss PyCon 2016 Oneliner-izer
  106. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler What’s Left from module import * yield and generators with Chelsea Voss PyCon 2016 Oneliner-izer
  107. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Building the Compiler ast - for parsing Python files into syntax trees symtable - for elucidating the scope of variables argparse - for parsing command-line arguments unittest - test suite Chelsea Voss PyCon 2016 Oneliner-izer
  108. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Building the Compiler ast - for parsing Python files into syntax trees symtable - for elucidating the scope of variables argparse - for parsing command-line arguments unittest - test suite https://github.com/csvoss/onelinerizer Chelsea Voss PyCon 2016 Oneliner-izer
  109. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Some caveats Constant upper limit to Python parser. $ python onelinerized.py s_push: parser stack overflow MemoryError Chelsea Voss PyCon 2016 Oneliner-izer
  110. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Some caveats Constant upper limit to Python parser. $ python onelinerized.py s_push: parser stack overflow MemoryError $ pypy onelinerized.py Chelsea Voss PyCon 2016 Oneliner-izer
  111. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Some caveats Constant upper limit to Python parser. $ python onelinerized.py s_push: parser stack overflow MemoryError $ pypy onelinerized.py Long loops: Maximum recursion depth exceeded. Chelsea Voss PyCon 2016 Oneliner-izer
  112. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Some caveats Constant upper limit to Python parser. $ python onelinerized.py s_push: parser stack overflow MemoryError $ pypy onelinerized.py Long loops: Maximum recursion depth exceeded. import sys sys.setrecursionlimit(new_limit) Chelsea Voss PyCon 2016 Oneliner-izer
  113. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Oneliner-izing the Oneliner-izer Chelsea Voss PyCon 2016 Oneliner-izer
  114. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Contributors Many thanks to: andersk for contributing many features and some slides asottile and shulinye for contributing code Chelsea Voss PyCon 2016 Oneliner-izer
  115. The Challenge Simple Code Blocks Control Flow Beyond Building the

    Compiler Links Demo: http://onelinepy.herokuapp.com/ Code: https://github.com/csvoss/onelinerizer Further Reading Lambda calculus, Church numerals, combinatory logic To Mock a Mockingbird for logic and combinator puzzles Chelsea Voss PyCon 2016 Oneliner-izer