Uniform access principle

Ruby

Consider the following

y = Egg.new( "Green")
y.color = "White" 
puts y.color

Now the Egg class could be defined as follows

class Egg
  attr_accessor :color
  def initialize( color )
    @color = color
  end
end

The above initial code segment would work fine with the Egg being defined as such. The Egg class could also be defined as below, where color is instead a method. The calling code would still work, unchanged if Egg were to be defined as follows.

class Egg
  
  def initialize(color)
    @rgb_color = to_rgb(color)
  end

  def color
     to_color_name(@rgb_color)
  end
 
  def color=(color) 
     @rgb_color = to_rgb(color)
  end

  private
  def to_rgb(color_name)
     .....
  end

  def to_color_name(color)
     ....
  end
end

Note how even though color looks like an attribute in one case and a pair of methods in the next, the interface to the class remains the same. The person maintaining the Egg class can switch from one form to the other without fear of breaking any caller's code. Ruby follows the revised UAP, the attr_accessor :color only acts as syntactic sugar for generating accessor/setter methods for color. There is no way in Ruby to retrieve an instance variable from an object without calling a method on it.

Strictly speaking, Ruby does not follow Meyer's original UAP in that the syntax for accessing an attribute is different from the syntax for invoking a method. But here, the access for an attribute will always actually be through a function which is often automatically generated. So in essence, either type of access invokes a function and the language does follow Meyer's revised Uniform Access Principle.

Python

Python properties may be used to allow a method to be invoked with the same syntax as accessing an attribute. Whereas Meyer's UAP would have a single notation for both attribute access and method invocation (method invocation syntax), a language with support for properties still supports separate notations for attribute and method access. Properties allow the attribute notation to be used, but to hide the fact that a method is being invoked instead of simply retrieving or setting a value.

In the strict sense, Python does NOT follow the UAP because there is a syntax difference between normal method invocations and attribute access.

In Python, we may have code that access an object as follows

>>> egg = Egg( 4, "White")
>>> egg.color = "Green"
>>> print egg.weight, egg.color, egg.quack()
4 Green quack

A Egg object could be defined such that weight and color are simple attributes as in the following

class Egg(object):
    def __init__(self, weight, color):
        self.weight = weight
        self.color = color
    def quack(self):
        return "quack"

Or the Egg object could use properties, and invoke methods instead

class Egg(object):
    def __init__(self, weight, color):
        self.__weight = toGrams(weight)
        self.__color = toRGB(color)

    def setColor(self, colorname):
        self.__color = toRGB(colorname)

    def getColor(self):
        return toColorName(self.__color)
    
    color = property(getColor, setColor, doc="Color of the Egg")

    def setWeight(self, weightOz);
        self.__weight = 29.3*weightOz

    def getWeight(self):
        return self.__weight/29.3;

    weight = property(setWeight, getWeight, doc="Weight in Ounces")

    def quack(self):
        return "quack"

Regardless of which way Egg is defined, the calling code can remain the same. The implementation of Egg can switch from one form to the other without affecting code that uses the Egg class. Languages which implement the UAP have this property as well.

C#

The C# language supports class properties, which provide a means to define get and set operations (getters and setters) for a member variable. The syntax to access or modify the property is the same as accessing any other class member variable, but the actual implementation for doing so can be defined as either a simple read/write access or as functional code.

class Foo
{
    // Property
    int Size
    {
        get;    // Getter
        set;    // Setter
    }

    // Property
    string Name
    {
        get { return name_; }     // Getter
        set { name_ = value; }    // Setter
    }

    private string  name_;
}

In the example above, class Foo contains two properties, Size and Name . The Size property is an integer that can be read (get) and written (set). Similarly, the Name property is a string that can also be read and modified, but its value is stored in a separate (private) class variable name_ .

Omitting the set operation in a property definition makes the property read-only, while omitting the get operation makes it write-only.

Use of the properties employs the UAP, as shown in the code below.

    Foo MakeFoo(int mySize, string myName)
    {
        Foo  myFoo = new Foo();
        myFoo.Size = mySize;       // Property setter
        myFoo.Name = myName;       // Property setter
        return myFoo;
    }

C++

C++ has neither the UAP nor properties, when an object is changed such that an attribute (color) becomes a pair of functions (getA, setA). Any place in that uses an instance of the object and either sets or gets the attribute value ( x = obj.color or obj.color= x) must be changed to invoke one of the functions. ( x = obj.getColor() or obj.setColor(x)). Using templates and operator overloading, it is possible to fake properties, but this is more complex than in languages which directly support properties. This complicates maintenance of C++ programs. Distributed libraries of C++ objects must be careful about how they provide access to member data.