Logo

Programming-Idioms

# 90 Read-only outside
Expose a read-only integer x to the outside world while being writable inside a structure or a class Foo.
New implementation

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating material.

Please try to avoid dependencies to third-party libraries and frameworks.

Other implementations 
package Foos is
      
   type Foo is private;
      
   function X (Self : Foo) return Integer;
      
private
   type Foo is
      record
         X : Integer;
      end record;
      
end Foos;
   
package body Foos is
      
   function X (Self : Foo) return Integer is (Self.X);
      
end Foos;
class Foo final {
  int mX = 0;

public:
  const auto& X() const { return mX; }
};
class Foo
{
	public int x { get; private set; }
}
struct Foo
{
    private int _x;
    int x() {return _x;}
}
class Foo{
  int _x = 0;
  int get x => _x;  
}
module x
  implicit none
  type foo
     integer, private :: x
   contains
     procedure :: readx
  end type foo
contains
  integer function readx(f)
    class(foo) :: f
    readx = f%x
  end function readx
end module x
type Foo struct {
	x int
}

func (f *Foo) X() int {
	return f.x
}
module Foo (Foo, getX) where

import Data.IORef

data Foo = Foo { xRef :: IORef Integer }

getX = readIORef . xRef
class Foo {
  #x = 123;
  get x() {
    return this.#x;
  }
}
const Foo = function Counter () {
  let n = 0
  Object.defineProperty (this, 'value', {get: () => n++})
}
{
  const counter = new Foo ()
  counter.value // 0
  counter.value // 1
}
public class Foo {
    private int x;
    private void set(int x) { this.x = x; }
    public int get() { return x; }
}
public class Foo {
    private int x;

    public int getX() {
        return x;
    }
}

local Foo = {}
do
	local x = 0
	Foo.getX = function()
		return x
	end
end
print(Foo.getX()) -- 0
print(x) -- nil
local function Foo()
    local private = {x = 9}
    local mt = {
        __index = private,
        __newindex = function (t, k, v)
            error("attempt to update a read-only table", 2)
        end
    }
    return setmetatable({}, mt)
end

local foo = Foo()
print(foo.x) -- 9
foo.x = 3    -- error: attempt to update a read-only table
class Foo
{
    /** @var int */
    private $x;

    public function getX(): int
    {
        return $this->x;
    }
}
class Foo
{
    /** @var int */
    private $x;

    /**
     * @return int
     */
    public function getX()
    {
        return $this->x;
    }
}
type Foo = class
  private fx: integer;
  public property x: integer read fx;
end;
use Moops;
class Foo {
    lexical_has 'x', isa => Int, accessor => \(my $_x), default => 0;
    method x() { return $self->$_x }
    method increment_x() { $self->$_x(1 + $self->$_x) }
}

class Foo(object):
    def __init__(self):
        self._x = 0

    @property
    def x(self):
        """
        Doc for x
        """
        return self._x
class Foo:
    def __init__(self, value):
        self._set_x(value)
    def _set_x(self, value):
        self._x = value
    def get_x(self):
        return self._x
class Foo

  def initialize
    @x = rand(10)
  end

  def x
    @x
  end

end


struct Foo {
    x: usize
}

impl Foo {
    pub fn new(x: usize) -> Self {
        Foo { x }
    }

    pub fn x<'a>(&'a self) -> &'a usize {
        &self.x
    }

    pub fn bar(&mut self) {
        self.x += 1;
    }
}

Preview