1
2
3
4
5
6
7
8
9
using System;
 
interface OutputStream { Write(s : string) : void }
 
class ConsoleOutputStream : OutputStream { public Write(s : string) : void { Console.WriteLine(s); } }
 
def printf(to : OutputStream, format : String, params values : array[object])
{
  to.Write( string.Format(format, values) );
 ...

1
2
3
4
5
6
7
8
9
using System;
 
interface OutputStream { Write(s : string) : void }
 
class ConsoleOutputStream : OutputStream { public Write(s : string) : void { Console.WriteLine(s); } }
 
def printf(to : OutputStream, format : String, params values : array[object])
{
  to.Write( string.Format(format, values) );
 ...

1
2
3
4
5
6
7
8
9
using System;
 
interface OutputStream { Write(s : string) : void }
 
class ConsoleOutputStream : OutputStream { public Write(s : string) : void { Console.WriteLine(s); } }
 
def printf(to : OutputStream, format : String, params values : array[object])
{
  to.Write( string.Format(format, values) );
 ...

1
2
3
4
5
6
7
8
9
using System;
 
interface OutputStream { Write(s : string) : void }
 
class ConsoleOutputStream : OutputStream { public Write(s : string) : void { Console.WriteLine(s); } }
 
def printf(to : OutputStream, format : String, params values : array[object])
{
  to.Write( string.Format(format, values) );
 ...

1
2
3
4
5
6
7
8
9
using System;
 
interface OutputStream { Write(s : string) : void }
 
class ConsoleOutputStream : OutputStream { public Write(s : string) : void { Console.WriteLine(s); } }
 
def printf(to : OutputStream, format : String, params values : array[object])
{
  to.Write( string.Format(format, values) );
 ...

1
2
3
4
5
6
7
8
9
using System.Console;
 
interface OutputStream { Write(s : string) : void }
 
class ConsoleOutputStream : OutputStream { public Write(s : string) : void { Console.WriteLine(s); } }
 
def printf(to : OutputStream, format : String, params values : array[object])
{
  to.Write( string.Format(format, values) );
 ...

1
2
3
4
5
6
7
8
9
using System.Console;
 
interface OutputStream { Write(s : string) : void }
 
class ConsoleOutputStream : OutputStream { public Write(s : string) : void { Console.WriteLine(s); } }
 
def printf(to : OutputStream, format : String, params values : array[object])
{
  to.Write( string.Format(format, values) );
 ...

1
2
3
4
5
6
7
8
9
using System.Console;
 
interface OutputStream { Write(s : string) : void }
 
class ConsoleOutputStream : OutputStream { public Write(s : string) : void { Console.WriteLine(s); } }
 
def printf(to : OutputStream, format : String, params values : array[object])
{
  to.Write( string.Format(format, values) );
 ...

1
2
3
4
5
6
7
8
9
using System.Console;
 
interface OutputStream { Write(s : string) : void }
 
class ConsoleOutputStream : OutputStream { public Write(s : string) : void { Console.WriteLine(s); } }
 
def printf(to : OutputStream, format : String, params values : array[object])
{
  to.Write( string.Format(format, values) );
 ...

1
2
def a = [1..10];
System.Console.WriteLine($<# $(..a, ": ")#>);

1
2
3
4
5
6
class A
{
 public this(a : int, b : int) {}
}
 
def a = A(b = 2, a = 2);

1
2
3
4
5
6
class A
{
 public this(a : int, b : int) {}
}
 
def a = A(b = 2, a = 2);

1
2
3
4
5
6
7
8
9
using System;
 
public module HelloWorld
{
    public Main() : void
    {
        def x = 1;
        Console.WriteLine(x);
    }

1
2
3
4
5
6
7
8
9
using System.Console;
 
class A { public P : int { get { 0 } } }
class B { public P : int { get { 0 } } }
 
def f(g)
{
  def x = g();
  WriteLine($"x.P - $(x.P)");
 ...

1
2
3
4
5
6
7
8
9
using System.Console;
 
class A { public P : int { get { 0 } } }
class B { public P : int { get { 0 } } }
 
def f(g)
{
  def x = g();
  WriteLine($"x.P - $(x.P)");
 ...

1
2
3
4
5
6
7
8
9
using System.Console;
 
class A { public P : int { get { 0 } } }
 
def f(g)
{
  def x = g();
  WriteLine($"x.P - $(x.P)");
}
 ...

1
2
3
4
5
6
7
8
9
using System.Console;
 
class A { public P : int { get { 0 } } }
 
def f(g)
{
  def x = g();
  WriteLine(x.P);
}
 ...

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

1
2
3
4
5
6
7
8
9
using System;
public class Test
{
        public static Main() : void
        {
                def solve() : void {
                        def i = int.Parse(Console.ReadLine());
                        unless (i == 42) {
                                Console.WriteLine(i);
 ...

1
2
3
4
5
def x = match (1 :> int?)
{
 | _? => "A"
 | _ => "B"
}

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

1
2
3
4
5
6
7
8
9
using System;
 
def fhead[T] ( l : list[T]) : T
{
     match(l) {
          | start :: _ => start
          | _ => throw System.Exception ("not valid");
     }
}
 ...

1
2
3
4
5
6
7
8
9
using System;
 
def fhead[T] ( l : list[T]) : T
{
     match(l) {
          | start :: _ => start
          | _ => throw System.Exception ("not valid");
     }
}
 ...

1
2
3
4
5
6
7
8
9
using System;
 
def fhead[T] ( l : list[T]) : T
{
     match(l) {
          | start :: _ => start
          | _ => throw System.Exception ("not valid");
     }
}
 ...

1
2
3
4
5
6
7
8
9
using System;
 
def fhead ( l : list[T]) : T
{
     match(l) {
          | start :: _ => start
          | _ => throw System.Exception ("not valid");
     }
}
 ...

1
2
3
4
5
6
7
8
9
using System;
 
def fhead ( l : list[T]) : T
{
     match(l) {
          | start :: _ => start
          | _ => throw System.Exception ("not valid");
     }
}
 ...

1
2
3
4
5
6
7
8
9
using System;
 
def fhead ( l : list[T]) : T
{
     match(l) {
          | start :: _ => start
          | _ => throw System.Exception ("not valid");
     }
}
 ...

1
2
3
4
5
6
7
8
9
using System;
 
def fhead ( l : list[T]) : T
{
     match(l) {
          | start :: _ => start
          | _ => throw System.Exception ("not valid");
     }
}
 ...

1
2
3
4
5
6
7
8
9
def fhead ( l : list[T]) : T
{
     match(l) {
          | start :: _ => start
          | _ => throw System.Exception ("not valid");
     }
}
 
def bad()
 ...

1
2
3
4
5
6
7
8
9
def fhead ( l : list[T]) : T
{
     match(l) {
          | _ :: rest => rest;
          | _ => throw Exception ("not valid");
     }
}
 
def bad()
 ...