Checking Your Types: An overview of Ruby's type system

Checking Your Types
An overview of Ruby's type system
@thecodewitch, slides available at thecodewitch.codes/checking-your-types/

Checking Your Types

Checking Your Types
• refresh ourselves on type systems

Checking Your Types
• types in Ruby

Checking Your Types
• types in Ruby
• What's new in Ruby 3

Checking Your Types
• types in Ruby
• Typecheckers

Checking Your Types
• types in Ruby
• Typecheckers
• Examples!

What are types?
Javascript
>> num = 2
2
>> console.log(typeof num);
number
C
char string[] = "C strings are arrays of characters";

Static vs. Dynamic
When do we know what types we're working with?

Static

Static
• Knows types beforehand.

Static
• Knows types beforehand.
• As a party host, knows the number of guests to cater for.

Dynamic

Dynamic
• Knows types when they show up.

Dynamic
• Knows types when they show up.
• Probably easier to crash their party /

Ambiguous territory ahead

Strong vs. Weak Types
"...whenever an object is passed from a calling function to a called
function, its type must be compatible with the type declared in the
called function."
- Liskov & S. Zilles, 19741
1
Liskov, B; Zilles, S (1974). "Programming with abstract data types". ACM SIGPLAN Notices. 9 (4): 50–59.
CiteSeerX 10.1.1.136.3043. doi:10.1145/942572.807045.

Strongly typed language
>> num = 2
2
>> num[0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not subscriptable
>> num + "hello"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

Weakly typed language
>> num = 2
2
// It will always try:
>> num[0]
undefined
// But sometimes this means strange things can happen:
>> num + "hello"
"2hello"

Where would Ruby land?

Dynamic, strong typing

Conversion between types in Ruby

Explicit Conversion
birthday = Time.new(1993, 02, 24)
birthday.to_s
=> "1993-02-24 00:00:00 -0500"

Implicit Conversion
require "bigdecimal"
BigDecimal("101.1111").to_int
=> 101

Numeric conversion
2 + 26.3
=> 28.3
# The above works because the `coerce` method is called before adding:
2.coerce(26.3)
=> [26.3, 2.0]

!
Why add types to Ruby? Isn't this making
the language less expressive?

!
Why add types to Ruby? Isn't this making the
language less expressive?

!
• Improved tooling means less mental overhead

!
• Improved tooling means less mental overhead
• Ruby's strong type system means we're already having to
concern ourselves with passing around valid types

✨
Ruby 3

✨
Ruby 3
• RBS, a language for describing the types of a Ruby program.

✨
Ruby 3
• RBS, a language for describing the types of a Ruby program.
• Typeprof

https://mame.github.io/typeprof-playground/

Gradual Type Checking

NoMethodErrors
# Here we try to call an instance method on the CreditCard class
class CreditCard
def number
end
end
CreditCard.number
NoMethodError (undefined method `number' for CreditCard:Class)

Type Signature Support (RBS)

• Separate ﬁle of type declarations, similar to .d.ts in Typescript

• Separate ﬁle of type declarations, similar to .d.ts in Typescript
• Standalone language, separate from Ruby but describes Ruby
types

!

# steep/sample/sig/conference.rbs
class Conference
attr_reader title: String
attr_reader year: Integer
def initialize: (title: String, year: Integer) -> void
end

Typecheckers

Typecheckers
• Sorbet
!

Typecheckers
• Sorbet
!
• Steep
"

Payments Example
class CreditCard
...
end
class DebitCard
...
end
class User
def payment_method
# (Returns CreditCard or DebitCard)
end
end

Payments Example
class CreditCard
...
end
class DebitCard
...
end
class User
def payment_method
# (Returns CreditCard or DebitCard or Instalments)
end
end

Payments Example

Payments Example
! ! !
ArgumentError: "unknown payment type"
! ! !

Payments Example
class PaymentMethodPresenter
def render
case payment_method
when CreditCard
render snippet: 'credit_card'
when DebitCard
render snippet: 'debit_card'
else
raise 'unknown payment type'
end
end
end

Payments Example
# sig/user.rbs
class User
def payment_method: () -> ???
end

Payments Example
class PaymentMethod
def charge(_amount)
raise 'unimplemented'
end
end
interface _PaymentMethod
def charge: (Money amount) -> void
end

Payments Example
interface _PaymentMethod
def charge: (Money amount) -> void
end
class DebitCard
include _PaymentMethod # Note: not actually adding any behaviour!
def charge
...
end
end
class CreditCard
include _PaymentMethod # Note: not actually adding any behaviour!
def charge
...
end
end

Payments Example
# sig/user.rbs
class User
def payment_method: () -> _PaymentMethod
end
# sig/payment_method_presenter.rbs
attr_reader payment_method: _PaymentMethod
def render: () -> String
end

Payments Example
def render
case payment_method
when creditcard
when debitcard
end
end
end

Payments Example
Error: PaymentMethodPresenter#render claims it returns String, but
actually returns String | nil

Payments Example
def render
case payment_method
when CreditCard
when DebitCard
end
end
end

Payments Example
!
We can use a union type deﬁnition to specify permitted types.

Payments Example
# sig/user.rbs
type payment_method = DebitCard | CreditCard
class User
def payment_method: () -> payment_method
end
attr_reader payment_method: payment_method
end

Payments Example
# sig/user.rbs
type payment_method = DebitCard | CreditCard | Instalments
class User
def payment_method: () -> payment_method
end
attr_reader payment_method: payment_method
end

Payments Example
def render
case payment_method
when CreditCard
when DebitCard
when Instalments
render snippet: 'instalments'
end
end
end

What about reducing NoMethodError?

Addressable Example
Addressable::URI.parse("https://example.com/foo.css?v=123123").query_values
=> { "v" => "123123" }

Addressable Example
version = Addressable::URI.parse(url).query_values['v']
unless version
render :bad_request
return
end

Addressable Example
Addressable::URI.parse("https://example.com").query_values
=> nil
Addressable::URI.parse("https://example.com?").query_values
=> {}

Addressable Example
class Baddressable
def initialize(uri)
@uri = uri
end
def query_values
Hash[*URI.parse(@uri).query.split("=")]
end
end
Baddressable.new("https://example.com").query_values['v']
baddressable.rbs:
class Baddressable
def initialize: (String?) -> void
def query_values: -> Hash[String, String]?
end

Addressable Example
[error] Type `(::Hash[::String, ::String] | nil)` does not have method `[]`
│ Diagnostic ID: Ruby::NoMethod
│
└ Baddressable.new("https://example.com").query_values['v']

Takeaways

Takeaways
• Types were always there; now we're able to work with them
more intentionally in Ruby.

Takeaways
• Using these type checking tools can help us ensure errors really
only happen once by making our code a little smarter.

Takeaways
• Using these type checking tools can help us ensure errors really
only happen once by making our code a little smarter.
• It's going to take adoption and use by the community for this
feature to be as successful as possible!

Thank you!
Sam Doiron @conlectus
Fleur de Ruby meetup @fleur_de_ruby
Grusp for hosting this event, & you for attending!

Go forth & build with types!

Checking Your Types: An overview of Ruby's type system

More Related Content

Recently uploaded

Featured

Checking Your Types: An overview of Ruby's type system