> Yes, i know how instance is_a? works.

Apparently not.

	def is_a?(module)
	  self.class.ancestors.include? module
	end

	A.is_a? A # false since Module.ancestors =3D=3D [Module, Object, Kernel, B=
asicObject]
	Module.is_a? Module # true since Module.class =3D=3D Class and Class.ances=
tors =3D=3D [Class, Module, Object, Kernel, BasicObject]
	BasicObject.is_a? BasicObject # true since BasicObject.class =3D=3D Class =
and Class.ancestors =3D=3D [Class, Module, Object, Kernel, BasicObject]

Konstantin

On Feb 14, 2012, at 12:23 , Alex N wrote:

>=20
> Issue #6020 has been updated by Alex N.
>=20
>=20
> =3Dbegin
> Yes, i know how instance is_a? works. The problem is that the module owns=
 the same functionality as well.
> For example:
> module A; end
> A.class #=3D> Module
> A.is_a?(A) #=3D> false
> A.is_a?(A.class) #=3D> true
>=20
> From implementation perspective it's totally ok: Module is not A.
> But (({A.ancestors})) is (({[A]})), meanwhile (({Module.ancestors})) it t=
he whole set of the core objects. At the same time module A is an BasicObje=
ct.
> I'm not saying that it's completely wrong, but it feels confusing. On the=
 other had it's really really edge case.
> =3Dend
>=20
> ----------------------------------------
> Bug #6020: Unexpected is_a/kind_of behaviour
> https://bugs.ruby-lang.org/issues/6020
>=20
> Author: Alex N
> Status: Feedback
> Priority: Low
> Assignee:=20
> Category: core
> Target version:=20
> ruby -v: ruby 2.0.0dev (2012-02-14 trunk 34598) [x86_64-darwin11.3.0]
>=20
>=20
> =3Dbegin
> I've noticed some inconsistent is_a?/kind_of? methods behavior in a very =
special cases
> self.class #=3D> Object
>=20
> BasicObject.is_a?(BasicObject) #=3D> true
> Module.is_a?(Module) #=3D> true
> Class.is_a?(Class) #=3D> true
> Object.is_a?(Object) #=3D> true
>=20
> BasicObject.is_a?(Module) #=3D> true
>=20
> Integer.is_a?(Integer) #=3D> false
> class A; end
> A.is_a?(A) #=3D> false
>=20
> module B; end
> B.is_a?(B) #=3D> false
>=20
> class C < Object; end
> C.is_a?(C) #=3D> false
> C.is_a?(Object) #=3D> true
> C.is_a?(BasicObject) #=3D> true
> C.is_a?(Module) #=3D> true
> C.is_a?(Class) #=3D> true
>=20
> c =3D C.new
> c.is_a?(Module) #=3D> false
> c.is_a?(Class) #=3D> false
>=20
> It looks like it's because Class, Module, Object and BasicObject have cla=
ss Class, superclass is set properly.=20
> Anyway all is logical but not expected.=20
> =3Dend
>=20
>=20
>=20
>=20
> --=20
> http://bugs.ruby-lang.org/
>=20