all tasks

Task/Singleton/0DESCRIPTION

@@ -0,0 +1 @@
+A Global Singleton is a class of which only one instance exists within a program. Any attempt to use non-static members of the class involves performing operations on this one instance.

Task/Singleton/1META.yaml

@@ -0,0 +1,2 @@
+---
+note: Object oriented

Task/Singleton/ActionScript/singleton.as

@@ -0,0 +1,20 @@
+package
+{
+    public class Singleton
+    {
+
+        private static var instance:Singleton;
+
+        // ActionScript does not allow private or protected constructors.
+        public function Singleton(enforcer:SingletonEnforcer) {
+
+        }
+
+        public static function getInstance():Singleton {
+            if (instance == null) instance = new Singleton(new SingletonEnforcer());
+            return instance;
+        }
+    }
+}
+
+internal class SingletonEnforcer {}

Task/Singleton/Ada/singleton-1.ada

@@ -0,0 +1,10 @@
+package Global_Singleton is
+   procedure Set_Data (Value : Integer);
+   function Get_Data return Integer;
+private
+   type Instance_Type is record
+      -- Define instance data elements
+      Data : Integer := 0;
+   end record;
+   Instance : Instance_Type;
+end Global_Singleton;

Task/Singleton/Ada/singleton-2.ada

@@ -0,0 +1,21 @@
+package body Global_Singleton is
+
+   --------------
+   -- Set_Data --
+   --------------
+
+   procedure Set_Data (Value : Integer) is
+   begin
+      Instance.Data := Value;
+   end Set_Data;
+
+   --------------
+   -- Get_Data --
+   --------------
+
+   function Get_Data return Integer is
+   begin
+      return Instance.Data;
+   end Get_Data;
+
+end Global_Singleton;

Task/Singleton/Ada/singleton-3.ada

@@ -0,0 +1,11 @@
+package Protected_Singleton is
+   procedure Set_Data (Value : Integer);
+   function Get_Data return Integer;
+private
+   protected Instance is
+      procedure Set(Value : Integer);
+      function Get return Integer;
+   private
+      Data : Integer := 0;
+   end Instance_Type;
+end Protected_Singleton;

Task/Singleton/Ada/singleton-4.ada

@@ -0,0 +1,47 @@
+package body Protected_Singleton is
+
+   --------------
+   -- Set_Data --
+   --------------
+
+   procedure Set_Data (Value : Integer) is
+   begin
+      Instance.Set(Value);
+   end Set_Data;
+
+   --------------
+   -- Get_Data --
+   --------------
+
+   function Get_Data return Integer is
+   begin
+      return Instance.Get;
+   end Get_Data;
+
+   --------------
+   -- Instance --
+   --------------
+
+   protected body Instance is
+
+      ---------
+      -- Set --
+      ---------
+
+      procedure Set (Value : Integer) is
+      begin
+         Data := Value;
+      end Set;
+
+      ---------
+      -- Get --
+      ---------
+
+      function Get return Integer is
+      begin
+         return Data;
+      end Get;
+
+   end Instance;
+
+end Protected_Singleton;

Task/Singleton/AutoHotkey/singleton.ahk

@@ -0,0 +1,28 @@
+b1 := borg()
+b2 := borg()
+msgbox % "b1 is b2? " . (b1 == b2)
+b1.datum := 3
+msgbox % "b1.datum := 3`n...`nb1 datum: " b1.datum "`nb2 datum: " b2.datum ; is 3 also
+msgbox % "b1.datum is b2.datum ? " (b1.datum == b2.datum)
+return
+
+
+borg(){
+   static borg
+   If !borg
+      borg := Object("__Set", "Borg_Set"
+                   , "__Get", "Borg_Get")
+   return object(1, borg, "base", borg)
+}
+
+
+Borg_Get(brg, name)
+{
+  Return brg[1, name]
+}
+
+Borg_Set(brg, name, val)
+{
+  brg[1, name] := val
+  Return val
+}

Task/Singleton/C++/singleton-1.cpp

@@ -0,0 +1,38 @@
+class Singleton
+{
+public:
+     static Singleton* Instance()
+     {
+          // We need to ensure that we don't accidentally create two Singletons
+          HANDLE hMutex = CreateMutex(NULL, FALSE, "MySingletonMutex");
+          WaitForSingleObject(hMutex, INFINITE);
+
+          // Create the instance of the class.
+          // Since it's a static variable, if the class has already been created,
+          // It won't be created again.
+          static Singleton myInstance;
+
+          // Release our mutex so that other application threads can use this function
+          ReleaseMutex( hMutex );
+
+          // Free the handle
+          CloseHandle( hMutex );
+
+          // Return a pointer to our mutex instance.
+          return &myInstance;
+     }
+
+     // Any other public methods
+
+protected:
+     Singleton()
+     {
+          // Constructor code goes here.
+     }
+     ~Singleton()
+     {
+          // Destructor code goes here.
+     }
+
+     // And any other protected methods.
+}

Task/Singleton/C++/singleton-2.cpp

@@ -0,0 +1,27 @@
+class Singleton
+{
+public:
+     static Singleton* Instance()
+     {
+          // Since it's a static variable, if the class has already been created,
+          // It won't be created again.
+          static Singleton myInstance;
+
+          // Return a pointer to our mutex instance.
+          return &myInstance;
+     }
+
+     // Any other public methods
+
+protected:
+     Singleton()
+     {
+          // Constructor code goes here.
+     }
+     ~Singleton()
+     {
+          // Destructor code goes here.
+     }
+
+     // And any other protected methods.
+}

Task/Singleton/C/singleton-1.c

@@ -0,0 +1,7 @@
+#ifndef SILLY_H
+#define SILLY_H
+
+extern void JumpOverTheDog( int numberOfTimes);
+extern int  PlayFetchWithDog( float weightOfStick);
+
+#endif

Task/Singleton/C/singleton-2.c

@@ -0,0 +1,25 @@
+...
+#include "silly.h"
+
+struct sDog {
+   float max_stick_weight;
+   int   isTired;
+   int   isAnnoyed;
+};
+
+static struct sDog lazyDog = { 4.0, 0,0 };
+
+/* define functions used by the functions in header as static */
+static int RunToStick( )
+{...
+}
+/* define functions declared in the header file. */
+
+void JumpOverTheDog(int numberOfTimes)
+{ ...
+   lazyDog.isAnnoyed = TRUE;
+}
+int PlayFetchWithDog( float weightOfStick )
+{ ...
+   if(weightOfStick < lazyDog.max_stick_weight){...
+}

Task/Singleton/C/singleton-3.c

@@ -0,0 +1,7 @@
+...
+#include "silly.h"
+...
+/* code using the dog methods */
+   JumpOverTheDog( 4);
+   retrieved = PlayFetchWithDog( 3.1);
+...

Task/Singleton/Common-Lisp/singleton.lisp

@@ -0,0 +1,24 @@
+(defgeneric concat (a b)
+  (:documentation "Concatenate two phrases."))
+
+(defclass nonempty-phrase ()
+  ((text :initarg :text :reader text)))
+
+(defmethod concat ((a nonempty-phrase) (b nonempty-phrase))
+  (make-instance 'nonempty-phrase :text (concatenate 'string (text a) " " (text b))))
+
+(defmethod concat ((a (eql 'the-empty-phrase)) b)
+  b)
+
+(defmethod concat (a (b (eql 'the-empty-phrase)))
+  a)
+
+(defun example ()
+  (let ((before (make-instance 'nonempty-phrase :text "Jack"))
+        (mid (make-instance 'nonempty-phrase :text "went"))
+        (after (make-instance 'nonempty-phrase :text "to fetch a pail of water")))
+    (dolist (p (list 'the-empty-phrase
+                     (make-instance 'nonempty-phrase :text "and Jill")))
+      (dolist (q (list 'the-empty-phrase
+                       (make-instance 'nonempty-phrase :text "up the hill")))
+        (write-line (text (reduce #'concat (list before p mid q after))))))))

Task/Singleton/D/singleton.d

@@ -0,0 +1,61 @@
+module singleton ;
+import std.stdio ;
+import std.thread ;
+import std.random ;
+import std.c.time ;
+
+class Dealer {
+  private static Dealer me ;
+  static Dealer Instance() {
+    writefln("   Calling Dealer... ") ;
+    if(me is null) // Double Checked Lock
+      synchronized  // this part of code can only be executed by one thread a time
+        if(me is null)
+          me = new Dealer ;
+    return me ;
+  }
+  private static string[] str = ["(1)Enjoy", "(2)Rosetta", "(3)Code"] ;
+  private int state ;
+  private this() {
+    for(int i = 0 ; i < 3 ; i++) {
+      writefln("...calling Dealer... ") ;
+      msleep(rand() & 2047) ;
+    }
+    writefln(">>Dealer is called to come in!") ;
+    state = str.length - 1 ;
+  }
+  Dealer nextState() {
+    synchronized(this) // accessed to Object _this_ is locked ... is it necessary ???
+      state = (state + 1) % str.length ;
+    return this ;
+  }
+  string toString() { return str[state] ; }
+}
+
+class Coder : Thread {
+  private string name_ ;
+  Coder hasName(string name) {  name_ = name ; return this ; }
+  override int run() {
+    msleep(rand() & 1023) ;
+    writefln(">>%s come in.", name_) ;
+    Dealer single = Dealer.Instance ;
+    msleep(rand() & 1023) ;
+    for(int i = 0 ; i < 3 ; i++) {
+      writefln("%9s got %-s", name_, single.nextState) ;
+      msleep(rand() & 1023) ;
+    }
+    return 0 ;
+  }
+}
+
+void main() {
+  Coder x = new Coder ;
+  Coder y = new Coder ;
+  Coder z = new Coder ;
+
+  x.hasName("Peter").start() ;
+  y.hasName("Paul").start() ;
+  z.hasName("Mary").start() ;
+
+  x.wait ;  y.wait ;  z.wait ;
+}

Task/Singleton/Delphi/singleton.delphi

@@ -0,0 +1,40 @@
+unit Singleton;
+
+interface
+
+type
+  TSingleton = class
+  private
+    //Private fields and methods here...
+
+     class var _instance: TSingleton;
+  protected
+    //Other protected methods here...
+  public
+    //Global point of access to the unique instance
+    class function Create: TSingleton;
+
+    destructor Destroy; override;
+
+    //Other public methods and properties here...
+  end;
+
+implementation
+
+{ TSingleton }
+
+class function TSingleton.Create: TSingleton;
+begin
+  if (_instance = nil) then
+    _instance:= inherited Create as Self;
+
+  result:= _instance;
+end;
+
+destructor TSingleton.Destroy;
+begin
+  _instance:= nil;
+  inherited;
+end;
+
+end.

Task/Singleton/E/singleton.e

@@ -0,0 +1,3 @@
+def aSingleton {
+  # ...
+}

Task/Singleton/Erlang/singleton-1.erl

@@ -0,0 +1,33 @@
+-module(singleton).
+
+-export([get/0, set/1, start/0]).
+
+-export([loop/1]).
+
+% spec singleton:get() -> {ok, Value::any()} | not_set
+get() ->
+     ?MODULE ! {get, self()},
+     receive
+	{ok, not_set} -> not_set;
+        Answer -> Answer
+     end.
+
+% spec singleton:set(Value::any()) -> ok
+set(Value) ->
+    ?MODULE ! {set, self(), Value},
+    receive
+        ok -> ok
+    end.
+
+start() ->
+    register(?MODULE, spawn(?MODULE, loop, [not_set])).
+
+loop(Value) ->
+    receive
+        {get, From} ->
+             From ! {ok, Value},
+             loop(Value);
+        {set, From, NewValue} ->
+             From ! ok,
+             loop(NewValue)
+        end.

Task/Singleton/Erlang/singleton-2.erl

@@ -0,0 +1,14 @@
+1> singleton:get().
+not_set
+2> singleton:set(apple).
+ok
+3> singleton:get().
+{ok,apple}
+4> singleton:set("Pear").
+ok
+5> singleton:get().
+{ok,"Pear"}
+6> singleton:set(42).
+ok
+7> singleton:get().
+{ok,42}

Task/Singleton/Factor/singleton.factor

@@ -0,0 +1,6 @@
+USING: classes.singleton kernel io prettyprint ;
+IN: singleton-demo
+
+SINGLETON: bar
+GENERIC: foo ( obj -- )
+M: bar foo drop "Hello!" print ;

Task/Singleton/Go/singleton-1.go

@@ -0,0 +1,9 @@
+package singlep
+
+// package level data declarations serve as singleton instance variables
+var X, Y int
+
+// package level functions serve as methods for a package-as-a-singleton
+func F() int {
+    return Y - X
+}

Task/Singleton/Go/singleton-2.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+    "fmt"
+    "singlep"
+)
+
+func main() {
+    // dot selector syntax references package variables and functions
+    singlep.X = 2
+    singlep.Y = 3
+    fmt.Println(singlep.X, singlep.Y)
+    fmt.Println(singlep.F())
+}

Task/Singleton/Groovy/singleton-1.groovy

@@ -0,0 +1,11 @@
+@Singleton
+class SingletonClass {
+
+    def invokeMe() {
+        println 'invoking method of a singleton class'
+    }
+
+    static void main(def args) {
+        SingletonClass.instance.invokeMe()
+    }
+}

Task/Singleton/Groovy/singleton-2.groovy

@@ -0,0 +1,13 @@
+class Singleton
+   method print()
+       write("Hi there.")
+   end
+   initially
+       write("In constructor!")
+       Singleton := create |self
+end
+
+procedure main()
+   Singleton().print()
+   Singleton().print()
+end

Task/Singleton/Io/singleton.io

@@ -0,0 +1,2 @@
+Singleton := Object clone
+Singleton clone = Singleton

Task/Singleton/Java/singleton-1.java

@@ -0,0 +1,26 @@
+class Singleton
+{
+    private static Singleton myInstance;
+    public static Singleton getInstance()
+    {
+        if (myInstance == null)
+        {
+            synchronized(Singleton.class)
+            {
+                if (myInstance == null)
+                {
+                    myInstance = new Singleton();
+                }
+            }
+        }
+
+        return myInstance;
+    }
+
+    protected Singleton()
+    {
+        // Constructor code goes here.
+    }
+
+    // Any other methods
+}

Task/Singleton/Java/singleton-2.java

@@ -0,0 +1,20 @@
+class Singleton
+{
+    private static Singleton myInstance;
+    public static Singleton getInstance()
+    {
+        if (myInstance == null)
+        {
+            myInstance = new Singleton();
+        }
+
+        return myInstance;
+    }
+
+    protected Singleton()
+    {
+        // Constructor code goes here.
+    }
+
+    // Any other methods
+}

Task/Singleton/JavaScript/singleton.js

@@ -0,0 +1,20 @@
+function Singleton() {
+	if(Singleton._instance) return Singleton._instance;
+	this.set("");
+	Singleton._instance = this;
+}
+
+Singleton.prototype.set = function(msg) { this.msg = msg; }
+Singleton.prototype.append = function(msg) { this.msg += msg; }
+Singleton.prototype.get = function() { return this.msg; }
+
+
+var a = new Singleton();
+var b = new Singleton();
+var c = new Singleton();
+
+a.set("Hello");
+b.append(" World");
+c.append("!!!");
+
+document.write( (new Singleton()).get() );

Task/Singleton/Logtalk/singleton-1.logtalk

@@ -0,0 +1,16 @@
+:- object(singleton).
+
+    :- public(value/1).
+    value(Value) :-
+        state(Value).
+
+    :- public(set_value/1).
+    set_value(Value) :-
+        retract(state(_)),
+        assertz(state(Value)).
+
+    :- private(state/1).
+    :- dynamic(state/1).
+    state(0).
+
+:- end_object.

Task/Singleton/Logtalk/singleton-2.logtalk

@@ -0,0 +1,7 @@
+| ?- singleton::value(Value).
+Value = 0
+yes
+
+| ?- singleton::(set_value(1), value(Value)).
+Value = 1
+yes

Task/Singleton/NetRexx/singleton.netrexx

@@ -0,0 +1,97 @@
+/* NetRexx */
+options replace format comments java crossref symbols binary
+
+import java.util.random
+
+class RCSingleton public
+
+  method main(args = String[]) public static
+    RCSingleton.Testcase.main(args)
+    return
+
+  -- ---------------------------------------------------------------------------
+  class RCSingleton.Instance public
+
+    properties private static
+      _instance = Instance()
+
+    properties private
+      _refCount = int
+      _random   = Random
+
+    method Instance() private
+      this._refCount = 0
+      this._random = Random()
+      return
+
+    method getInstance public static returns RCSingleton.Instance
+      return _instance
+
+  method getRandom public returns Random
+    return _random
+
+    method addRef public protect
+      _refCount = _refCount + 1
+      return
+
+    method release public protect
+      if _refCount > 0 then
+        _refCount = _refCount - 1
+      return
+
+    method getRefCount public protect returns int
+      return _refCount
+
+  -- ---------------------------------------------------------------------------
+  class RCSingleton.Testcase public implements Runnable
+
+  properties private
+    _instance = RCSingleton.Instance
+
+  method run public
+    say threadInfo'|-'
+    thud = Thread.currentThread
+    _instance = RCSingleton.Instance.getInstance
+    thud.yield
+    _instance.addRef
+    say threadInfo'|'_instance.getRefCount
+    thud.yield
+    do
+      thud.sleep(_instance.getRandom.nextInt(1000))
+    catch ex = InterruptedException
+      ex.printStackTrace
+      end
+    _instance.release
+    say threadInfo'|'_instance.getRefCount
+    return
+
+  method main(args = String[]) public static
+    threads = [ Thread -
+      Thread(Testcase()), Thread(Testcase()), Thread(Testcase()), -
+      Thread(Testcase()), Thread(Testcase()), Thread(Testcase()) ]
+    say threadInfo'|-'
+    mn = Testcase()
+    mn._instance = RCSingleton.Instance.getInstance
+    say mn.threadInfo'|'mn._instance.getRefCount
+    mn._instance.addRef
+    say mn.threadInfo'|'mn._instance.getRefCount
+    do
+      loop tr over threads
+        (Thread tr).start
+        end tr
+      Thread.sleep(400)
+    catch ex = InterruptedException
+      ex.printStackTrace
+      end
+    mn._instance.release
+    say mn.threadInfo'|'mn._instance.getRefCount
+    return
+
+  method threadInfo public static returns String
+    trd = Thread.currentThread
+    tid = trd.getId
+    hc  = trd.hashCode
+    info = Rexx(trd.getName).left(16, '_')':' -
+        || Rexx(Long.toString(tid)).right(10, 0)':' -
+        || '@'Rexx(Integer.toHexString(hc)).right(8, 0)
+    return info

Task/Singleton/Objeck/singleton.objeck

@@ -0,0 +1,18 @@
+class Singleton {
+  @singleton : static : Singleton;
+
+  New : private () {
+  }
+
+  function : GetInstance() ~ Singleton {
+    if(@singleton <> Nil) {
+      @singleton := Singleton->New();
+    };
+
+    return @singleton;
+  }
+
+  method : public : DoStuff() ~ Nil {
+    ...
+  }
+}

Task/Singleton/Objective-C/singleton-1.m

@@ -0,0 +1,9 @@
+// SomeSingleton.h
+@interface SomeSingleton : NSObject
+{
+  // any instance variables
+}
+
++ (SomeSingleton*)sharedInstance;
+
+@end

Task/Singleton/Objective-C/singleton-2.m

@@ -0,0 +1,38 @@
+// SomeSingleton.m
+@implementation SomeSingleton
+
++ (SomeSingleton*) sharedInstance
+{
+   static sharedInstance = nil;
+   if(!sharedInstance) {
+      sharedInstance = [[SomeSingleton alloc] init];
+   }
+   return sharedInstance;
+}
+
+- (id)copyWithZone:(NSZone *)zone
+{
+    return self;
+}
+
+- (id)retain
+{
+    return self;
+}
+
+- (unsigned)retainCount
+{
+    return UINT_MAX;
+}
+
+- (void)release
+{
+    // prevent release
+}
+
+- (id)autorelease
+{
+    return self;
+}
+
+@end

Task/Singleton/OxygenBasic/singleton.oxy

@@ -0,0 +1,14 @@
+class singleton
+static sys     a,b,c
+static string  s,t,u
+static double  x,y,z
+end class
+
+'TEST
+'====
+
+singleton A
+singleton B
+A.c=3
+print B.c      'result 3
+print sizeof B 'result 0

Task/Singleton/Oz/singleton.oz

@@ -0,0 +1,19 @@
+declare
+   local
+      class Singleton
+	 meth init
+	    skip
+	 end
+      end
+      L = {NewLock}
+      Instance
+   in
+      fun {GetInstance}
+	 lock L then
+	    if {IsFree Instance} then
+	       Instance = {New Singleton init}
+	    end
+	    Instance
+	 end
+      end
+   end

Task/Singleton/PHP/singleton.php

@@ -0,0 +1,21 @@
+class Singleton {
+  protected static $instance = null;
+  public $test_var;
+  private function __construct(){
+    //Any constructor code
+  }
+  public static function getInstance(){
+    if (is_null(self::$instance)){
+      self::$instance = new self();
+    }
+    return self::$instance;
+  }
+}
+
+$foo = Singleton::getInstance();
+$foo->test_var = 'One';
+
+$bar = Singleton::getInstance();
+echo $bar->test_var; //Prints 'One'
+
+$fail = new Singleton(); //Fatal error

Task/Singleton/Perl-6/singleton.pl6

@@ -0,0 +1,6 @@
+class Singleton {
+    # We create a lexical variable in the class block that holds our single instance.
+    my Singleton $instance = Singleton.bless(*); # You can add initialization arguments here.
+    method new {!!!} # Singleton.new dies.
+    method instance { $instance; }
+}

Task/Singleton/Perl/singleton.pl

@@ -0,0 +1,29 @@
+package Singleton;
+use strict;
+use warnings;
+
+my $Instance;
+
+sub new {
+    my $class = shift;
+    $Instance ||= bless {}, $class; # initialised once only
+}
+
+sub name {
+    my $self = shift;
+    $self->{name};
+}
+
+sub set_name {
+    my ($self, $name) = @_;
+    $self->{name} = $name;
+}
+
+package main;
+
+my $s1 = Singleton->new;
+$s1->set_name('Bob');
+printf "name: %s, ref: %s\n", $s1->name, $s1;
+
+my $s2 = Singleton->new;
+printf "name: %s, ref: %s\n", $s2->name, $s2;

Task/Singleton/PicoLisp/singleton.l

@@ -0,0 +1,7 @@
+(class +Singleton)
+
+(dm message1> ()
+   (prinl "This is method 1 on " This) )
+
+(dm message2> ()
+   (prinl "This is method 2 on " This) )

Task/Singleton/PureBasic/singleton-1.purebasic

@@ -0,0 +1,48 @@
+Global SingletonSemaphore=CreateSemaphore(1)
+
+Interface OO_Interface    ; Interface for any value of this type
+  Get.i()
+  Set(Value.i)
+  Destroy()
+EndInterface
+
+Structure OO_Structure ; The *VTable structure
+  Get.i
+  Set.i
+  Destroy.i
+EndStructure
+
+Structure OO_Var
+  *VirtualTable.OO_Structure
+  Value.i
+EndStructure
+
+Procedure OO_Get(*Self.OO_Var)
+  ProcedureReturn *Self\Value
+EndProcedure
+
+Procedure OO_Set(*Self.OO_Var, n)
+  *Self\Value = n
+EndProcedure
+
+Procedure CreateSingleton()
+  If TrySemaphore(SingletonSemaphore)
+    *p.OO_Var = AllocateMemory(SizeOf(OO_Var))
+    If *p
+      *p\VirtualTable = ?VTable
+    EndIf
+  EndIf
+  ProcedureReturn *p
+EndProcedure
+
+Procedure OO_Destroy(*Self.OO_Var)
+  FreeMemory(*Self)
+  SignalSemaphore(SingletonSemaphore)
+EndProcedure
+
+DataSection
+  VTable:
+  Data.i @OO_Get()
+  Data.i @OO_Set()
+  Data.i @OO_Destroy()
+EndDataSection

Task/Singleton/PureBasic/singleton-2.purebasic

@@ -0,0 +1,23 @@
+Singleton Class Demo
+  BeginPrivate
+    Name$
+    X.i
+  EndPrivate
+
+  Public Method Init(Name$)
+    This\Name$ = Name$
+  EndMethod
+
+  Public Method GetX()
+    MethodReturn This\X
+  EndMethod
+
+  Public Method SetX(n)
+    This\X = n
+  EndMethod
+
+  Public Method Hello()
+    MessageRequester("Hello!", "I'm "+This\Name$)
+  EndMethod
+
+EndClass

Task/Singleton/Python/singleton.py

@@ -0,0 +1,19 @@
+>>> class Borg(object):
+	__state = {}
+	def __init__(self):
+		self.__dict__ = self.__state
+	# Any other class names/methods
+
+	
+>>> b1 = Borg()
+>>> b2 = Borg()
+>>> b1 is b2
+False
+>>> b1.datum = range(5)
+>>> b1.datum
+[0, 1, 2, 3, 4]
+>>> b2.datum
+[0, 1, 2, 3, 4]
+>>> b1.datum is b2.datum
+True
+>>> # For any datum!

Task/Singleton/Racket/singleton.rkt

@@ -0,0 +1,9 @@
+#lang racket
+
+(provide instance)
+
+(define singleton%
+  (class object%
+    (super-new)))
+
+(define instance (new singleton%))

Task/Singleton/Ruby/singleton.rb

@@ -0,0 +1,9 @@
+require 'singleton'
+class MySingleton
+   include Singleton
+   # constructor and/or methods go here
+end
+
+a = MySingleton.instance # instance is only created the first time it is requested
+b = MySingleton.instance
+puts a.equal?(b) # outputs "true"

Task/Singleton/Scala/singleton.scala

@@ -0,0 +1,3 @@
+object Singleton {
+  // any code here gets executed as if in a constructor
+}

Task/Singleton/Slate/singleton.slate

@@ -0,0 +1 @@
+define: #Singleton &builder: [Oddball clone]

Task/Singleton/Tcl/singleton-1.tcl

@@ -0,0 +1,21 @@
+package require TclOO
+
+# This is a metaclass, a class that defines the behavior of other classes
+oo::class create singleton {
+   superclass oo::class
+   variable object
+   unexport create ;# Doesn't make sense to have named singletons
+   method new args {
+      if {![info exists object]} {
+         set object [next {*}$args]
+      }
+      return $object
+   }
+}
+
+singleton create example {
+   method counter {} {
+      my variable count
+      return [incr count]
+   }
+}

Task/Singleton/Tcl/singleton-2.tcl

@@ -0,0 +1,14 @@
+% set a [example new]
+::oo::Obj20
+% set b [example new]  ;# note how this returns the same object name
+::oo::Obj20
+% expr {$a == $b}
+1
+% $a counter
+1
+% $b counter
+2
+% $a counter
+3
+% $b counter
+4