# Implicit Conversions¶ ↑

Some Ruby methods accept one or more objects that can be either:

- Of a given class, and so accepted as is.

- Implicitly convertible to that class, in which case the called method converts the object.

For each of the relevant classes, the conversion is done by calling a specific conversion method:

- Array: `to_ary`

- Hash: `to_hash`

- Integer: `to_int`

- String: `to_str`

## Array-Convertible Objects¶ ↑

An Array-convertible object is an object that:

- Has instance method `to_ary`.

- The method accepts no arguments.

- The method returns an object `obj` for which `obj.kind_of?(Array)` returns `true`.

The Ruby core class that satisfies these requirements is:

- `Array`

The examples in this section use method `Array#replace`, which accepts an Array-convertible argument.

This class is Array-convertible:

    class ArrayConvertible
      def to_ary
        [:foo, 'bar', 2]
      end
    end
    a = []
    a.replace(ArrayConvertible.new) # => [:foo, "bar", 2]

This class is not Array-convertible (no `to_ary` method):

    class NotArrayConvertible; end
    a = []
    # Raises TypeError (no implicit conversion of NotArrayConvertible into Array)
    a.replace(NotArrayConvertible.new)

This class is not Array-convertible (method `to_ary` takes arguments):

    class NotArrayConvertible
      def to_ary(x)
        [:foo, 'bar', 2]
      end
    end
    a = []
    # Raises ArgumentError (wrong number of arguments (given 0, expected 1))
    a.replace(NotArrayConvertible.new)

This class is not Array-convertible (method `to_ary` returns non-Array):

    class NotArrayConvertible
      def to_ary
        :foo
      end
    end
    a = []
    # Raises TypeError (can't convert NotArrayConvertible to Array (NotArrayConvertible#to_ary gives Symbol))
    a.replace(NotArrayConvertible.new)

## Hash-Convertible Objects¶ ↑

A Hash-convertible object is an object that:

- Has instance method `to_hash`.

- The method accepts no arguments.

- The method returns an object `obj` for which `obj.kind_of?(Hash)` returns `true`.

The Ruby core class that satisfies these requirements is:

- `Hash`

The examples in this section use method `Hash#merge`, which accepts a Hash-convertible argument.

This class is Hash-convertible:

    class HashConvertible
      def to_hash
        {foo: 0, bar: 1, baz: 2}
      end
    end
    h = {}
    h.merge(HashConvertible.new) # => {:foo=>0, :bar=>1, :baz=>2}

This class is not Hash-convertible (no `to_hash` method):

    class NotHashConvertible; end
    h = {}
    # Raises TypeError (no implicit conversion of NotHashConvertible into Hash)
    h.merge(NotHashConvertible.new)

This class is not Hash-convertible (method `to_hash` takes arguments):

    class NotHashConvertible
      def to_hash(x)
        {foo: 0, bar: 1, baz: 2}
      end
    end
    h = {}
    # Raises ArgumentError (wrong number of arguments (given 0, expected 1))
    h.merge(NotHashConvertible.new)

This class is not Hash-convertible (method `to_hash` returns non-Hash):

    class NotHashConvertible
      def to_hash
        :foo
      end
    end
    h = {}
    # Raises TypeError (can't convert NotHashConvertible to Hash (ToHashReturnsNonHash#to_hash gives Symbol))
    h.merge(NotHashConvertible.new)

## Integer-Convertible Objects¶ ↑

An Integer-convertible object is an object that:

- Has instance method `to_int`.

- The method accepts no arguments.

- The method returns an object `obj` for which `obj.kind_of?(Integer)` returns `true`.

The Ruby core classes that satisfy these requirements are:

- `Integer`

- `Float`

- `Complex`

- `Rational`

The examples in this section use method `Array.new`, which accepts an Integer-convertible argument.

This user-defined class is Integer-convertible:

    class IntegerConvertible
      def to_int
        3
      end
    end
    a = Array.new(IntegerConvertible.new).size
    a # => 3

This class is not Integer-convertible (method `to_int` takes arguments):

    class NotIntegerConvertible
      def to_int(x)
        3
      end
    end
    # Raises ArgumentError (wrong number of arguments (given 0, expected 1))
    Array.new(NotIntegerConvertible.new)

This class is not Integer-convertible (method `to_int` returns non-Integer):

    class NotIntegerConvertible
      def to_int
        :foo
      end
    end
    # Raises TypeError (can't convert NotIntegerConvertible to Integer (NotIntegerConvertible#to_int gives Symbol))
    Array.new(NotIntegerConvertible.new)

## String-Convertible Objects¶ ↑

A String-convertible object is an object that:

- Has instance method `to_str`.

- The method accepts no arguments.

- The method returns an object `obj` for which `obj.kind_of?(String)` returns `true`.

The Ruby core class that satisfies these requirements is:

- `String`

The examples in this section use method `String::new`, which accepts a String-convertible argument.

This class is String-convertible:

    class StringConvertible
      def to_str
        'foo'
      end
    end
    String.new(StringConvertible.new) # => "foo"

This class is not String-convertible (no `to_str` method):

    class NotStringConvertible; end
    # Raises TypeError (no implicit conversion of NotStringConvertible into String)
    String.new(NotStringConvertible.new)

This class is not String-convertible (method `to_str` takes arguments):

    class NotStringConvertible
      def to_str(x)
        'foo'
      end
    end
    # Raises ArgumentError (wrong number of arguments (given 0, expected 1))
    String.new(NotStringConvertible.new)

This class is not String-convertible (method `to_str` returns non-String):

    class NotStringConvertible
      def to_str
        :foo
      end
    end
    # Raises TypeError (can't convert NotStringConvertible to String (NotStringConvertible#to_str gives Symbol))
    String.new(NotStringConvertible.new)