provide way to disable T.let / T.cast for production setups and debugging

[md-work]

It seems there's no way to disable T.let and T.cast globally.
This might be helpful when running code in production setups because of two reasons:

• T.let / T.cast may be time consuming (see below)
• production setups may want to ignore typing errors, to reduce risks from incorrect Sorbet code

Additionally a miminal T.let / T.cast codepath might be helpful when debugging (if there's a method call inside T.let(..., which you want to step into). Sadly sorbet-unwrap won't help here. (see also AaronC81/pry-sorbet#5)

 

To solve this problems for method signatures (sig { ... }) one can simply set:
T::Configuration.default_checked_level = :never

There seems to be no such setting for T.let / T.cast.
There's just a hacky workaround I know of.
QUESTION: Is there any counter argument to do this in productive code?
Note: The local checked setting isn't helpful to set a global behavior.

module T
  def self.let(value, type, checked: true)
    value
  end
  
  def self.cast(value, type, checked: true)
    value
  end
end

 

Example: slow

require 'sorbet-runtime'


class MyTest
  attr_reader :x

  def set_typed_x(new_x)
    @x = T.cast(new_x, T::Array[Integer])
  end

  def set_untyped_x(new_x)
    @x = new_x
  end
end


test = MyTest.new

time = Time.now
ary = Array.new(50_000_000) { |i| i }
puts('initializing array: ' + (Time.now - time).to_s)
# 2.08708646

time = Time.now
test.set_typed_x(ary)
puts('set_typed_x: ' + (Time.now - time).to_s)
# 4.434147138

time = Time.now
test.set_untyped_x(ary)
puts('set_untyped_x: ' + (Time.now - time).to_s)
# 3.451e-06

 

Example: ignore problems when introducing Sorbet

require 'sorbet-runtime'


class MyTest
  attr_reader :x

  def initialize(x)
    # Someone might wrote down this very fast and forgot T.nilable
    # But nil might be totally fine for the applications task.
    @x = T.cast(new_x, String)
  end
end


test = MyTest.new(nil)
puts(test.x.inspect)
# Is considered to output "nil" in this case.

[paracycle]

@md-work I think both of your concerns have solutions that can be used today:

1. Slow cast/let is solved by a recent change in sorbet runtime that stopped checking items in enumerable types. So your example above should be working much faster now.
2. Ignoring problems when introducing Sorbet has been possible without turning off typechecking. This gives you the best of both worlds; you still get runtime type-checking errors logged but they don't break your code.

At Shopify our Sorbet initialization looks like this:

require "sorbet-runtime"

if ENV['RAILS_ENV'] == 'production'
  T::Configuration.default_checked_level = :never

  error_handler = lambda do |error, *_|
    # Log error somewhere
  end

  # Suppresses errors caused by T.cast, T.let, T.must, etc.
  T::Configuration.inline_type_error_handler = error_handler
  # Suppresses errors caused by incorrect parameter ordering
  T::Configuration.sig_validation_error_handler = error_handler
end

[md-work]

@paracycle

[...]
At Shopify our Sorbet initialization looks like this:
[...]

Thanks!
That's very helpful.

 

But what about stepping into a method when debugging?

x = T.cast(method_i_like_to_step_in, String)

I'd like to have a way where I don't need to step through the T.let code to enter the method_i_like_to_step_in.