anchor.diff:  endif::env-github[]
   
   Corefines is a collection of general purpose _refinements_ for extending the core capabilities of Ruby’s built-in classes.
  -It also provides a compatibility mode for older Ruby versions and alternative Ruby implementations that don’t support refinements (yet).
  +It also provides a <<compatibility-mode>> for older Ruby versions and alternative Ruby implementations that don’t support refinements (yet).
   
   
   == Why refinements?
  
positive.code: 
  * https://github.com/rails/rails/tree/master/activesupport[Active Support (Ruby extensions)]
  * https://github.com/rubyworks/facets[Ruby Facets]
  * https://github.com/fazibear/colorize[colorize]
  
  Very useful articles about refinements and how to “trick” them:
  
negative.code: 
  == Compatibility mode
  
  Refinements are still a quite young feature, so there’s a good chance that your gem or application will have to work on a Ruby platform that doesn’t fully support refinements yet.
  
  The main Ruby implementation, https://en.wikipedia.org/wiki/Ruby_MRI[MRI] (aka CRuby), supports refinements since version 2.1.0 (https://www.ruby-lang.org/en/news/2013/12/25/ruby-2-1-0-is-released/[released in 25 Dec 2013]).
  footnote:[Actually, refinements has been introduced to MRI in 2.0.0, as an experimental feature. However, its design and implementation has been changed then, so refinements in 2.0.x and 2.1+ behaves quite differently.]
  Version 2.0.0 (https://www.ruby-lang.org/en/news/2013/02/24/ruby-2-0-0-p0-is-released/[released in 24 Feb 2013]) is still supported though.
  http://www.jruby.org/[JRuby] doesn’t support refinements yet, it’s planned in the upcoming version 9.0.0.0 (https://github.com/jruby/jruby/issues/1062[#1062]).
  http://rubini.us/[Rubinius] also doesn’t support refinements yet.
  
  This gem is a collection of pure refinements, and yet, it works even on older Rubies that doesn’t support refinements.
  
  Wait… how?
  Well, when running on older Ruby, it’s actually cheating.
  Instead of locally scoped changes, it fallbacks to global monkey-patching.
  
  Corefines adds `refine` and `using` methods to the core classes, so you can define and use refinements just like on newer Rubies.
  But internally it works very differently.
  The `refine` method adds a given block to a collection of pending “refinements” inside its module.
  When `using` is called _first time_ for the module, it _evaluates_ module’s “refinements” in context of the target classes (i.e. do a monkey-patch).
  
  Not ideal indeed, but probably the best of what we can achieve.
  
  
  == List of refinements
  