1
2
3
4
5
6
7
8
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Chello world!");
        }
}

1
2
3
4
5
6
7
8
9
 
using System;
using System.Console;
public class HelloWorld
{
        public static Main() : void
        {
                Console.WriteLine("Hello world!");
                def hw = HelloWorld();
 ...

1
2
3
4
5
6
7
8
9
 
using System;
using System.Console;
public class HelloWorld
{
        public static Main() : void
        {
                Console.WriteLine("Hello world!");
                def hw = HelloWorld();
 ...

1
2
3
4
5
6
7
8
9
 
using System;
using System.Console;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hello world!");
                def hw = HelloWorld();
 ...

1
2
3
4
5
6
7
8
bubblesort(List, Sorted):-
    swap(List, List1),!,
    bubblesort(List1, Sorted),
    bubblesort(Sorted, Sorted).
 
swap([X,Y|Rest], [Y,X|Rest]):-
    X<Y,
swap([Z|Rest], [Z,Rest1]).
 ...

1
2
3
4
5
6
7
8
bubblesort(List, Sorted):-
    swap(List, List1),!,
    bubblesort(List1, Sorted).
    bubblesort(Sorted, Sorted).
 
swap([X,Y|Rest], [Y,X|Rest]):-
    X<Y,
swap([Z|Rest], [Z,Rest1]).
 ...

1
2
3
4
5
6
7
8
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hello world!");
        }
}

1
2
3
4
5
6
7
8
9
class Password
{
      static void Main(string[] args)
      {
             console.Write("The password is: ")
             
             for (int i = 0; i < 6; i++)
                 Console.Write(GetChar(i,i*i));
             Console.readKay();
 ...

1
2
3
4
5
6
7
8
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hello world!");
        }
}

1
2
3
4
5
6
7
8
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hello world!");
        }
}

1
2
3
4
5
6
7
8
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hello world!");
        }
}

1
2
3
4
5
6
7
8
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hello world!");
        }
}

1
2
3
4
5
6
7
8
fun :: [Int]
fun = 0 : 1 : zipWith (+) fun (tail fun)
 
line n = printf "%02x" $ ( (fun !! (30-n) ) `rem` 256 )  
 
main = do
    sequence_ $ map line [1..16]
    printf "\n"

1
2
3
4
5
6
7
8
using System;
public class Test
{
        public static Main()
        {
          System.out.println("Trollol");
        }
}

1
2
3
4
5
6
7
8
using System;
public class Test
{
        public static Main() : void
        {
          System.out.println("Trollol");
        }
}

1
2
3
4
5
6
7
class A
{
 public Item[x : int, y : int, z : int] : int { get { 10 } }
}
 
def a = A();
def x = a[1,2,3];

1
2
3
4
5
6
class A { public X : int { get { 10 } } }
 
def a = A();
def x = a.get_X();
 
System.Console.WriteLine(x);

1
2
3
4
class A { public X : int { get { 0 } } }
 
def a = A();
def x = a.get_X();

1
2
3
4
5
using Nemerle.Utility;
 
[Record] class X { public G : int { get { 0; } set { } } };
 
def x = X(1);

1
2
3
4
5
using Nemerle.Utility;
 
[Record] class X { public G : int { get {return 0; } set { } } };
 
def x = X(1);

1
2
3
4
5
using Nemerle.Utility;
 
[Record] class X { public G : int { get ; set ; } };
 
def x = X(1);

1
2
3
4
5
6
using System;
 
def s = Uri("a", UriKind.Relative);
def p = s.OriginalString;
_=p;
_=s;

1
 

1
 

1
2
3
4
5
6
7
8
9
eb 04 af c2 bf a3 81 ec  00 01 00 00 31 c9 88 0c
0c fe cl 75 f9 31 c0 ba  ef be ad de 02 04 0c 00
d0 cl ca 08 8a 1c 0c 8a  3c 04 88 1c 04 88 3c 0c
fe cl 75 e8 e9 5c 00 00  00 89 e3 81 c3 04 00 00
00 5c 58 3d 41 41 41 41  75 43 58 ed 42 42 42 42
75 3b 5a 89 dl 89 e6 89  df 29 cf f3 a4 89 de 89
dl 89 df 29 cf 31 c0 31  db 31 d2 fe c0 02 lc 06
8a 14 06 8a 34 le 88 34  06 88 14 1e 00 f2 30 f6
8a 1c 16 8a 17 30 da 88  17 47 49 75 de 31 db 89

1
2
3
4
5
6
7
8
using Nemerle.Utility;
 
[Record]
struct X
{
  public i : int = 1;
  public j : int = 2;
}

1
2
3
4
5
6
7
8
using Nemerle.Utility;
 
[Record]
struct X
{
  public i : int;
  public j : int;
}

1
2
3
4
5
6
7
8
9
using Nemerle.Utility;
 
struct X
{
  [Accessor]
  i : int;
 
  [Accessor]
  j : int;
 ...

1
2
3
4
5
6
7
8
struct X
{
  [Accessor]
  i : int;
 
  [Accessor]
  j : int;
}

1
2
3
class A[T = int] { }
 
_=();