Features
 | This section includes a list of references, related reading or external links, but its sources remain unclear because it lacks inline citations .(September 2013) |
Nemerle's most notable feature is the ability to mix styles of programming that are object-oriented and functional. Programs may be structured using object-oriented concepts such as classes and namespaces, while methods can (optionally) be written in a functional style. Other notable features include:
- strong type inference
- a flexible metaprogramming subsystem (using macros)
- full support for object-oriented programming (OOP), in the style of C#, Java, and C++
- full support for functional programming, in the style of ML, OCaml, and Haskell, with these features:
- higher-order functions
- pattern matching
- algebraic types
- local functions
- tuples and anonymous types
- partial application of functions
The metaprogramming system allows for great compiler extensibility, embedding domain-specific languages, partial evaluation, and aspect-oriented programming, taking a high-level approach to lift as much of the burden as possible from programmers. The language combines all Common Language Infrastructure (CLI) standard features, including parametric polymorphism, lambdas, extension methods etc. Accessing the libraries included in the .NET or Mono platforms is as easy as in C#.
Type inference
defx=1;// intdefmyList=List();// generic List[T], type T is deduced from the usage in the next linemyList.Add(x);// compiler deduces type of T as int making myList type of List[int]Everything is an expression
defx={// similar to x = 3defy=1;defz=2;y+z// this last statement is a block return value};defx=if(DateTime.Now.DayOfWeek==DayOfWeek.Monday)// if, using, try are also expressions"Monday"else"other day";defx=tryint.Parse(someString)catch{|FormatException()=>0};defx=returnBlock:{foreach(iin[1,2,3])when(i>2)returnBlock(true);// exit block (x = true)false// x = false};Tuples
defk=(1,"one");// k : (int * string)def(a,b)=k;// a = 1, b = "one"Pattern matching
defresult=match(number){|0=>"zero"|1=>"one"|xwhenx<0=>"negative"|_=>"more than one"}Type matching with variable binding:
defcheck(o:object){match(o){|iisint=>$"An int: $i"|sisstring=>$"A string: $(s.ToUpper())"|_=>"Object of another type"}}Tuple pattern matching:
match(tuple){|(42,_)=>"42 on first position"|(_,42)=>"42 on second position"|(x,y)=>$"( $x, $y )"}Regexp matching:
usingNemerle.Text;regexpmatch(str){|"a+.*"=>printf("a\n");|@"(?<num : int>\d+)-\w+"=>printf("%d\n",num+3);|"(?<name>(Ala|Kasia))? ma kota"=>match(name){|Some(n)=>printf("%s\n",n)|None=>printf("noname?\n")}|_=>printf("default\n");}Functional types and local functions
usingSystem.Console;// classes and modules (static classes) can be put in namespacesdefnext(x){x+1};// the type of x argument and other function arguments can be deduced from usagedefmult(x,y){x*y};deffibonacci(i){|0=>0|1=>1|other=>fibonacci(i-1)+fibonacci(i-2)};WriteLine(next(9));// 10 similar to "Console.WriteLine(next(9));" WriteLine(mult(2,2));// 4WriteLine(fibonacci(10));// 55Variants
Variants (called data types or sum types in SML and OCaml) are forms of expressing data of several different kinds:
variantRgbColor{|Red|Yellow|Green|Different{red:float;green:float;blue:float;}}Metaprogramming
Nemerle's macro system allows for creating, analysing, and modifying program code during compiling. Macros can be used in the form of a method call or as a new language construct. Many constructs within the language are implemented using macros (if, for, foreach, while, using etc.).
"if" macro example:
macro@if(cond,e1,e2)syntax("if","(",cond,")",e1,Optional(";"),"else",e2){/* <[ ]> defines an area of quasi-quotation, the Nemerle compiler transforms the code in it to an AST, such transformations are somewhat similar to an Expression compiling in C# */<[match($cond:bool){|true=>$e1|_=>$e2}]>}// using this macro in code:defmax=if(a>b)aelseb;// during a compile time the upper line will be transformed to this:defmax=match(a>b){|true=>a|_=>b}Braceless syntax
Similarly to the braceless syntax later added to Scala, Nemerle allows the programmer to optionally use a whitespace-sensitive syntax based on the off-side rule, similarly to Python.
The following curly-brace snippet:
usingSystem.Console;[Qux]classFooBar{publicstaticMain():void{WriteLine("Hello")}staticFoo(x:int):void{if(x==3){defy=x*42;Foo(x)}else{[x].Map(fun(x){x*2})}}staticBar():int{deffoo=2+7*13;foo}}could be rewritten as:
usingSystem.Console;[Qux]\classFooBarpublicstaticMain():voidWriteLine("Hello")staticFoo(x:int):voidif(x==3)defy=x*42;Foo(x)else[x].Map(fun(x){x*2})staticBar():intdeffoo=2+7*13fooNotably, it is not possible to break expressions or alternative clauses in matches over multiple lines without using a backslash \:
// This will not compile ...staticBar():intdeffoo=2+7*13foomatch(s)|"a"|"aa"=>1|"b"|"bb"=>2|_=>0// But this will:staticBar():intdeffoo=2\+7\*13foomatch(s)|"a"\|"aa"=>1|"b"\|"bb"=>2|_=>0In order to activate this syntax, the user must add #pragma indent to the top of the file or use the compiler option -i.
