Creating a Special Integer - ruby

Question

I want to define a constant FOO in the namespace of Integer that is similar to Float::NAN in Float, which is itself an instance of Float. It will be used somewhat similar to symbols, i.e., to mark a special case (of an integer). I don't need it to be used in calculation, but I need it to have the following properties:
Its class must be Integer or a subclass of Integer, and it must behave so to methods related to class:
Integer::FOO.kind_of?(Integer) # => true
Optionally (if the class is Integer):
Integer::FOO.class # => Integer
Integer === Integer::FOO # => true
Integer::FOO.instance_of?(Integer) # => true
It must be distinct from (ideally all) other integers:
Integer::FOO == 0 # => false
Ideally, I want it distinct from any other integer, but if that is not possible, I can live with a dirty hack that, say makes Integer::FOO be identical to the largest or the smallest integer, which are the least likely to hit any random given integer.
What is the best way to go about this?

Answer 1

Ruby's metaprogramming methods make it easy to twist a generic object into the shape you desire:
class Integer
FOO = Object.new
end
Integer::FOO.define_singleton_method(:kind_of?) do |klass|
Integer.ancestors.include? klass
end
Integer::FOO.define_singleton_method(:class) do
Integer
end
Integer::FOO.define_singleton_method(:instance_of?) do |klass|
klass == Integer
end
oldteq = Integer.method(:===)
Integer.define_singleton_method(:===) do |obj|
obj == Integer::FOO ? true : oldteq.call(obj)
end
Integer::FOO.kind_of? Integer
# true
Integer::FOO.class
# Integer
Integer === Integer::FOO
# true
Integer::FOO.instance_of? Integer
# true
Integer::FOO == 0
# false
The tricky part is making sure you cover all of the use cases. My code handles all of the requirements you listed but I have no idea what kind of weird side effects such a strange object would create.

Answer 2

Another option is to create a true Integer instance using a C extension:
// IntegerFoo.c
#include "ruby.h"
void Init_integer_foo() {
// this should be the equivalent of "Integer.new"
NEWOBJ_OF(obj, struct RObject, rb_cInteger, T_OBJECT | (RGENGC_WB_PROTECTED_OBJECT ? FL_WB_PROTECTED : 0));
rb_define_const(rb_cInteger, "FOO", (VALUE)obj);
}
# extconf.rb
require 'mkmf'
dir_config('integer_foo')
create_makefile('integer_foo')
After building the extension ...
$ ruby extconf.rb
creating Makefile
$ make
compiling IntegerFoo.c
linking shared-object integer_foo.bundle
... the new constant can be used in Ruby and it seems to work as expected:
require './integer_foo'
Integer::FOO #=> #<Integer:0x007fe40c02c040>
Integer::FOO.kind_of? Integer #=> true
Integer::FOO.class #=> Integer
Integer === Integer::FOO #=> true
Integer::FOO.instance_of? Integer #=> true
Integer::FOO == 0 #=> false

Answer 3

I think the hack of picking an number you won't encounter anywhere is likely to be the cleanest solution.
class Integer
FOO = (1..100).map{rand(10)}.join.to_i
end
Satisfies all of your criteria, aside from being equal to a random 100-digit number.
You can still introduce some custom behavior with this trick:
# Allow singleton methods on Bignums
class Bignum
def singleton_method_added(meth)
true
end
end
class Integer
FOO = (1..100).map{rand(10)}.join.to_i
FOO.define_singleton_method(:to_s){'FOO'}
end
#Disallow singleton methods on Bignums once we've added all we're going to
class Bignum
def singleton_method_added(meth)
super
end
end
p Integer::FOO # FOO
1111111111111111111111111111111.define_singleton_method(:will_raise){}