using System;
using System.Console;

type period = DateTime * DateTime;

public module DateHelper {
    public @* ( a : period, b : period ) : period
    {
            def max_start =
                if( a[0] > b[0] ) a[0]; else b[0];

            def min_stop =
                if( a[1] < b[1] ) a[1]; else b[1];
                
            (max_start, min_stop);
    }
}

def a = (DateTime.Now, DateTime.Now.AddDays(2));
def b = (DateTime.Now.AddDays(-3), DateTime.Now.AddDays(1));

WriteLine( a * b );

public @+( date : DateTime, delta : double ) : DateTime {...}

public Sum( this protocol : list[ProtocolItem], predicate : ProtocolItem -> bool ) : double
        {
            def summator(pi, sum) {
                if( predicate(pi) ) {
                    if( pi.Article.IsAdditional )
                        sum + pi.Sum;
                    else
                        sum - pi.Sum;
                }
                else sum;
            }
            
            protocol.FoldLeft(0.00 : double, summator); //134 строка
        }

ИД>Если правильно понимаю, то в коде используется +(double, DateTime)

using System;
using System.Console;
using Overl; // This is expected behavior?

public module Overl
{
  public @+(date : DateTime, delta : long) : DateTime // This is expected behavior?
  {
    date + TimeSpan(delta)
  }

  public @+(delta : long, date : DateTime) : DateTime // This is expected behavior?
  {
    date + TimeSpan(delta)
  }
}

module Program
{
  Main() : void
  {
    def now = DateTime.Now;
    WriteLine(now);
    WriteLine(now + 20000000L);
    WriteLine(20000000L + now);
    _ = ReadLine();
  }
}

using System;
using System.Console;
using DateHelper;

public module DateHelper 
{
    public @+( date : DateTime, delta : double ) : DateTime
    {
        date.AddDays(delta);
    }
    
    public @-( date : DateTime, delta : double ) : DateTime
    {
        date.AddDays(-delta);
    }
}

def rand = Random();

def summator(x, sum)
{
    if( rand.Next(100) > 50 ) sum + x; else sum - x;
}

def l = $[0.0, 0.5 .. 5];
WriteLine( l.FoldLeft(0.00 : double, summator) );

AB>using System;
AB>using System.Console;
AB>using DateHelper;

AB>public module DateHelper 
AB>{
AB>    public @+( date : DateTime, delta : double ) : DateTime
AB>    {
AB>        date.AddDays(delta);
AB>    }
    
AB>    public @-( date : DateTime, delta : double ) : DateTime
AB>    {
AB>        date.AddDays(-delta);
AB>    }
AB>}

AB>def rand = Random();

AB>def summator(x, sum)
AB>{
AB>    if( rand.Next(100) > 50 ) sum + x; else sum - x;
AB>}

AB>def l = $[0.0, 0.5 .. 5];
AB>WriteLine( l.FoldLeft(0.00 : double, summator) );
AB>

namespace Nemerle
{
    public module Core
    {
        public static @$[A,B,C](this fbc : B->C, fab : A->B) : A->C
        {
            match(fab : object)
            {
                | fa is void->B => ((() => fbc(fa())) : object) :> A->C
                | _ => a => fbc(fab(a))
            }
        }
    }
}