Question

我想在FOO的名称空间中定义一个常量Integer，它类似于Float::NAN中的Float，Float本身就是Integer的一个实例。它将在某种程度上类似于符号使用，即标记特殊情况（整数）。我不需要它用于计算，但我需要它具有以下属性：

它的类必须是Integer或Integer::FOO.kind_of?(Integer) # => true的子类，并且它必须对与类相关的方法起作用：
```
Integer
```
可选（如果课程为Integer::FOO.class # => Integer Integer === Integer::FOO # => true Integer::FOO.instance_of?(Integer) # => true）：
```
Integer::FOO == 0 # => false
```
它必须与（理想情况下所有）其他整数不同：
```
Integer::FOO
```
理想情况下，我希望它与任何其他整数不同，但如果这是不可能的，我可以忍受一个肮脏的黑客，比如使得{{1}}与最大或最小整数相同，这是最不可能击中任何随机给定的整数。

最好的方法是什么？

Answer 1

Ruby的元编程方法可以很容易地将通用对象转换为您想要的形状：

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

棘手的部分是确保涵盖所有用例。我的代码处理你列出的所有要求，但我不知道这样一个奇怪的对象会产生什么样的奇怪副作用。

Answer 2

另一种选择是使用C扩展名创建一个真实的Integer实例：

// 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')

构建扩展程序后......

$ ruby extconf.rb
creating Makefile
$ make
compiling IntegerFoo.c
linking shared-object integer_foo.bundle

...新常量可以在Ruby中使用，它似乎按预期工作：

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

我认为选择一个你不会在任何地方遇到的数字的黑客可能是最干净的解决方案。

class Integer
  FOO = (1..100).map{rand(10)}.join.to_i
end

满足您的所有标准，除了等于随机的100位数字。

你仍然可以通过这个技巧引入一些自定义行为：

# 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){}

创建特殊整数

3 个答案: