Ideone.com | Online Nemerle Compiler & Debugging Tool

Computer geeks!

language:	Nemerle (ncc 0.9.3)
date:	403 days 16 hours ago
link:
visibility:	public private user's deleted

source code clone download copy to clipboard report bug / make suggestion

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

clone download copy to clipboard

compilation info hide

input / output show all hide all

# 65 # 64 # 63 # 62 # 61 # 60 # 59 # 58 # 57 # 56 # 55 # 54 # 53 # 52 # 51 # 50 # 49 # 48 # 47 # 46 # 45 # 44 # 43 # 42 # 41 # 40 # 39 # 38 # 37 # 36 # 35 # 34 # 33 # 32 # 31 # 30 # 29 # 28 # 27 # 26 # 25 # 24 # 23 # 22 # 21 # 20 # 19 # 18 # 17 # 16 # 15 # 14 # 13 # 12 # 11 # 10 # 9 # 8 # 7 # 6 # 5 # 4 # 3 # 2 # 1

upload with new input
# 65: hide show clone input 11 days 23 hours ago Success

result: Success time: 0.06s memory: 13352 kB returned value: 0
input:
```
<["Foo"]>
```
output:
```
Hello world!
```
# 64: hide show clone input 18 days 12 hours ago Success

result: Success time: 0.06s memory: 13352 kB returned value: 0
input:
```
аааав ввв
```
output:
```
Hello world!
```
# 63: hide show clone input 32 days 17 hours ago Success

result: Success time: 0.07s memory: 13352 kB returned value: 0
input:
```
gege
```
output:
```
Hello world!
```
# 62: hide show clone input 34 days 20 hours ago Success

result: Success time: 0.06s memory: 13352 kB returned value: 0
input:
```
xxx
```
output:
```
Hello world!
```

# 61: show clone input 40 days 9 hours ago Success

input:

def title = "Programming language authors";
def authors = ["Anders Hejlsberg", "Simon Peyton-Jones"];
// 'xml' - macro from Nemerle.Xml.Macro library which alows to inline XML literals into the nemerle-code
def html = xml <#
  <html>
    <head>
      <title>$title</title>
    </head>
    <body>
      <ul $when(authors.Any())>
        <li $foreach(author in authors)>$author</li>
      </ul>
    </body>
  </html>
Trace.Assert(html.GetType().Equals(typeof(XElement)));
WriteLine(html.GetType());

output:

Hello world!

# 60: hide show clone input 41 days 0 hours ago Success

result: Success time: 0.07s memory: 13352 kB returned value: 0
input:
```
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("?");
        }
}
```
output:
```
Hello world!
```
# 59: hide show clone input 41 days 9 hours ago Success

result: Success time: 0.06s memory: 13352 kB returned value: 0
input:
```
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hello plop!");
        }
}
```
output:
```
Hello world!
```

# 58: show clone input 49 days 14 hours ago Success

input:

macro @if (cond, e1, e2)
syntax ("if", "(", cond, ")", e1, Optional (";"), "else", e2){
  /*
    <[ ]> defines an area of quasi-quotation, the Nemerle compiler transforms a code in a such block
    to an AST tree, such transformations are somewhat similar to an Expression compiling in C#
  */
  <[
    match ($cond : bool)
    {
      | true => $e1
      | _ => $e2
    }
  ]>}
 
// using this macro in code:
def max = if (a > b) a else b;// during a compile time the upper line will be transformed to the following:
def max = match (a > b){
  | true => a
  | _    => b
}

output:

Hello world!

# 57: hide show clone input 55 days 20 hours ago Success

result: Success time: 0.07s memory: 13352 kB returned value: 0

input: no
output:
```
Hello world!
```
# 56: hide show clone input 59 days 0 hours ago Success

result: Success time: 0.07s memory: 13352 kB returned value: 0
input:
```
Console.WriteLine("test");
```
output:
```
Hello world!
```
# 55: hide show clone input 59 days 0 hours ago Success

result: Success time: 0.06s memory: 13352 kB returned value: 0
input:
```
jh
```
output:
```
Hello world!
```
# 54: hide show clone input 84 days 7 hours ago Success

result: Success time: 0.07s memory: 13352 kB returned value: 0
input:
```
Console.WriteLine("toodles!"};
```
output:
```
Hello world!
```
# 53: hide show clone input 92 days 10 hours ago Success

result: Success time: 0.07s memory: 13352 kB returned value: 0
input:
```
Console.WriteLine("toodles!"};
```
output:
```
Hello world!
```
# 52: hide show clone input 92 days 10 hours ago Success

result: Success time: 0.06s memory: 13352 kB returned value: 0
input:
```
Hello me!
```
output:
```
Hello world!
```
# 51: hide show clone input 100 days 19 hours ago Success

result: Success time: 0.07s memory: 13352 kB returned value: 0
input:
```
def x=3
```
output:
```
Hello world!
```

# 50: show clone input 105 days 8 hours ago Success

input:

using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("этот язык кусок дерьма!");
                Console.WriteLine("Тот кто это написал уныл и ничтожен!");
        }
}

output:

Hello world!

# 49: hide show clone input 105 days 8 hours ago Success

result: Success time: 0.06s memory: 13352 kB returned value: 0
input:
```
yes
```
output:
```
Hello world!
```
# 48: hide show clone input 116 days 6 hours ago Success

result: Success time: 0.07s memory: 13352 kB returned value: 0

input: no
output:
```
Hello world!
```

# 47: show clone input 126 days 14 hours ago Success

input:

using System;
def factorial(n, acc)
{
  | (0, _)
  | (1, _) => acc
  | _      => factorial(n - 1, n * acc)
}
def partedFactorial = factorial(_, 1);
Console.WriteLine(partedFactorial(5));

output:

Hello world!

# 46: hide show clone input 145 days 6 hours ago Success

result: Success time: 0.06s memory: 13352 kB returned value: 0
input:
```
990
```
output:
```
Hello world!
```

# 45: show clone input 164 days 15 hours ago Success

input:

using Nemerle.Collections;
using Nemerle.Peg;
using Nemerle.Text;
using Nemerle.Utility;
using Nemerle;

using System;
using System.Collections.Generic;
using System.Console;
using System.Linq;

using SCG = System.Collections.Generic;

namespace BF {

	[PegGrammar(Options = EmitDebugSources, cmds,
	grammar{
		newLine                      =  "\n"
		                               /"\r\n"
		                               /"\r"
		                               /"\u2028"  /*  line separator       */
		                               /"\u2029"; /*  paragraph separator  */
		command     : Commands       = '+'/'-'/'<'/'>'/'?'/'.';
		begin_while : Commands       = '[';
		end_while   : Commands       = ']';
		while_loop  : Commands       = begin_while cmds* end_while;
		cmds        : List[Commands] = (while_loop / command)+ newLine? ;
	})]
	class Parser {
		command (t : NToken) : Commands {
			match (this._parsingSource.OriginalText[t.StartPos]) {
				| '+' => Commands.Add();
				| '-' => Commands.Sub();
				| '>' => Commands.Inc();
				| '<' => Commands.Dec();
				| '?' => Commands.C_in();
				| '.' => Commands.Cout();
				| _ => throw InvalidOperationException()
			}
		}
    
		while_loop ( Begin : Commands,  Cmds : List[List[Commands]],  EndAt : Commands) : Commands.While {
			Commands.While(  Begin:>Commands.W_beg,  EndAt:>Commands.W_end,  Cmds[0] )
		}   
  
		begin_while ( _t : NToken ) : Commands {
			Commands.W_beg();
		}

		end_while ( _t : NToken ) : Commands {
			Commands.W_end();
		}

		cmds ( cs : List[Commands], _n : NToken ) : List[Commands] {
			cs
		}   
	}


	public variant Commands {
		| Add    
		| Sub    
		| Dec    
		| Inc   
		| C_in   
		| Cout  
		| W_beg
		| W_end   
		| While {
			Begin: W_beg;
			EndAt: W_end;
			Exprs: List[Commands];
		  }	             
	}


	public class bf_World {
		public mutable ptr :int;
		public mutable mem : array [byte];
		private mutable O_FN : char->void;
		private mutable I_FN : void->char;
 
		public this(o : char->void, i:void->char) {
			mem=array(65536); I_FN=i;	O_FN=o;
		}

		public   cell         : byte {
			get { this.mem[this.ptr] }
			set { this.mem[this.ptr]=value }
		}

		public Output(c:char) : void {
			O_FN(c)
		}

		public  Input()       : char {
			I_FN()
		}
	}


	public class BF {
		public static Run(ast : List[BF.bfc],mutable s : bf_World) : bf_World {
			foreach( cmd  in ast)
				match (cmd) {
					| Inc   => s.ptr++;
					| Dec   => s.ptr--;
					| Add   => s.cell++;
					| Sub   => s.cell--;
					| While => while(s.cell!=0){  s=Run((cmd:>Commands.While).Exprs,s); };
					| C_in  => s.cell= (s.Input()):>byte;
					| Cout  => s.Output( s.cell:>char);                
				} 
			s
		}
	}


	module Program {
		Main() : void {
			def p=BF.Parser();
			def ast=p.Parse("+++++++[>+++++++>++++++++++++>+<<<<-]>++.>+.+++++..+++.>++.<<+++++++++++.>.+++.------.--------.>+.>.");
			if( ast.HasValue){
				def d=BF.BF.Run(ast.Value,
				                BF.bf_World( (c)=>Write(c),
                                                ()=>Console.Read():>Char) );
			}
			else{()}
			_ = ReadLine();
		}  
	}
}

output:

Hello world!

# 44: show clone input 164 days 15 hours ago Success

input:

using Nemerle.Collections;
using Nemerle.Peg;
using Nemerle.Text;
using Nemerle.Utility;
using Nemerle;

using System;
using System.Collections.Generic;
using System.Console;
using System.Linq;

using SCG = System.Collections.Generic;

namespace BF {

	[PegGrammar(Options = EmitDebugSources, cmds,
	grammar{
		newLine                      =  "\n"
		                               /"\r\n"
		                               /"\r"
		                               /"\u2028"  /*  line separator       */
		                               /"\u2029"; /*  paragraph separator  */
		command     : Commands       = '+'/'-'/'<'/'>'/'?'/'.';
		begin_while : Commands       = '[';
		end_while   : Commands       = ']';
		while_loop  : Commands       = begin_while cmds* end_while;
		cmds        : List[Commands] = (while_loop / command)+ newLine? ;
	})]
	class Parser {
		command (t : NToken) : Commands {
			match (this._parsingSource.OriginalText[t.StartPos]) {
				| '+' => Commands.Add();
				| '-' => Commands.Sub();
				| '>' => Commands.Inc();
				| '<' => Commands.Dec();
				| '?' => Commands.C_in();
				| '.' => Commands.Cout();
				| _ => throw InvalidOperationException()
			}
		}
    
		while_loop ( Begin : Commands,  Cmds : List[List[Commands]],  EndAt : Commands) : Commands.While {
			Commands.While(  Begin:>Commands.W_beg,  EndAt:>Commands.W_end,  Cmds[0] )
		}   
  
		begin_while ( _t : NToken ) : Commands {
			Commands.W_beg();
		}

		end_while ( _t : NToken ) : Commands {
			Commands.W_end();
		}

		cmds ( cs : List[Commands], _n : NToken ) : List[Commands] {
			cs
		}   
	}


	public variant Commands {
		| Add    
		| Sub    
		| Dec    
		| Inc   
		| C_in   
		| Cout  
		| W_beg
		| W_end   
		| While {
			Begin: W_beg;
			EndAt: W_end;
			Exprs: List[Commands];
		  }	             
	}


	public class bf_World {
		public mutable ptr :int;
		public mutable mem : array [byte];
		private mutable O_FN : char->void;
		private mutable I_FN : void->char;
 
		public this(o : char->void, i:void->char) {
			mem=array(65536); I_FN=i;	O_FN=o;
		}

		public   cell         : byte {
			get { this.mem[this.ptr] }
			set { this.mem[this.ptr]=value }
		}

		public Output(c:char) : void {
			O_FN(c)
		}

		public  Input()       : char {
			I_FN()
		}
	}


	public class BF {
		public static Run(ast : List[BF.bfc],mutable s : bf_World) : bf_World {
			foreach( cmd  in ast)
				match (cmd) {
					| Inc   => s.ptr++;
					| Dec   => s.ptr--;
					| Add   => s.cell++;
					| Sub   => s.cell--;
					| While => while(s.cell!=0){  s=Run((cmd:>Commands.While).Exprs,s); };
					| C_in  => s.cell= (s.Input()):>byte;
					| Cout  => s.Output( s.cell:>char);                
				} 
			s
		}
	}


	module Program {
		Main() : void {
			def p=BF.Parser();
			def ast=p.Parse("++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.");
			if( ast.HasValue){
				def d=BF.BF.Run(ast.Value,
				                BF.bf_World( (c)=>Write(c),
                                                ()=>Console.Read():>Char) );
			}
			else{()}
			_ = ReadLine();
		}  
	}
}

output:

Hello world!

# 43: hide show clone input 164 days 15 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hello world!");
        }
}
```
output:
```
Hello world!
```

# 42: show clone input 180 days 2 hours ago Success

input:

using System;
public module HelloWorld
{
        public Main() : int
        {
                Console.WriteLine("Hello world!");
return -1;
        }
}

output:

Hello world!

# 41: hide show clone input 180 days 2 hours ago Success

result: Success time: 0.04s memory: 14344 kB returned value: 0
input:
```
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hellof world!");
        }
}
```
output:
```
Hello world!
```
# 40: hide show clone input 189 days 23 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Test");
        }
}
```
output:
```
Hello world!
```
# 39: hide show clone input 198 days 3 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
using System;
public module HelloWorld
{
        public Main() : void
        

        }
}
```
output:
```
Hello world!
```
# 38: hide show clone input 198 days 3 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("!");
        }
}
```
output:
```
Hello world!
```

# 37: show clone input 198 days 3 hours ago Success

input:

using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hel4545lo world!");
        }
}

output:

Hello world!

# 36: show clone input 198 days 3 hours ago Success

input:

using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hel4545lo world!");
        }
}

output:

Hello world!

# 35: hide show clone input 228 days 7 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0

input: no
output:
```
Hello world!
```
# 34: hide show clone input 230 days 1 hour ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hello world!");
        }
}
```
output:
```
Hello world!
```
# 33: hide show clone input 230 days 4 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
Console.WriteLine("test");
```
output:
```
Hello world!
```
# 32: hide show clone input 231 days 20 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
Console.WriteLine("fodinha");
```
output:
```
Hello world!
```
# 31: hide show clone input 236 days 21 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
Console.WriteLine("fodinha");
```
output:
```
Hello world!
```
# 30: hide show clone input 240 days 21 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
Console.WriteLine("fodinha");
```
output:
```
Hello world!
```

# 29: show clone input 243 days 7 hours ago Success

input:

using Nemerle.Collections;
using Nemerle.Peg;
using Nemerle.Text;
using Nemerle.Utility;
using Nemerle;

using System;
using System.Collections.Generic;
using System.Console;
using System.Linq;

using SCG = System.Collections.Generic;

namespace BF {

	[PegGrammar(Options = EmitDebugSources, cmds,
	grammar{
		newLine                      =  "\n"
		                               /"\r\n"
		                               /"\r"
		                               /"\u2028"  /*  line separator       */
		                               /"\u2029"; /*  paragraph separator  */
		command     : Commands       = '+'/'-'/'<'/'>'/'?'/'.';
		begin_while : Commands       = '[';
		end_while   : Commands       = ']';
		while_loop  : Commands       = begin_while cmds* end_while;
		cmds        : List[Commands] = (while_loop / command)+ newLine? ;
	})]
	class Parser {
		command (t : NToken) : Commands {
			match (this._parsingSource.OriginalText[t.StartPos]) {
				| '+' => Commands.Add();
				| '-' => Commands.Sub();
				| '>' => Commands.Inc();
				| '<' => Commands.Dec();
				| '?' => Commands.C_in();
				| '.' => Commands.Cout();
				| _ => throw InvalidOperationException()
			}
		}
    
		while_loop ( Begin : Commands,  Cmds : List[List[Commands]],  EndAt : Commands) : Commands.While {
			Commands.While(  Begin:>Commands.W_beg,  EndAt:>Commands.W_end,  Cmds[0] )
		}   
  
		begin_while ( _t : NToken ) : Commands {
			Commands.W_beg();
		}

		end_while ( _t : NToken ) : Commands {
			Commands.W_end();
		}

		cmds ( cs : List[Commands], _n : NToken ) : List[Commands] {
			cs
		}   
	}


	public variant Commands {
		| Add    
		| Sub    
		| Dec    
		| Inc   
		| C_in   
		| Cout  
		| W_beg
		| W_end   
		| While {
			Begin: W_beg;
			EndAt: W_end;
			Exprs: List[Commands];
		  }	             
	}


	public class bf_World {
		public mutable ptr :int;
		public mutable mem : array [byte];
		private mutable O_FN : char->void;
		private mutable I_FN : void->char;
 
		public this(o : char->void, i:void->char) {
			mem=array(65536); I_FN=i;	O_FN=o;
		}

		public   cell         : byte {
			get { this.mem[this.ptr] }
			set { this.mem[this.ptr]=value }
		}

		public Output(c:char) : void {
			O_FN(c)
		}

		public  Input()       : char {
			I_FN()
		}
	}


	public class BF {
		public static Run(ast : List[BF.bfc],mutable s : bf_World) : bf_World {
			foreach( cmd  in ast)
				match (cmd) {
					| Inc   => s.ptr++;
					| Dec   => s.ptr--;
					| Add   => s.cell++;
					| Sub   => s.cell--;
					| While => while(s.cell!=0){  s=Run((cmd:>Commands.While).Exprs,s); };
					| C_in  => s.cell= (s.Input()):>byte;
					| Cout  => s.Output( s.cell:>char);                
				} 
			s
		}
	}


	module Program {
		Main() : void {
			def p=BF.Parser();
			def ast=p.Parse("++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.");
			if( ast.HasValue){
				def d=BF.BF.Run(ast.Value,
				                BF.bf_World( (c)=>Write(c),
                                                ()=>Console.Read():>Char) );
			}
			else{()}
			_ = ReadLine();
		}  
	}
}

output:

Hello world!

# 28: show clone input 243 days 7 hours ago Success

input:

using Nemerle.Collections;
using Nemerle.Peg;
using Nemerle.Text;
using Nemerle.Utility;
using Nemerle;

using System;
using System.Collections.Generic;
using System.Console;
using System.Linq;

using SCG = System.Collections.Generic;

namespace BF {

	[PegGrammar(Options = EmitDebugSources, cmds,
	grammar{
		newLine                      =  "\n"
		                               /"\r\n"
		                               /"\r"
		                               /"\u2028"  /*  line separator       */
		                               /"\u2029"; /*  paragraph separator  */
		command     : Commands       = '+'/'-'/'<'/'>'/'?'/'.';
		begin_while : Commands       = '[';
		end_while   : Commands       = ']';
		while_loop  : Commands       = begin_while cmds* end_while;
		cmds        : List[Commands] = (while_loop / command)+ newLine? ;
	})]
	class Parser {
		command (t : NToken) : Commands {
			match (this._parsingSource.OriginalText[t.StartPos]) {
				| '+' => Commands.Add();
				| '-' => Commands.Sub();
				| '>' => Commands.Inc();
				| '<' => Commands.Dec();
				| '?' => Commands.C_in();
				| '.' => Commands.Cout();
				| _ => throw InvalidOperationException()
			}
		}
    
		while_loop ( Begin : Commands,  Cmds : List[List[Commands]],  EndAt : Commands) : Commands.While {
			Commands.While(  Begin:>Commands.W_beg,  EndAt:>Commands.W_end,  Cmds[0] )
		}   
  
		begin_while ( _t : NToken ) : Commands {
			Commands.W_beg();
		}

		end_while ( _t : NToken ) : Commands {
			Commands.W_end();
		}

		cmds ( cs : List[Commands], _n : NToken ) : List[Commands] {
			cs
		}   
	}


	public variant Commands {
		| Add    
		| Sub    
		| Dec    
		| Inc   
		| C_in   
		| Cout  
		| W_beg
		| W_end   
		| While {
			Begin: W_beg;
			EndAt: W_end;
			Exprs: List[Commands];
		  }	             
	}


	public class bf_World {
		public mutable ptr :int;
		public mutable mem : array [byte];
		private mutable O_FN : char->void;
		private mutable I_FN : void->char;
 
		public this(o : char->void, i:void->char) {
			mem=array(65536); I_FN=i;	O_FN=o;
		}

		public   cell         : byte {
			get { this.mem[this.ptr] }
			set { this.mem[this.ptr]=value }
		}

		public Output(c:char) : void {
			O_FN(c)
		}

		public  Input()       : char {
			I_FN()
		}
	}


	public class BF {
		public static Run(ast : List[BF.bfc],mutable s : bf_World) : bf_World {
			foreach( cmd  in ast)
				match (cmd) {
					| Inc   => s.ptr++;
					| Dec   => s.ptr--;
					| Add   => s.cell++;
					| Sub   => s.cell--;
					| While => while(s.cell!=0){  s=Run((cmd:>Commands.While).Exprs,s); };
					| C_in  => s.cell= (s.Input()):>byte;
					| Cout  => s.Output( s.cell:>char);                
				} 
			s
		}
	}


	module Program {
		Main() : void {
			def p=BF.Parser();
			def ast=p.Parse("++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.");
			if( ast.HasValue){
				def d=BF.BF.Run(ast.Value,
				                BF.bf_World( (c)=>Write(c),
                                                ()=>Console.Read():>Char) );
			}
			else{()}
			_ = ReadLine();
		}  
	}
}

output:

Hello world!

# 27: show clone input 243 days 7 hours ago Success

input:

using System;
def factorial(n, acc)
{
  | (0, _)
  | (1, _) => acc
  | _      => factorial(n - 1, n * acc)
}
def partedFactorial = factorial(_, 1);
Console.WriteLine(partedFactorial(35));

output:

Hello world!

# 26: show clone input 258 days 7 hours ago Success

input:

using System;
def factorial(n, acc)
{
  | (0, _)
  | (1, _) => acc
  | _      => factorial(n - 1, n * acc)
}
def partedFactorial = factorial(_, 1);
Console.WriteLine(partedFactorial(35));

output:

Hello world!

# 25: show clone input 258 days 7 hours ago Success

input:

using System;
def factorial(n, acc)
{
  | (0, _)
  | (1, _) => acc
  | _      => factorial(n - 1, n * acc)
}
def partedFactorial = factorial(_, 1);
Console.WriteLine(partedFactorial(15));

output:

Hello world!

# 24: show clone input 258 days 7 hours ago Success

input:

using System;
def factorial(n, acc)
{
  | (0, _)
  | (1, _) => acc
  | _      => factorial(n - 1, n * acc)
}
def partedFactorial = factorial(_, 1);
Console.WriteLine(partedFactorial(5));

output:

Hello world!

# 23: hide show clone input 279 days 1 hour ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hell o world!");
        }
}
```
output:
```
Hello world!
```
# 22: hide show clone input 289 days 18 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0

input: no
output:
```
Hello world!
```

# 21: show clone input 294 days 3 hours ago Success

input:

using System;
def factorial(n, acc)
{
  | (0, _)
  | (1, _) => acc
  | _      => factorial(n - 1, n * acc)
}
def partedFactorial = factorial(_, 1);
Console.WriteLine(partedFactorial(5));

output:

Hello world!

# 20: hide show clone input 325 days 5 hours ago Success

result: Success time: 0.04s memory: 14344 kB returned value: 0

input: no
output:
```
Hello world!
```

# 19: show clone input 330 days 8 hours ago Success

input:

using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("этот язык кусок дерьма!");
                Console.WriteLine("Тот кто это написал уныл и ничтожен!");
        }
}

output:

Hello world!

# 18: show clone input 341 days 12 hours ago Success

input:

using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("этот язык кусок дерьма!");
                Console.WriteLine("Тот кто это написал уныл и ничтожен!");
        }
}

output:

Hello world!

# 17: show clone input 349 days 8 hours ago Success

input:

using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("этот язык кусок дерьма!");
                Console.WriteLine("Тот кто это написал уныл и ничтожен!");
        }
}

output:

Hello world!

# 16: hide show clone input 349 days 11 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
derp
```
output:
```
Hello world!
```

# 15: show clone input 349 days 17 hours ago Success

input:

using System;
def factorial(n, acc)
{
  | (0, _)
  | (1, _) => acc
  | _      => factorial(n - 1, n * acc)
}
def partedFactorial = factorial(_, 1);
Console.WriteLine(partedFactorial(5));

output:

Hello world!

# 14: hide show clone input 350 days 2 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hello world!");
        }
}
```
output:
```
Hello world!
```
# 13: hide show clone input 350 days 16 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
using System;
public module Test
{
public Main() : void
{
Console.WriteLine("Test");
}
}
```
output:
```
Hello world!
```

# 12: show clone input 352 days 14 hours ago Success

input:

using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("этот язык кусок дерьма!");
                Console.WriteLine("Тот кто это написал уныл и ничтожен!");
        }
}

output:

Hello world!

# 11: show clone input 357 days 21 hours ago Success

input:

using System;
def factorial(n, acc)
{
  | (0, _)
  | (1, _) => acc
  | _      => factorial(n - 1, n * acc)
}
def partedFactorial = factorial(_, 1);
Console.WriteLine(partedFactorial(5));

output:

Hello world!

# 10: show clone input 359 days 3 hours ago Success

input:

using System;
def factorial(n, acc)
{
  | (0, _)
  | (1, _) => acc
  | _      => factorial(n - 1, n * acc)
}
def partedFactorial = factorial(_, 1);
Console.WriteLine(partedFactorial(5));

output:

Hello world!

# 9: show clone input 362 days 23 hours ago Success

input:

using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("этот язык кусок дерьма!");
        }
}

output:

Hello world!

# 8: hide show clone input 363 days 3 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hello plop!");
        }
}
```
output:
```
Hello world!
```

# 7: show clone input 366 days 3 hours ago Success

input:

using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Supercalifragilistic!");
        }
}

output:

Hello world!

# 6: hide show clone input 369 days 23 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0

input: no
output:
```
Hello world!
```
# 5: hide show clone input 373 days 8 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Cacas!");
        }
}
```
output:
```
Hello world!
```
# 4: hide show clone input 374 days 2 hours ago Success

result: Success time: 0.04s memory: 14344 kB returned value: 0
input:
```
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Caca!");
        }
}
```
output:
```
Hello world!
```
# 3: hide show clone input 375 days 6 hours ago Success

result: Success time: 0.05s memory: 13320 kB returned value: 0
input:
```
using System.Console;
public module HelloWorld
{
        public Main() : void
        {
                WriteLine("Hello world!");
        }
}
```
output:
```
Hello world!
```
# 2: hide show clone input 381 days 21 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0
input:
```
using System;
public module HelloWorld
{
        public Main() : void
        {
                Console.WriteLine("Hello world!");
        }
}
```
output:
```
Hello world!
```
# 1: hide show clone input 403 days 16 hours ago Success

result: Success time: 0.04s memory: 13320 kB returned value: 0

input: no
output:
```
Hello world!
```

UsernamePassword

Username
Password