4 posts tagged with "release"

T-Ruby v0.0.42 adds full Ruby 4.0 support, released just days after Ruby 4.0's Christmas release. (PR#28)

T-Ruby v0.0.41 introduces keyword arguments syntax, bringing more expressive type annotations to your Ruby code. (PR#27)

T-Ruby v0.0.40 brings significant parser improvements, including access modifier support and heredoc detection. (PR#22)

T-Ruby now automatically infers return types from your code. No more explicit annotations for obvious types!

What's New​

Previously, you had to write:

def greet(name: String): String
  "Hello, #{name}!"
end

Now, the return type is optional:

def greet(name: String)
  "Hello, #{name}!"
end

T-Ruby infers that greet returns String and generates the correct RBS:

def greet: (name: String) -> String

How It Works​

The new type inference engine analyzes method bodies to determine return types:

• Literal inference: "hello" → String, 42 → Integer
• Method call tracking: str.upcase → String
• Implicit returns: Ruby's last expression becomes the return type
• Conditional handling: Union types from if/else branches

Examples​

Simple Methods​

class Calculator
  def double(n: Integer)
    n * 2
  end

  def is_positive?(n: Integer)
    n > 0
  end
end

Generated RBS:

class Calculator
  def double: (n: Integer) -> Integer
  def is_positive?: (n: Integer) -> bool
end

Instance Variables​

class User
  def initialize(name: String)
    @name = name
  end

  def greeting
    "Hello, #{@name}!"
  end
end

Generated RBS:

class User
  @name: String

  def initialize: (name: String) -> void
  def greeting: () -> String
end

Technical Details​

The inference system is inspired by TypeScript's approach:

• BodyParser: Parses T-Ruby method bodies into IR nodes
• TypeEnv: Manages scope chains for variable type tracking
• ASTTypeInferrer: Traverses IR with lazy evaluation and caching

For a deep dive into the implementation, check out our technical blog post.

Try It Now​

Update to the latest T-Ruby and enjoy automatic type inference:

gem update t-ruby

Your existing code will work as before - explicit types still take precedence. The inference only kicks in when return types are omitted.

Feedback​

We'd love to hear your experience with type inference. Found an edge case? Have suggestions? Open an issue on GitHub.

Happy typing!