A>  func0                 : void -> float = ("pi" / "rnd")s;
A>  funcExpr0             : float = func0;
A>  func1                 : float -> float = ("round")s;
A>  funcExpr1             : float = func1 "("s expr ")"s;
A>

Warning 5 N10003: method CalcParser.func0(name : Nemerle.Peg.NToken) : void -> float is not externally visible and has never been referenced D:\Work\Nemerle\NConsole\CalcTest\CalcParser2.n 95 4 CalcTest
Warning 6 N10003: method CalcParser.funcExpr0(func0 : void -> float) : float is not externally visible and has never been referenced D:\Work\Nemerle\NConsole\CalcTest\CalcParser2.n 115 4 CalcTest
Warning 7 N10003: method CalcParser.func1(name : Nemerle.Peg.NToken) : float -> float is not externally visible and has never been referenced D:\Work\Nemerle\NConsole\CalcTest\CalcParser2.n 120 4 CalcTest
Warning 8 N10003: method CalcParser.funcExpr1(func1 : float -> float, _N_wildcard_2808 : Nemerle.Peg.NToken, firstArg : float, _N_wildcard_2809 : Nemerle.Peg.NToken) : float is not externally visible and has never been referenced D:\Work\Nemerle\NConsole\CalcTest\CalcParser2.n 135 4 CalcTest

using System;
using System.Globalization.CultureInfo;
using System.Linq;
using System.Console;
using SCG = System.Collections.Generic;

using Nemerle.Peg;//Options = EmitDebugSource, 

[PegGrammar(start, 
grammar
{
  any                   = ['\u0000'..'\uFFFF'];
  s : void              = ' '*;
  num                   : float = ['0'..'9']+ ((',' / '.') ['0'..'9']+)? s;
  parenthesesExpr       : float = "("s expr ")"s;
  func0                 : void -> float = ("pi" / "rnd")s;
  funcExpr0             : float = func0;
  func1                 : float -> float = ("round")s;
  funcExpr1             : float = func1 "("s expr ")"s;
  //func1str              : string -> float = ("len")s;
  //funcExpr1str          : float = func1str "("s expr ")"s;
  func                  : SCG.IEnumerable.[float] -> float = ("max" / "avg" / "sum")s;
  funcExpr              : float = func "("s expr (";"s expr)* ")"s;
  unaryExpr             : float = (("-" / "+")s)* (num / parenthesesExpr / funcExpr);
  multiplicationExpr    : float = unaryExpr ( ("*" / "/")s unaryExpr)*;
  additionExpr          : float = multiplicationExpr ( ("+" / "-")s multiplicationExpr)*;
  expr                  : float = additionExpr;
  start                 : float = s expr !any;
})]
public sealed class CalcParser
{
  private num(integerPart : NToken, floatPart : option[NToken * NToken]) : float
  {
    def number = match(floatPart)
    {
      | Some((_, floatPart)) =>
        GetText(integerPart)
        + InvariantCulture.NumberFormat.NumberDecimalSeparator
        + GetText(floatPart)
      | _ =>
        GetText(integerPart)
    };
    float.Parse(number, InvariantCulture)
  }

  private parenthesesExpr(_ : NToken, se : float, _ : NToken) : float
  {
    se
  }

  private func(name : NToken) : SCG.IEnumerable[float] -> float
  {
    def max(seq)
    {
      mutable acc = float.MinValue;
      foreach(x in seq)
        when(x > acc)
          acc = x;
      otherwise
        acc = float.NaN;
      acc
    }
    def avg(seq)
    {
      mutable acc = .0f;
      mutable count = 0;
      foreach(x in seq)
      {
        acc += x;
        count += 1;
      }
      if(count > 0)
        acc / count
      else
        float.NaN
    }
    def sum(seq)
    {
      mutable acc = .0f;
      foreach(x in seq)
        acc += x;
      otherwise
        acc = float.NaN;
      acc
    }
    match(GetText(name).ToLowerInvariant()) // из GetText приедет оригинальную строку
    {
      | "max" => max
      | "avg" => avg
      | "sum" => sum
      | _ => throw InvalidOperationException()
    }
  }

  private func0(name : NToken) : void -> float
  {
    def pi()
    {
        Math.PI :> float
    }
      
    def rnd()
    {
        Random().NextDouble() :> float
    }

    match(GetText(name).ToLowerInvariant()) // из GetText приедет оригинальную строку
    {
      | "pi" => pi
      | "rnd" => rnd
      | _ => throw InvalidOperationException()
    }
  }

  private funcExpr0(func0 : void -> float) : float
  {
    func0()
  }
  
  private func1(name : NToken) : float -> float
  {
    def round(x)
    {
      //Math.Round(x)
        11.1f;
    }
    
    match(GetText(name).ToLowerInvariant()) // из GetText приедет оригинальную строку
    {
      | "round" => round
      | _ => throw InvalidOperationException()
    }
  }

  private funcExpr1(func1 : float -> float, _ : NToken, firstArg : float, _ : NToken) : float
  {
    func1(firstArg)
  }
  
  private funcExpr(func : SCG.IEnumerable[float] -> float, _ : NToken, firstArg : float, tailArgs : SCG.List[NToken * float], _ : NToken) : float
  {
    func([firstArg].Concat(tailArgs.Select(t => t[1])))
  }

  private unaryExpr(unaryOps : SCG.List[NToken], value : float) : float
  {
    mutable acc = value;
    foreach(op in unaryOps)
    {
      match(GetText(op))
      {
        | "+" => ()
        | "-" => acc *= -1
        | _ => throw InvalidOperationException()
      }
    }
    acc
  }

  private multiplicationExpr(head : float, tail : SCG.List[NToken * float]) : float
  {
    mutable acc = head;
    foreach((op, value) in tail)
    {
      match(GetText(op))
      {
        | "*" => acc *= value
        | "/" => acc /= value
        | _ => throw InvalidOperationException()
      }
    }
    acc
  }

  private additionExpr(head : float, tail : SCG.List[NToken * float]) : float
  {
    mutable acc = head;
    foreach((op, value) in tail)
    {
      match(GetText(op))
      {
        | "+" => acc += value
        | "-" => acc -= value
        | _ => throw InvalidOperationException()
      }
    }
    acc
  }
}


module Program
{
  Main() : void
  {
    def parser = CalcParser();
    //while(true)
    {
      def input = "round(2)";// "AVG(-3,5; 2)";//"abs (-3,5 min 2)";//"10    +2 - 3- 4 *4 / 2/   2  + (2+6)/2  +(-1)"; //res =  8 
      SourceSnapshot(input).WithText(input.ToLowerInvariant()) |> parser.Parse |> WriteLine; // магия!
      _ = ReadLine();
    }
  }
}

funCall : float      = identifier args;
arg0    : list[expr] = "("s ")"s;
arg1    : list[expr] = "("s expr ")"s;
argMeny : list[expr] = "("s expr (";"s expr)+ ")"s;
args    : list[expr] = arg0 / arg1 / argMeny;

funCall : float      = identifier "("s args ")"s;
args    : list[expr] = (expr (";"s expr)+)?;

match (funName, args)
{
  | ("round", [arg]) => Math.Round(arg)
  | ("round", _)     => throw InvalidArgumentException("The 'round' function has one parameter.")
  | ("max", [_])
  | ("max", [])      => throw InvalidArgumentException("The 'max' function must have 2 or more arguments.")
  ...
}

  func                  : SCG.IEnumerable.[float] -> float = ("max" / "avg" / "sum")s;
  funcExpr              : float = func "("s expr (";"s expr)* ")"s;

A>1. Заработало! Спасибо

variant CalcObject
{
  | Int    { value : int; }
  | Double { value : double; }
  | String { value : string; }
}

func                  : SCG.IEnumerable.[float] -> float = ("max" / "avg" / "sum")s;
funcExpr              : float = func "("s expr (";"s expr)* ")"s;

A>>func                  : SCG.IEnumerable.[float] -> float = ("max" / "avg" / "sum")s;
A>>funcExpr              : float = func "("s expr (";"s expr)* ")"s;
A>>

funcExpr              : float = func "("s expr (";"s expr)* ")"s;