Static Type Inferencing ... in Ruby?

And exploration of the possibility of doing static type inferencing in Ruby.

Transcript

1. Hi, I’m Dan github/jellymann twitter/jellym4nn
3. Static Type Inferencing In Ruby … ?
4. What is it?
5. Type Infer Static
6. Type (n) a category of people or things having common characteristics.
7. Infer (v) deduce or conclude (something) from evidence and reasoning rather than from explicit statements.
8. Static (adj) not able to be changed during a set period, for example while a program is running.
9. Static Type Inferencing to deduce from reasoning, the categories of things that are not able to change while a program is running
10. tl;dr x = 1 therefore x is Integer
11. def foo(x) x + 1 end therefore foo(1) is Integer
12. Why?
13. Catch bugs before production
14. Undefined method `[]’ for nil:NilClass
15. But isn’t that what tests are for?
16. You won’t catch every edge case in your tests
17. Static Type Inferencing can catch as you type
18. Helps make code more self-documenting eg. auto-complete
19. User.f find(id) find_by(**attrs) find_or_create_by
20. Why Ruby?
21. Undefined method `[]’ for nil:NilClass
22. Because it doesn’t quite have it (yet)
23. Supposedly getting something in 3.0
24. Ruby is notoriously dynamic
25. user&.first_name || ‘‘
26. user&.first_name || ‘‘ (Imagine doing that in Java)
27. Not to mention... define_method instance_eval method_missing __send__
28. I think it’ll only make Ruby better and easier to work with
29. All of the type safety None of the runtime cost
30. Also, I’m completely insane
31. How?
32. How to infer type:
33. How to infer type: 1. Parse Code
34. How to infer type: 1. Parse Code 2. Infer type of literals
35. How to infer type: 1. Parse Code 2. Infer type of literals 3. ???
36. How to infer type: 1. Parse Code 2. Infer type of literals 3. ??? 4. Profit!
37. Step 1: RubyParser
38. It turns this: x = 1
39. It turns this: x = 1 Into this: s(:lasgn,:x,s(:lit,1))
40. It turns this: x = 1 Into this: s(:lasgn,:x,s(:lit,1))
41. It turns this: x = 1 Into this: s(:lasgn,:x,s(:lit,1))
42. Step 2: Process the expressions
43. s(:lasgn,:x,s(:lit,1)) # ... @local_variables[:x] = Type(Integer)
44. Step 3: Rinse and Repeat
45. Method calls: 1 + 1
46. Method calls: 1 + 1 s(:call, s(:lit, 1), :+, s(:lit, 1))
47. Method calls: 1 + 1 Integer has a + method that takes an Integer and returns an Integer
48. Method calls: 1 + 1 #=> Integer
49. def foo(a) a + 1 end
50. s(:defn, :foo, s(:args, :a), s(:call, s(:lvar,:a), :+, s(:lit, 1)))
51. foo accepts a
52. foo accepts a and + gets called on a
53. foo accepts a and + gets called on a with an Integer
54. foo accepts a and + gets called on a with an Integer and it’s the last expr. in the method
55. foo accepts one arg
56. foo accepts one arg that has a + method
57. foo accepts one arg that has a + method that takes an Integer
58. foo accepts one arg that has a + method that takes an Integer and returns whatever that returns
59. Some kind of internal representation
60. foo
61. foo(a)
62. foo(a:)
63. foo(a:[:+])
64. foo(a:[:+(Integer)])
65. foo( a:[:+(Integer)->R])
66. foo( a:[:+(Integer)->R]) -> R
67. Looks like we’re getting somewhere...
68. def foo(a, b=1, c:, **d) x = a > b ? c : d “B:#{b + yield(x).upcase}” rescue => e retry end
69. s(:defn, :foo, s(:args, :a, s(:lasgn, :b, s(:lit, 1)), s(:kwarg, :c), :"**d"), s(:rescue, s(:block, s(:lasgn, :x, s(:if, s(:call, s(:lvar, :a), :>, s(:lvar, :b)), s(:lvar, :c), s(:lvar, :d))), s(:dstr, "B:", s(:evstr, s(:call, s(:lvar, :b), :+, s(:call, s(:yield, s(:lvar, :x)), :upcase))))), s(:resbody, s(:array, s(:lasgn, :e, s(:gvar, :$!))), s(:retry))))
70. ¯\_(ツ)_/¯
71. And this is just the surface
72. Ruby is a mess of a language
73. define_method instance_eval method_missing __send__
74. Almost impossible to look at a piece of code and say definitively what their types are
75. The only way to know the type of anything in Ruby code ...
76. … is to run the code
77. Thank You
78. Wait a minute ...
79. What if we ran the code … statically?
80. Basically a Ruby runtime that doesn’t have any side effects
81. Explores every code path in your application from start to finish
82. Raises the same errors that you would have gotten if you really ran it
83. But without actually running it
84. def foo(a) a + 1 end foo(1) #=> foo(nil) #=> ‍♂
85. ‘If’ statements with quantum scope
86. x = nil if something x = 1 end # x is maybe 1 or nil
87. foo(a) a + 1 end foo(x) # undefined method `+’ for nil:NilClass
88. if x.nil? # x is nil:NilClass else # x is 1:Integer foo(x) #=> end
89. Mutations and Generics
90. a = [] # Array[?] a << 1 # Array[Integer] a << nil # Array[Int|Nil] a.sample + 1 # undefined method `+’ for symbol
91. Modules, Refinements
92. Recursion (and detecting infinite loops)
93. Monkeypatching
94. Meta-programming
95. %i(foo bar baz).each do |m| define_method(m) do # … end end
96. Do just enough code execution to know what’s up
97. Dead-code detection
98. if 1 < 10 # this will never happen end
99. class Integer def <(other) return true if other==10 super end end
100. if 1 < 10 # suddenly not impossible end
101. So how does this all look?
102. Will it Ruby?
103. Demo Time!
104. Thank You