bitint 0.6.1 → 0.7.0

data/lib/bitint/bitint.rb

@@ -1,318 +1,51 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
-class BitInt
-  # Indicates that +BitInt::new+ was called with an integer that was too large.
-  class OverflowError < RuntimeError
-    attr_reader :integer, :range
+module BitInt
+  module_function
 
-    def initialize(integer, range)
-      super "#{integer} is out of bounds (range=#{range})"
-      @integer = integer
-      @range = range
-    end
-  end
-
-  @classes = {}
-
-  class << self
-    private :new
-
-    # Creates a new unsigned +BitInt+ class.
-    #
-    # === Example
-    #   puts BitInt::U(16)::MAX #=> 65535
-    def U(bits) = self[bits, signed: false]
-    alias unsigned U
-
-    # Creates a new signed +BitInt+ class.
-    #
-    # === Example
-    #   puts BitInt::I(16)::MAX #=> 32767
-    def I(bits) = self[bits, signed: true]
-    alias signed I
-    alias S I
-
-    # Creates a new +BitInt+. Raises an ArgumentError if bits is negative.
-    #
-    # === Example
-    #   puts BitInt[8]::MAX #=> 255
-    #   puts BitInt[8, signed: false]::MAX #=> 255
-    #   puts BitInt[8, signed: true]::MAX #=> 127
-    def [](bits, signed: false) = create(bits: bits, signed: signed)
-
-    def create(bits: nil, bytes: nil, signed:)
-      if bits.nil? == bytes.nil?
-        raise ArgumentError, 'exactly one of `bits` or `bytes` must be supplied'
-      end
-
-      bits ||= bytes * 8
-
-      raise ArgumentError, 'bit count must be at least 1' unless bits.positive?
-
-      @classes[[bits, signed].freeze] ||= Class.new(self) do |cls|
-        cls.setup!(bits, signed)
-      end
-    end
-
-    # Returns whether this class represents a signed integer.
-    #
-    # === Example
-    #   puts BitInt::U(8).signed? #=> false
-    #   puts BitInt::I(8).signed? #=> true
-    def signed? = @signed
-
-    # Returns whether this class represents an unsigned integer.
-    #
-    # === Example
-    #   puts BitInt::U(8).unsigned? #=> false
-    #   puts BitInt::I(8).unsigned? #=> true
-    def unsigned? = !signed?
-
-    def inspect = name || "#{signed? ? 'I' : 'U'}#@bits"
-    alias to_s inspect
-
-    # :stopdoc:
-    protected def setup!(bits, signed)
-      @bits = bits
-      @signed = signed
-
-      create = ->(int) {
-        allocate.tap { |x| x.instance_variable_set :@int, int }
-      }
-
-      class << self
-        public :new
-      end
-
-      const_set :BITS, @bits
-      const_set :BYTES, (@bits / 8.0).ceil
-      const_set :MASK, (1 << @bits).pred
-      const_set :ZERO, create[0]
-      const_set :ONE, create[1]
-      const_set :MIN, create[signed? ? -(1 << @bits.pred) : 0]
-      const_set :MAX, create[signed? ? (1 << @bits.pred).pred : (1 << @bits).pred]
-      const_set :BOUNDS, self::MIN .. self::MAX
-    end
-
-    def pack_char
-
-    end
-    # :startdoc:
-  end
-
-  # Creates a new BitInt by masking +int+.
+  # Helper to create new unsigned {BitInt::Base} classes.
   #
-  # If +int+ is not rdoc-ref:in_bounds? and +wrap+ is false, then an
-  # OverflowError is raised.
+  # This method just wraps {Base.create}
   #
-  # === Example
-  #   puts BitInt::U(8).new(27) #=> 27
-  #   puts BitInt::U(8).new(-1) #=> 255
-  #   puts BitInt::U(8).new(-1, wrap: false) #=> OverflowError
-  #   puts BitInt::I(8).new(255) #=> -1
-  def initialize(int, wrap: true)
-    unless wrap || (bounds = self.class::BOUNDS).include?(int)
-      raise OverflowError.new(int, bounds)
-    end
-
-    @int = ((int - self.class::MIN.to_i) & self.class::MASK) + self.class::MIN.to_i
-  end
-
-  # Checks to see if +rhs.to_i+ is equal to this class
+  # @param bits [Integer] number of bits; must be nonzero
+  # @return [subclass of Base] a +Class+ that inherits from +Base+
   #
   # === Example
-  #   U64 = BitInt::U(64)
-  #   twelve = U64.new(12)
-  # 
-  #   # Behaves as you'd expect.
-  #   puts twelve == U64.new(12) #=> true
-  #   puts twelve == U64.new(13) #=> false
-  #   puts twelve == 12   #=> true
-  #   puts twelve == 12.0 #=> true
-  #   puts twelve == 13   #=> false
-  #   puts twelve == Object.new #=> false
-  def ==(rhs) = rhs.respond_to?(:to_i) && @int == rhs.to_i
-
-  # Overwite rdoc-ref:Numeric#integer? as we're an integer.
-  def integer? = true
-
-  # :section: Conversions
-
-  # Returns the underlying integer.
-  def to_i = @int
-  alias to_int to_i
-
-  # Converts self to a Float.
-  def to_f = @int.to_f
-
-  # Converts self to a String.
+  #   puts BitInt::U(16)::MAX #=> 65535
   #
-  # If no base is given, it just returns a normal string in base 10.
-  # If a base is given, a string padded with `0`s will be returned.
-  def to_s(base = nil)
-    return @int.to_s if base.nil?
-
-    adjusted = negative? ? (-2*self.class::MIN + self).to_i : @int
-    adjusted.to_s(base).rjust(self.class::BITS / Math.log2(base), negative? ? '1' : '0')
-  end
+  # @rbs (Integer) -> untyped
+  def U(bits) = Base.create(bits: bits, signed: false)
+  alias unsigned U
 
-  alias inspect to_s
-
-  # Returns a base-16 string of +self+. Equivalent to +to_s(16)+.
+  # Helper to create new signed {BitInt::Base} classes.
   #
-  # If +upper: true+ is passed, returns an upper-case version.
+  # This method just wraps {Base.create}
   #
-  # === Example
-  #   puts BitInt::U16.new(1234).hex #=> 04d2
-  #   puts BitInt::U16.new(1234, upper: true).hex #=> 04D2
-  def hex(upper: false)
-    to_s(16).tap { _1.upcase! if upper }
-  end
-
-  # Returns a base-8 string of +self+. Equivalent to +to_s(8)+.
+  # @param bits [Integer] number of bits; must be nonzero
+  # @return     [subclass of Base] a +Class+ that inherits from +Base+
   #
   # === Example
-  #   puts BitInt::U16.new(1234).oct #=> 02322
-  def oct
-    to_s(8)
-  end
+  #   puts BitInt::I(16)::MAX #=> 32767
+  #
+  # @rbs (Integer) -> untyped
+  def I(bits) = Base.create(bits: bits, signed: true)
+  alias signed I
+  alias S I
 
-  # Returns a base-2 string of +self+. Equivalent to +to_s(2)+.
+  # Helper to create new {BitInt::Base} classes.
+  #
+  # This method just wraps {Base.create}.
+  #
+  # @param bits   [Integer] number of bits; must be nonzero
+  # @param signed [bool] whether the subclass should be signed
+  # @return       [subclass of Base] a +Class+ that inherits from +Base+
   #
   # === Example
-  #   puts BitInt::U16.new(54321).bin #=> 0000010011010010
-  def bin
-    to_s(2)
-  end
-
-  # :section: Math
-
-  # Numerically negates +self+.
-  def -@ = self.class.new(-@int)
-
-  # Bitwise negates +self+.
-  def ~ = self.class.new(~@int)
-
-  # Compares +self+ to +rhs+.
-  def <=>(rhs) = rhs.respond_to?(:to_i) ? @int <=> (_ = rhs).to_i : nil
-
-  # Adds +self+ to +rhs+.
-  def +(rhs) = self.class.new(@int + rhs.to_i)
-
-  # Subtracts +rhs+ from +self+.
-  def -(rhs) = self.class.new(@int - rhs.to_i)
-
-  # Multiplies +self+ by +rhs+.
-  def *(rhs) = self.class.new(@int * rhs.to_i)
-
-  # Divides +self+ by +rhs+.
-  def /(rhs) = self.class.new(@int / rhs.to_i)
-
-  # Modulos +self+ by +rhs+.
-  def %(rhs) = self.class.new(@int % rhs.to_i)
-
-  # :section:
-
-  # Returns whether +self+ is a positive integer. Zero is not positive.
-  def positive?
-    @int.positive?
-  end
-
-  # Return whether +self+ is a negative integer. Zero is not negative.
-  def negative?
-    @int.negative?
-  end
-
-  # Returns whether +self+ is zero.
-  def zero?
-    @int.zero?
-  end
-
-  # Returns a falsey value if zero, otherwise returns +self+.
-  def nonzero?
-    @int.nonzero? && self
-  end
-
-  # Checks to see if +self+ is even.
-  def even?
-    @int.even?
-  end
-
-  # Checks to see if +self+ is odd.
-  def odd?
-    @int.odd?
-  end
-
-  ##################################
-  # :section: Bit-level operations #
-  ##################################
-
-  # Raises +self+ to the +rhs+th power.
-  #--
-  # Note that `Numeric` only defines `.to_int` (not `.to_i`)
-  #++
-  def **(rhs) = self.class.new((@int ** rhs.to_i).to_int)
-
-  # Shifts +self+ left by +rhs+ bits.
-  def <<(rhs) = self.class.new(@int << rhs.to_i)
-
-  # Shifts +self+ right by +rhs+ bits.
-  def >>(rhs) = self.class.new(@int >> rhs.to_i)
-
-  # Bitwise ANDs +self+ and +rhs+.
-  def &(rhs) = self.class.new(@int & rhs.to_i)
-
-  # Bitwise ORs +self+ and +rhs+.
-  def |(rhs) = self.class.new(@int | rhs.to_i)
-
-  # Bitwise XORs +self+ and +rhs+.
-  def ^(rhs) = self.class.new(@int ^ rhs.to_i)
-
-  # Gets the bit at index +idx+ or returns +nil+.
+  #   puts BitInt[9]::MAX #=> 511
+  #   puts BitInt[9, signed: false]::MAX #=> 511
+  #   puts BitInt[9, signed: true]::MAX #=> 255
   #
-  # This is equivalent to +Integer#[]+
-  def [](idx) = @int[idx]
-
-  def anybits?(mask) = @int.anybits?(mask)
-  def allbits?(mask) = @int.allbits?(mask)
-  def nobits?(mask) = @int.nobits?(mask)
-  def bit_length = @int.bit_length
-
-  def size = (self.class::BITS / 8.0).ceil
-
-  PACK_FMT = {
-    [:native, 8,  false].freeze => 'C',
-    [:native, 16, false].freeze => 'S',
-    [:native, 32, false].freeze => 'L',
-    [:native, 64, false].freeze => 'Q',
-    [:native, 8,  true].freeze => 'c',
-    [:native, 16, true].freeze => 's',
-    [:native, 32, true].freeze => 'l',
-    [:native, 64, true].freeze => 'q',
-  }.freeze
-  private_constant :PACK_FMT
-
-  def bytes(endian = :native)
-    return to_enum(__method__, endian) unless block_given?
-
-    template = '_CS_L___Q'[self.class::BYTES]
-    if template.nil? || template == '_'
-      raise ArgumentError, 'bytes only works for sizes of 8, 16, 32, or 64.'
-    end
-
-    template.downcase! if self.class.signed?
-
-    case endian
-    when :native
-    when :little then template.concat '<'
-    when :big then template.concat '>'
-    else raise raise ArgumentError, 'endian must be :big, :little, or :native'
-    end
-
-    [to_i].pack(template).unpack('C*').map(&U8.method(:new))
-  end
-
-  def bytes_hex(...)
-    bytes(...).map(&:hex)
-  end
+  # @rbs (Integer, ?signed: bool) -> untyped
+  def [](bits, signed: false) = Base.create(bits: bits, signed: signed)
 end

data/lib/bitint/constants.rb

@@ -1,6 +1,22 @@
 # frozen_string_literal: true
-
-class BitInt
+# rbs_inline: enabled
+
+# @rbs!
+#   module BitInt
+#     class U8 < Base end
+#     class U16 < Base end
+#     class U32 < Base end
+#     class U64 < Base end
+#     class U128 < Base end
+#     class I8 < Base end
+#     class I16 < Base end
+#     class I32 < Base end
+#     class I64 < Base end
+#     class I128 < Base end
+#   end
+
+# @rbs skip
+module BitInt
   # An unsigned 8-bit integer
   U8 = U(8)
 

data/lib/bitint/native.rb

@@ -1,88 +1,144 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require 'fiddle'
 
-class BitInt
-  # `BitInt`s that correspond to underlying C integer sizes.
+module BitInt
+  # +BitInt+s that correspond to underlying C integer sizes.
   module Native
-    # On big-endian systems, the unpack will equal `0x00AA`.
+    # On big-endian systems, the unpack will equal +0x00AA+.
     IS_LITTLE_ENDIAN = [0xAA00].pack('S').unpack('S<') == [0xAA00]
     private_constant :IS_LITTLE_ENDIAN
 
     module_function
 
-    # Returns either `:little` or `:big` depending on the underlying system's endianness.
+    # Helper method to fetch the endianness of the underlying system.
+    #
+    # @rbs () -> (:little | :big)
     def endianness
-      @IS_LITTLE_ENDIAN ? :little : :big
+      IS_LITTLE_ENDIAN ? :little : :big
     end
 
     class << self
       alias endian endianness
     end
 
-    # Returns `true` when on a little endian system.
+    # Returns +true+ when on a little endian system.
+    #
+    # @rbs () -> bool
     def little_endian?
       endianness == :little
     end
 
-    # Returns `true` when on a big endian system.
+    # Returns +true+ when on a big endian system.
+    #
+    # @rbs () -> bool
     def big_endian?
       endianness == :big
     end
 
-    # A signed `sizeof(char)`-byte BitInt.
+    # @rbs!
+    #   class SCHAR < Base end
+    #   class UCHAR < Base end
+    #   class SHORT < Base end
+    #   class USHORT < Base end
+    #   class INT < Base end
+    #   class UINT < Base end
+    #   class LONG < Base end
+    #   class ULONG < Base end
+    #   class LONG_LONG < Base end
+    #   class ULONG_LONG < Base end
+    #   class VOIDP < Base end
+    #   class SIZE_T < Base end
+    #   class SSIZE_T < Base end
+    #   class PTRDIFF_T < Base end
+    #   class INTPTR_T < Base end
+    #   class UINTPTR_T < Base end
+
+    # A signed +sizeof(char)+-byte BitInt.
     #
-    # Technically C has a difference between `char`, `unsigned char`, and `signed char`. But there's
-    # no real easy way to tell from within ruby code. So `CHAR` doesn't exist.
+    # Technically C has a difference between +char+, +unsigned char+, and +signed char+. But there's
+    # no real easy way to tell from within ruby code. So +CHAR+ doesn't exist.
     #
-    SCHAR = BitInt.create(bytes: Fiddle::SIZEOF_CHAR, signed: true)
+    # @rbs skip
+    SCHAR = Base.create(bytes: Fiddle::SIZEOF_CHAR, signed: true)
 
-    # An unsigned `sizeof(char)`-byte BitInt.
-    UCHAR = BitInt.create(bytes: Fiddle::SIZEOF_CHAR, signed: false)
+    # An unsigned +sizeof(char)+-byte BitInt.
+    #
+    # @rbs skip
+    UCHAR = Base.create(bytes: Fiddle::SIZEOF_CHAR, signed: false)
 
-    # A signed `sizeof(short)`-byte BitInt.
-    SHORT = BitInt.create(bytes: Fiddle::SIZEOF_SHORT, signed: true)
+    # A signed +sizeof(short)+-byte BitInt.
+    #
+    # @rbs skip
+    SHORT = Base.create(bytes: Fiddle::SIZEOF_SHORT, signed: true)
 
-    # An unsigned `sizeof(short)`-byte BitInt.
-    USHORT = BitInt.create(bytes: Fiddle::SIZEOF_SHORT, signed: false)
+    # An unsigned +sizeof(short)+-byte BitInt.
+    #
+    # @rbs skip
+    USHORT = Base.create(bytes: Fiddle::SIZEOF_SHORT, signed: false)
 
-    # A signed `sizeof(int)`-byte BitInt.
-    INT = BitInt.create(bytes: Fiddle::SIZEOF_INT, signed: true)
+    # A signed +sizeof(int)+-byte BitInt.
+    #
+    # @rbs skip
+    INT = Base.create(bytes: Fiddle::SIZEOF_INT, signed: true)
 
-    # An unsigned `sizeof(short)`-byte BitInt.
-    UINT = BitInt.create(bytes: Fiddle::SIZEOF_INT, signed: false)
+    # An unsigned +sizeof(int)+-byte BitInt.
+    #
+    # @rbs skip
+    UINT = Base.create(bytes: Fiddle::SIZEOF_INT, signed: false)
 
-    # A signed `sizeof(long)`-byte BitInt.
-    LONG = BitInt.create(bytes: Fiddle::SIZEOF_LONG, signed: true)
+    # A signed +sizeof(long)+-byte BitInt.
+    #
+    # @rbs skip
+    LONG = Base.create(bytes: Fiddle::SIZEOF_LONG, signed: true)
 
-    # An unsigned `sizeof(short)`-byte BitInt.
-    ULONG = BitInt.create(bytes: Fiddle::SIZEOF_LONG, signed: false)
+    # An unsigned +sizeof(long)+-byte BitInt.
+    #
+    # @rbs skip
+    ULONG = Base.create(bytes: Fiddle::SIZEOF_LONG, signed: false)
 
-    # Some platforms Ruby supports don't actually support `long long`s (in this day and age...)
+    # Some platforms Ruby supports don't actually support +long long+s (in this day and age...)
     if defined? Fiddle::SIZEOF_LONG_LONG
-      # A signed `sizeof(long long)`-byte BitInt. Only enabled if the platform supports `long long`.
-      LONG_LONG = BitInt.create(bytes: Fiddle::SIZEOF_LONG_LONG, signed: true)
-
-      # An unsigned `sizeof(long long)`-byte BitInt. Only enabled if the platform supports `long long`.
-      ULONG_LONG = BitInt.create(bytes: Fiddle::SIZEOF_LONG_LONG, signed: false)
+      # A signed +sizeof(long long)+-byte BitInt. Only enabled if the platform supports +long long+.
+      #
+      # @rbs skip
+      LONG_LONG = Base.create(bytes: Fiddle::SIZEOF_LONG_LONG, signed: true)
+
+      # An unsigned +sizeof(long long)+-byte BitInt. Only enabled if the platform supports +long long+.
+      #
+      # @rbs skip
+      ULONG_LONG = Base.create(bytes: Fiddle::SIZEOF_LONG_LONG, signed: false)
     end
 
-    # An unsigned `sizeof(void *)`-byte BitInt.
-    VOIDP = BitInt.create(bytes: Fiddle::SIZEOF_VOIDP, signed: false)
+    # An unsigned +sizeof(void *)+-byte BitInt.
+    #
+    # @rbs skip
+    VOIDP = Base.create(bytes: Fiddle::SIZEOF_VOIDP, signed: false)
 
-    # An unsigned `sizeof(size_t)`-byte BitInt.
-    SIZE_T = BitInt.create(bytes: Fiddle::SIZEOF_SIZE_T, signed: false)
+    # An unsigned +sizeof(size_t)+-byte BitInt.
+    #
+    # @rbs skip
+    SIZE_T = Base.create(bytes: Fiddle::SIZEOF_SIZE_T, signed: false)
 
-    # A signed `sizeof(ssize_t)`-byte BitInt.
-    SSIZE_T = BitInt.create(bytes: Fiddle::SIZEOF_SSIZE_T, signed: true)
+    # A signed +sizeof(ssize_t)+-byte BitInt.
+    #
+    # @rbs skip
+    SSIZE_T = Base.create(bytes: Fiddle::SIZEOF_SSIZE_T, signed: true)
 
-    # A signed `sizeof(ptrdiff_t)`-byte BitInt.
-    PTRDIFF_T = BitInt.create(bytes: Fiddle::SIZEOF_PTRDIFF_T, signed: true)
+    # A signed +sizeof(ptrdiff_t)+-byte BitInt.
+    #
+    # @rbs skip
+    PTRDIFF_T = Base.create(bytes: Fiddle::SIZEOF_PTRDIFF_T, signed: true)
 
-    # A signed `sizeof(intptr_t)`-byte BitInt.
-    INTPTR_T = BitInt.create(bytes: Fiddle::SIZEOF_INTPTR_T, signed: true)
+    # A signed +sizeof(intptr_t)+-byte BitInt.
+    #
+    # @rbs skip
+    INTPTR_T = Base.create(bytes: Fiddle::SIZEOF_INTPTR_T, signed: true)
 
-    # An unsigned `sizeof(uintptr_t)`-byte BitInt.
-    UINTPTR_T = BitInt.create(bytes: Fiddle::SIZEOF_UINTPTR_T, signed: false)
+    # An unsigned +sizeof(uintptr_t)+-byte BitInt.
+    #
+    # @rbs skip
+    UINTPTR_T = Base.create(bytes: Fiddle::SIZEOF_UINTPTR_T, signed: false)
   end
 end

data/lib/bitint/overflow_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module BitInt
+  # Indicates that +BitInt::Base.create+ was called with an integer that was too large.
+  class OverflowError < RuntimeError
+    attr_reader :integer, :range
+
+    def initialize(integer, range)
+      super "#{integer} is out of bounds (range=#{range})"
+      @integer = integer
+      @range = range
+    end
+  end
+end

data/lib/bitint/refinements.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
-class BitInt
-  # Refinements to Integer for easy "BitInt literals" (eg `12.u8`)
+module BitInt
+  # Refinements to +Integer+ for easy "+BitInt+ literals" (eg +puts(12.u8)+)
   module Refinements
     refine Integer do
       # Converts +self+ into an unsigned +bits+-bit integer.
@@ -12,7 +13,7 @@ class BitInt
       #   puts BitInt::U(16)::MAX #=> 65535
       #   
       def u(bits, ...)
-        BitInt::U(bits, ...).new(self)
+        BitInt::U(bits).new(self, ...)
       end
 
       # Converts +self+ into a signed +bits+-bit integer.
@@ -20,61 +21,61 @@ class BitInt
       # If no arguments are given, this instead forwards to Numeric#i.
       #
       # Any additional arguments are forwarded to +BitInt#new+
-      def i(bits = bits_not_given=true, *a, **k, &b) # Support ruby-3.0
-        bits_not_given and return super
+      def i(bits = bits_not_given=true, ...)
+        bits_not_given and return super()
 
-        BitInt::i(bits, *a, **k, &b).new(self)
+        BitInt::I(bits).new(self, ...)
       end
 
       # Converts +self+ into an unsigned 8-bit integer.
       #
       # Any additional arguments are forwarded to +BitInt#new+
-      def u8(...) = u(8, ...)
+      def u8(...) = U8.new(self, ...)
 
       # Converts +self+ into an unsigned 16-bit integer.
       #
       # Any additional arguments are forwarded to +BitInt#new+
-      def u16(...) = u(16, ...)
+      def u16(...) = U16.new(self, ...)
 
       # Converts +self+ into an unsigned 32-bit integer.
       #
       # Any additional arguments are forwarded to +BitInt#new+
-      def u32(...) = u(32, ...)
+      def u32(...) = U32.new(self, ...)
 
       # Converts +self+ into an unsigned 64-bit integer.
       #
       # Any additional arguments are forwarded to +BitInt#new+
-      def u64(...) = u(64, ...)
+      def u64(...) = U64.new(self, ...)
 
       # Converts +self+ into an unsigned 128-bit integer.
       #
       # Any additional arguments are forwarded to +BitInt#new+
-      def u128(...) = u(128, ...)
+      def u128(...) = U128.new(self, ...)
 
       # Converts +self+ into a signed 8-bit integer.
       #
       # Any additional arguments are forwarded to +BitInt#new+
-      def i8(...) = i(8, ...)
+      def i8(...) = I8.new(self, ...)
 
       # Converts +self+ into a signed 16-bit integer.
       #
       # Any additional arguments are forwarded to +BitInt#new+
-      def i16(...) = i(16, ...)
+      def i16(...) = I16.new(self, ...)
 
       # Converts +self+ into a signed 32-bit integer.
       #
       # Any additional arguments are forwarded to +BitInt#new+
-      def i32(...) = i(32, ...)
+      def i32(...) = I32.new(self, ...)
 
       # Converts +self+ into a signed 64-bit integer.
       #
       # Any additional arguments are forwarded to +BitInt#new+
-      def i64(...) = i(64, ...)
+      def i64(...) = I64.new(self, ...)
 
       # Converts +self+ into a signed 128-bit integer.
       #
       # Any additional arguments are forwarded to +BitInt#new+
-      def i128(...) = i(128, ...)
+      def i128(...) = I128.new(self, ...)
     end
   end
 end

data/lib/bitint/version.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
-class BitInt < Numeric
+module BitInt
   # The current version of BitInt.
-  VERSION = '0.6.1'
+  VERSION = '0.7.0' #: String
 end