From 3b92ebb3ac1326e43ee73add74bcdc581f16ab02 Mon Sep 17 00:00:00 2001
From: Joe Corcoran <joecorcoran@gmail.com>
Date: Sun, 27 Sep 2015 18:47:12 +0200
Subject: [PATCH] Add documentation for general use of Numeric

---
 numeric.c | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 69 insertions(+), 1 deletion(-)

diff --git a/numeric.c b/numeric.c
index 10ed43c..8a967bb 100644
--- a/numeric.c
+++ b/numeric.c
@@ -4070,7 +4070,75 @@ fix_even_p(VALUE num)
  */
 
 /*
- *  The top-level number class.
+ * Document-class: Numeric
+ *
+ * Numeric is the class from which all higher-level numeric classes should inherit.
+ * 
+ * Numeric allows instantiation of heap-allocated objects. Other core numeric classes such as
+ * Integer are implemented as immediates, which means that each Integer is a single immutable
+ * object which is always passed by value.
+ * 
+ *   a = 1
+ *   puts 1.object_id == a.object_id   #=> true
+ * 
+ * There can only ever be one instance of the integer +1+, for example. Ruby ensures this
+ * by preventing instantiation and duplication.
+ * 
+ *   Integer.new(1)   #=> NoMethodError: undefined method `new' for Integer:Class
+ *   1.dup            #=> TypeError: can't dup Fixnum
+ * 
+ * For this reason, Numeric should be used when defining other numeric classes.
+ * 
+ * Classes which inherit from Numeric must implement +coerce+, which returns a two-member
+ * Array containing an object that has been coerced into an instance of the new class
+ * and +self+ (see #coerce).
+ * 
+ * Inheriting classes should also implement arithmetic operator methods (<code>+</code>,
+ * <code>-</code>, <code>*</code> and <code>/</code>) and the <code><=></code> operator (see
+ * Comparable). These methods may rely on +coerce+ to ensure interoperability with
+ * instances of other numeric classes.
+ * 
+ *   class Tally < Numeric
+ *     def initialize(string)
+ *       @string = string
+ *     end
+ * 
+ *     def to_s
+ *       @string
+ *     end
+ * 
+ *     def to_i
+ *       @string.size
+ *     end
+ * 
+ *     def coerce(other)
+ *       [self.class.new('|' * other.to_i), self]
+ *     end
+ * 
+ *     def <=>(other)
+ *       to_i <=> other.to_i
+ *     end
+ * 
+ *     def +(other)
+ *       self.class.new('|' * (to_i + other.to_i))
+ *     end
+ * 
+ *     def -(other)
+ *       self.class.new('|' * (to_i - other.to_i))
+ *     end
+ * 
+ *     def *(other)
+ *       self.class.new('|' * (to_i * other.to_i))
+ *     end
+ * 
+ *     def /(other)
+ *       self.class.new('|' * (to_i / other.to_i))
+ *     end
+ *   end
+ * 
+ *   tally = Tally.new('||')
+ *   puts tally * 2            #=> "||||"
+ *   puts tally > 1            #=> true
  */
 void
 Init_Numeric(void)