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.
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;}
}if the result is an aggregate, then type can be quailified const and the transitiveness will make all the sub-members read-only
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 xtype Foo struct {
x int
}
func (f *Foo) X() int {
return f.x
}x is private, because it is not capitalized.
(*Foo).X is a public getter (a read accessor).
(*Foo).X is a public getter (a read accessor).
module Foo (Foo, getX) where
import Data.IORef
data Foo = Foo { xRef :: IORef Integer }
getX = readIORef . xRefModules is the idiomatic way to hide fields in Haskell. We export Foo and the getter getX
class Foo {
#x = 123;
get x() {
return this.#x;
}
}Stores a private property #x in the class Foo which is accessible via a getter.
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) -- nillocal 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 tableThe foo table is a read-only proxy to private table. You can manipulate private inside Foo and any closures that capture it, but you can't do that through foo.
class Foo
{
/** @var int */
private $x;
public function getX(): int
{
return $this->x;
}
}PHP >= 7 required for the : int return type declaration.
class Foo
{
/** @var int */
private $x;
/**
* @return int
*/
public function getX()
{
return $this->x;
}
}PHP < 7 doesn't have declared types for variables or return values.
type Foo = class
private fx: integer;
public property x: integer read fx;
end;no need to use an accessor function here. a property reader does the trick.
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._xclass 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;
}
}