1
2
3
4
5
6
7
8
9
import std.stdio;
 
interface singleton
{
        private static singleton me;
        static singleton get()
        {
                if (!me)
                {
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
interface singleton
{
        private static singleton me = null;
        private static singleton get()
        {
                if (!me)
                {
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
template singleton(T)
{
        private static T me = null;
        private static T get()
        {
                if (!me)
                {
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
template singleton(T)
{
        private static T me = null;
        private static T get()
        {
                if (!me)
                {
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
class Hellos
{
        static void hello()
        {
                writeln("hello.");
        }
}
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void Hello()
{
        writeln("hello.");
}
 
class Hellos
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void Hello()
{
        writeln("hello.");
}
 
class Hellos
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void Hello()
{
        writeln("hello.");
}
 
class Hellos
{
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void Hello()
{
        writeln("hello.");
}
 
void main()
{
 ...

1
2
3
4
5
6
import std.stdio;
 
void main()
{
        writeln("hello.");
}

1
2
3
4
5
6
7
8
9
import std.stdio;
 
template singleton(T)
{
private:
        static T me;
        static T get()
        {
                if (!me)
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
template singleton(T)
{
private:
        static T me;
        static T get()
        {
                if (!me)
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
template singleton(T)
{
private:
        static T me;
        static T get()
        {
                if (!me)
 ...

1
2
3
4
5
6
7
8
9
template singleton(T)
{
private:
        static T me;
        static T get()
        {
                if (!me)
                {
                        me = new T();
 ...

1
2
3
4
5
6
7
8
9
template singleton(T)
{
private:
        static T me;
        static T get()
        {
                if (!me)
                {
                        me = new T();
 ...

1
2
3
4
5
6
7
8
9
template singleton(T)
{
private:
        static T me;
        static T get()
        {
                if (!me)
                {
                        me = new T();
 ...

1
2
3
4
5
6
7
8
9
template singleton(T)
{
private:
        static T me;
        static T get()
        {
                if (!me)
                {
                        me = new T();
 ...

1
2
3
4
5
6
7
8
9
template singleton(T)
{
private:
        static T me;
        static get()
        {
                if (!me)
                {
                        me = new T();
 ...

1
2
3
4
5
6
7
8
9
template singleton(T)
{
private:
        static T me;
        static get()
        {
                if (!me)
                {
                        me = new T();
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
void main(string[] args)
{
    writeln("Hello World, Reloaded");
 
    // 自動型推論と、組み込みのforeach
    foreach (argc, argv; args)
    {
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
template singleton(T)
{
        static T get()
        {
                synchronized
                {
                        if (!me)
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
template singleton(T)
{
        static T get()
        {
                synchronized
                {
                        if (!me)
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
template singleton(T)
{
        static T get()
        {
                synchronized
                {
                        if (!me)
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
template singleton(T)
{
        static T get()
        {
                synchronized
                {
                        if (!me)
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
template singleton(T)
{
        static T get()
        {
                synchronized
                {
                        if (!me)
 ...

1
2
3
4
5
6
7
8
9
import std.stdio;
 
template singleton(T) {
        static T get() {
                synchronized {
                        if (!me)
                        {
                                me = new T;
                        }
 ...

1
2
3
4
5
6
import std.stdio;
 
void main()
{
        writeln("hello, world.");
}

1
void main() {}

1
2
3
4
5
void main()
{
    class Foo {}
    Object[] a = new Foo[10];
}

1
2
3
4
class Foo {}
Object[] a = new Foo[10];
 
void main() {}