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

  | _ => ...
}

[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)

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"
    }
}