From: "trans (Thomas Sawyer)" <transfire@...>
Date: 2012-03-23T02:08:32+09:00
Subject: [ruby-core:43558] [ruby-trunk - Feature #3908] private constant


Issue #3908 has been updated by trans (Thomas Sawyer).


What was this deemed significant? I can't think of single reason why anyone would actually have to have a "private", as opposed to a "public", constant. Constants are CONSTANT so they aren't supposed to be changed after they are defined anyway --indeed normal channels of doing so will cause a warning. And constants aren't methods, so they aren't something you can call to effect object state. So what's the point? Why add all this new complexity for working with constants, e.g. #private_constants vs. #public_constants? I just see additional headache with nothing at all gained.

----------------------------------------
Feature #3908: private constant
https://bugs.ruby-lang.org/issues/3908#change-25047

Author: mame (Yusuke Endoh)
Status: Closed
Priority: Normal
Assignee: mame (Yusuke Endoh)
Category: core
Target version: 1.9.3


=begin
 Hi,
 
 I'd propose "private constant."
 Private constant provides method-like visibility for constant.
 
 
 === Sample code ===
 
   module SomeModule
     class PublicClass
       ...
     end
 
     class PrivateClass
       ...
     end
 
     # you can make "PrivateClass" private by private_constant method
     private_constant :PrivateClass
   end
 
   # we can refer access constant as is conventionally done
   p SomeModule::PublicClass  #=> SomeModule::PublicClass
 
   # a RuntimeError is raised when we attempt to refer private constant
   p SomeModule::PrivateClass  #=> private constant (RuntimeError)
 
   # we can even refer private constant from its parent scope
   module SomeModule
     p PrivateClass  #=> SomeModule::PrivateClass
   end
 
 
 === Background ===
 
 Traditionally, there is no way to prevent users from using your classes.
 It is too easy for user to access any internal class (e.g., CGI::Html3,
 Enumerator::Generator, Matrix::Scalar, URI::Util, etc).
 We can only write a document to ask users not to use them.
 
 RubySpec inspired me to propose this feature.  RubySpec declares the
 policy that no spec should be written for private method.  Nevertheless,
 there were some specs for internal classes, such as CGI::Html3 (FYI,
 such specs are already deleted).
 I thought this was because there is no way to explicitly declare that
 the constants are "internal use only."
 
 
 === Proposal ===
 
 Private constant is a scoped constant that can be referred only from
 its parent scope.  It can be used for declaring "the constant is
 for internal use," like private method.
 
 When users try to refer private constant, they can realize that they
 are going to use non-guaranteed feature, because the constant cannot
 be referred so easily.  Even so, they can use such a feature with
 self-responsibility, by explicitly opening its parent scope.
 
 Since the default visibility is public, this feature does not break
 any compatibility.
 
 
 === Current status ===
 
 I first suggested this at [ruby-dev:39685].
 Matz approved my proposal [ruby-dev:39686]
 Yugui has also approved [ruby-dev:40254], but said that it is needed
 to discuss in ruby-core list before commit.
 
 The patches are attached.  make check and make test-rubyspec are all
 passed.
 
 
 What do you think?
 I'll commit the patch unless there is objection.
 
 -- 
 Yusuke ENDOH <mame@tsg.ne.jp>
=end



-- 
http://bugs.ruby-lang.org/