match (someString)
{
    | string.IsNullOrEmpty(true) =>
    | int.TryParse(value, true) =>
    | Contains("qwe", true) =>
    | Contains("asd", true) =>
    | Contains("zxc", true) =>
}

match (someString)
{
    | string.IsNullOrEmpty =>
    | int.TryParse(value) =>
    | Contains("qwe") =>
    | Contains("asd") =>
    | Contains("zxc") =>
}

match (someDictionary)
{
    | TryGetValue("qwe", value) =>
    | TryGetValue("asd", value) =>
    | TryGetValue("zxc", value) =>
}

SomeTypeVirtualConstructor(obj : SomeType, field1 : out Type1, field3 : out Type4, field6 : out Type21) : void
{
    field1 = obj.field1;
    field3 = obj.field3;
    field6 = obj.field6;
}

variant EvenOdd
{
    | Even
    | Odd
}
IsEvenOdd(value : int) : EvenOdd
{
    if (value % 2 == 0) Even() else Odd()
}
match (someInt)
{
    | IsEvenOdd(Even) =>
    | IsEvenOdd(Odd) =>
}

pattern EvenOdd
{
    | Even
    | Odd

    match (value : int)
    {
        if (value % 2 == 0) Even() else Odd()
    }
}
match (someInt)
{
    | Even =>
    | Odd =>
}

class EvenOdd
{
    public enum Patterns
    {
        | Even
        | Odd
    }

    public Match (value : int) : Patterns
    {
        if (value % 2 == 0) Even() else Odd()
    }
}

pattern Asdasdasd
{
    | Asd { a : int; b : string; x : float; }
    | Qwe { c : string; d : int; }

    match (value : SomeType)
    {
        ...
    }
}

class Asdasdasd
{
    public enum Patterns
    {
        [ArgumentsMap("1 2 3", "a b x")]//Это метаданные для того чтобы из других сборок можно было использовать
        | Asd
        [ArgumentsMap("2 1", "c d")]
        | Qwe
    }

    public Match (value : SomeType, res1 : out int, res2 : out string, res3 : out float) : Patterns
    {
        ...
    }
}

[assembly: PMCtor(BinaryExpression,      Bin(conv=Conversion, left=Left, right=Right, method=Method))]
[assembly: PMCtor(ConditionalExpression, If(ifFalse=IfFalse, ifTrue=IfTrue, cond=Test))]
[assembly: PMCtor(ConstantExpression,    Const(value=Value))]
[assembly: PMCtor(InvocationExpression,  Invoc(lambda=Expression, args=Arguments))]
[assembly: PMCtor(LambdaExpression,      Lambda(parms=Parameters, body=Body))]
[assembly: PMCtor(ListInitExpression,    ListInit(what=NewExpression, inits=Initializers))]
[assembly: PMCtor(MemberExpression,      Member(obj=Expression, member=Member))]
[assembly: PMCtor(MemberInitExpression,  MemberInit(what=NewExpression, bindings=Bindings))]
[assembly: PMCtor(MethodCallExpression,  Call(obj=Object, method=Method, args=Arguments))]
[assembly: PMCtor(NewArrayExpression,    New(ty=Type, inits=Expressions))]
[assembly: PMCtor(NewExpression,         NewArray(ctor=Constructor, args=Arguments, bindings=Members))]
[assembly: PMCtor(ParameterExpression,   Param(name=Name, ty=Type))]
[assembly: PMCtor(TypeBinaryExpression,  Is(expr=Expression, ty=TypeOperand))]
[assembly: PMCtor(UnaryExpression,       Unary(operator=Method, operand=Operand))]

Bin(conv, left, right, method)

BinaryExpression where(Conversion=conv, Left=left, Right=right, Method=method)

Realization of F#'s active patterns in Nemerle language.

using System.Console;

[Record]
class A
{
  public Prop1 : int { get; set; }
}

[Record]
class B : A
{
  public Prop2 : A { get; set; }
}

module Program
{
  Main() : void
  {
    def a : A = B(1, B(2, null));

    match (a)
    {
      | B where(Prop1=1, Prop2=B where(Prop1=2)) => WriteLine("OK");
      | _ => WriteLine("Fail");
    }
  }
}

/*
BEGIN-OUTPUT
OK
END-OUTPUT
*/

WH>match (someString)
WH>{
WH>    | string.IsNullOrEmpty(true) =>
WH>    | int.TryParse(value, true) =>
WH>    | Contains("qwe", true) =>
WH>    | Contains("asd", true) =>
WH>    | Contains("zxc", true) =>
WH>}
WH>

...
    def a : A = B(1, B(2, null));

    match (a)
    {
      | B(1, B(2, _)) => WriteLine("OK");
      | _ => WriteLine("Fail");
    }
...

[assembly: PatternMatchingCtorMapping(B(prop1=Prop1, prop2=Prop2))]

WH>match (someString)
WH>{
WH>    | string.IsNullOrEmpty =>
WH>    | int.TryParse(value) =>
WH>    | Contains("qwe") =>
WH>    | Contains("asd") =>
WH>    | Contains("zxc") =>
WH>}
WH>

WH>SomeTypeVirtualConstructor(obj : SomeType, field1 : out Type1, field3 : out Type4, field6 : out Type21) : void
WH>{
WH>    field1 = obj.field1;
WH>    field3 = obj.field3;
WH>    field6 = obj.field6;
WH>}
WH>

let (|Even|Odd|) i = if i % 2 = 0 then Even else Odd

J>>let (|Even|Odd|) i = if i % 2 = 0 then Even else Odd
J>>

match str with
| DateTime dt -> "это - дата"
| Integer i -> "это - число"
| Float d -> "это - вещ. число"
| _ -> "а хз, что это такое"

J>let (|Even|Odd|) i = if i % 2 = 0 then Even else Odd
J>

if (i %|| 2) a else b

J>match str with
J>| DateTime dt -> "это - дата"
J>| Integer i -> "это - число"
J>| Float d -> "это - вещ. число"
J>| _ -> "а хз, что это такое"
J>

match (str)
{
  | dt is DateTime => "это - дата"
  | i  is int      => "это - число"
  | d  is float    => "это - вещ. число"
  | _              => "а хз, что это такое"
}

J>>match str with
J>>| DateTime dt -> "это - дата"
J>>| Integer i -> "это - число"
J>>| Float d -> "это - вещ. число"
J>>| _ -> "а хз, что это такое"
J>>

VD>match (str)
VD>{
VD>  | dt is DateTime => "это - дата"
VD>  | i  is int      => "это - число"
VD>  | d  is float    => "это - вещ. число"
VD>  | _              => "а хз, что это такое"
VD>}
VD>

if (DateTime.Parse(str, out dt)) return "это - дата"; else
if (int.TryParse(str, out i)) return "это - чисто"; else
if (float.TryParse(str, out d) return "это - вещ. число"; else
return "а хз, что это такое";

pattern Asdasdasd
{
    | Asd { a : int; b : string; x : float; }
    | Qwe { c : string; d : int; }

    match (value : SomeType)//*
    {
    ...
    }
}

match (someTypeValue)
{
    | Asd (a, b, x) =>
    | Qwe (c, d) =>
}

class Asdasdasd
{
    public enum Patterns
    {
        [ArgumentsMap("1 2 3", "a b x")]//Это метаданные для того чтобы из других сборок можно было использовать
        | Asd
        [ArgumentsMap("2 1", "c d")]
        | Qwe
    }

    public Match (value : SomeType, res1 : out int, res2 : out string, res3 : out float) : Patterns
    {
        ...
    }
}

pattern Asdasdasd
{
    | Asd { a : int; b : string; x : float; }
    | Qwe { c : string; d : int; }

    match (value : SomeType)//*
    {
    ...
    }
}


match (someTypeValue)
{
    | Asd (a, b, x) =>
    | Qwe (c, d) =>
}

match (ToAsdQwe <| someTypeValue)
{
    | Asd (a, b, x) =>
    | Qwe (c, d) =>
}

pattern Asdasdasd
{
    | Asd { a : int; b : SomeType; x : float; }
    | Qwe { c : string; d : int; }

    match (value : SomeType)//*
    {
    ...
    }
}

match (someTypeValue)
{
    | Asd (a1, Asd (a2, b, x2), x1) =>
    | Asd (a, Qwe (c, d), x) =>
    | Qwe (c, d) =>
}

let (|DivisibleBySeven|_|) input = if input % 7 = 0 then Some() else None

let (|IsPerfectSquare|_|) (input : int) = 
    let sqrt = int (Math.Sqrt(float input))
    if sqrt * sqrt = input then 
        Some() 
    else 
        None

let describeNumber x =
    match x with
    | DivisibleBySeven & IsPerfectSquare -> printfn "x is divisible by 7 and is a perfect square."
    | DivisibleBySeven                   -> printfn "x is divisible by seven"
    | IsPerfectSquare                    -> printfn "x is a perfect square"
    | _                                  -> printfn "x looks normal."

ВВ>Переписать что? У тебя же внутри match троеточие У меня там тоже... эээ... "троеточие". Вернее, функция ToAsdQwe будет рекурсивной, что в принципе на объеме кода практически не скажется.

| Asd (a1, Asd (a2, b, x2), x1) =>
| Asd (a, Qwe (c, d), x) =>
| Qwe (c, d) =>

def DivisibleBySeven(input) { input % 7 = 0 }

def IsPerfectSquare(input : int)
{
    def sqrt = int (Math.Sqrt(float input));
    sqrt * sqrt = input
}

def describeNumber(x)
{
    match (x)
    {
        | DivisibleBySeven & IsPerfectSquare => WriteLine("x is divisible by 7 and is a perfect square.")
        | DivisibleBySeven                   => WriteLine("x is divisible by seven")
        | IsPerfectSquare                    => WriteLine("x is a perfect square")
        | _                                  => WriteLine("x looks normal.")
    }
}

ВВ>>Переписать что? У тебя же внутри match троеточие У меня там тоже... эээ... "троеточие". Вернее, функция ToAsdQwe будет рекурсивной, что в принципе на объеме кода практически не скажется.

WH>| Asd (a1, Asd (a2, b, x2), x1) =>
WH>| Asd (a, Qwe (c, d), x) =>
WH>| Qwe (c, d) =>
WH>

def describeNumber(x)
{
    match (x)
    {
        | _ when DivisibleBySeven(x) && IsPerfectSquare(x) => WriteLine("x is divisible by 7 and is a perfect square.")
        | _ when DivisibleBySeven(x)                   => WriteLine("x is divisible by seven")
        | _ when IsPerfectSquare(x)                    => WriteLine("x is a perfect square")
        | _                                  => WriteLine("x looks normal.")
    }
}

| SomePattern(DivisibleBySeven, IsPerfectSquare) =>

| SomePattern(x1, x2) when DivisibleBySeven(x1) && IsPerfectSquare(x2) =>

let (|DivisibleBySeven|_|) input =

match (someString)
{
    | string.IsNullOrEmpty =>
    | int.TryParse(value) =>
    | Contains("qwe") =>
    | Contains("asd") =>
    | Contains("zxc") =>
}

match (someDictionary)
{
    | TryGetValue("qwe", value) =>
    | TryGetValue("asd", value) =>
    | TryGetValue("zxc", value) =>
}

variant AsdQwe
{
 | Asd { a : int; b : AsdQwe; x : float; }
 | Qwe { c : string; d : int; }
}
  
def val = ToAsdQwe(...);
 
match (val : AsdQwe) {
 | Asd(a1, Asd(a2, b, x2), x1) => {}
 | Asd(a, Qwe(c, d), x) => {}
 | Qwe(c, d) => {}
}

WH>| SomePattern(x1, x2) when DivisibleBySeven(x1) && IsPerfectSquare(x2) =>
WH>

WH>let (|DivisibleBySeven|_|) input = 
WH>

match x with
| Int 1 -> ...

match (someExpr)
{
  | Bin(ExpressionType.And, Const(1), Call(null, method, args)) => 
    // что-то делаем с method и args

  | _ => ...
}

let (|Integer|_|) (str: string) =
   let mutable intvalue = 0
   if System.Int32.TryParse(str, &intvalue) then Some(intvalue)
   else None

let (|Float|_|) (str: string) =
   let mutable floatvalue = 0.0
   if System.Double.TryParse(str, &floatvalue) then Some(floatvalue)
   else None

let parseNumeric str =
   match str with
     | Integer i -> printfn "%d : Integer" i
     | Float f -> printfn "%f : Floating point" f
     | _ -> printfn "%s : Not matched." str

[Pattern] Integer(obj : string) : option[int]
{
  mutable intvalue = 0;
  if (int.TryParse(obj, out intvalue)) Some(intvalue) else None
}

[Pattern] Float(obj : string) : option[float]
{
  mutable floatvalue = 0;
  if (float.TryParse(obj, out floatvalue)) Some(floatvalue) else None
}

MatchExample(str : string) : string
{
  match(str)
  {
    | Integer(i) => $"str : int = $i"
    | Float(f) => $"str : float = $f"
    | _ => $"$str : Not matched"
  }
}

match(Integer(str))
{
  | Some(i) => $"str : int = $i"
  | _ => match(Float(str))
    {
      | Float(f) => $"str : float = $f"
      | _ => $"$str : Not matched"
    }
}

[PatternPredicate] IntegerPredicate(obj : string) : bool
{
  mutable intvalue = 0;
  int.TryParse(obj, out intvalue)
}

[PatternSelector] IntegerSelector(obj : string) : bool { int.Parse(obj) }

[PatternPredicate] FloatPredicate(obj : string) : bool
{
  mutable floatvalue = 0;
  float.TryParse(obj, out floatvalue)
}

[PatternSelector] FloatSelector(obj : string) : bool { float.Parse(obj) }

match(str)
{
  | Integer(i) => $"str : int = $i"
  | Float(f) => $"str : float = $f"
  | _ => $"$str : Not matched"
}

match(str)
{
  | _ when IntegerPredicate(str) => match(IntegerSelector(str)){ | i => $"str : int = $i"}
  | _ when FloatPredicate(str) => match(FloatSelector(str)){ | f => $"str : float = $f"}
  | _ => $"$str : Not matched"
}

if (x is Type1) // для каждого объектного паттерна
{
  def boundVar1 = ...;
  def boundVar2 = ...;
  def boundVarN = ...;
  // код обработчика
}
else if (x is Type1)
  ...

match(6)
{
  | x when x%2==0 => $"$x | 2"
  | x when x%3==0 => $"$x | 3"
}

active match(str)
{
  | Integer(i) => $"str : int = $i"
  | Float(f) => $"str : float = $f"
  | _ => $"$str : Not matched"
}

__>>А может лучше в Nemerle/snippets, так можно будет потом и в инсталлятор добавить

deactivated : list[PExpr.Ref*PExpr*PExpr*list[PExpr]]