__>Насчёт ленивых вычислений — в Nemerle они присутствуют и эта возможность никак не связана с императивностью или "логичностью"

class Field {
 String name;
 boolean is_private;
}
class Struct {
 Field[] fields;
 
 rule find(String name, Field@ f)
 {
  f @= fields,
  f.name.startsWith(name)
 }

 rule find_public(String name, Field@ f)
 {
  find_all(name, f),
  f.is_public
 }
}

module Util
{
    public IsEmpty[T](this e : IEnumerable[T]) : bool
    {
        !IsNotEmpty(e);
    }
    public IsNotEmpty[T](this e : IEnumerable[T]) : bool
    {
        e.GetEnumerator().MoveNext();
    }
}

def arr_foo = ["a", "b", "c"];
def foo(s)
{
  arr_foo.FilterLazy(ss => ss == s);
}

def arr_bar = ["b", "c", "d"];
def bar(s)
{
  foo(s).FilterLazy(ss => arr_bar.Contains(ss));
}

WriteLine(bar("a").IsNotEmpty());
WriteLine(bar("b").IsNotEmpty());
WriteLine(bar("c").IsNotEmpty());
WriteLine(bar("d").IsNotEmpty());

False
True
True
False

match (someClass.Fileds.Find(field => field.Name == name && field.IsPublic))
{
| Some(field) => // Нашли
| Nome => => // Не нашли
}

using System.Console;
using Nemerle.Utility;

[Record]
class Str
{
    s : string;

    public GetS(context: string) : string
    {
        WriteLine($"Getting \"$s\" in $context");
        s;
    };
}

def arr = [
    Str("a"),
    Str("bb"),
    Str("c"), 
    Str("dd"), 
    Str("a")
];

def find_foo(i)
{
    arr.FilterLazy(s => s.GetS("find_foo()").Length <= i);
};

def find_bar()
{
    find_foo(1).FilterLazy(s => s.GetS("find_bar()") == "a");
};

foreach (s in find_bar())
    WriteLine(s.GetS("foreach cycle"));

Getting "a" in find_foo()
Getting "a" in find_bar()
Getting "a" in foreach cycle
a
Getting "bb" in find_foo()
Getting "c" in find_foo()
Getting "c" in find_bar()
Getting "dd" in find_foo()
Getting "a" in find_foo()
Getting "a" in find_bar()
Getting "a" in foreach cycle
a

    public FilterLazy [T] (this source : SCG.IEnumerable [T], predicate : T -> bool) : SCG.IEnumerable [T]
    {
      foreach(elem when predicate(elem) in source)
        yield elem;
    }

    Akkerman1(a : int, b: int) : int
    {
        if (b == 0)
            Akkerman1(a - 1, 1);
        else if (a == 0)
            b + 1;
        else
            Akkerman1(a - 1, Akkerman1(a, b - 1));
    }
        
    [Memoize]
    Akkerman2(a : int, b: int) : int
    {
        if (b == 0)
            Akkerman2(a - 1, 1);
        else if (a == 0)
            b + 1;
        else
            Akkerman2(a - 1, Akkerman2(a, b - 1));
    }
        
    public Main() : void
    {
        def watch = Stopwatch.StartNew();
        WriteLine(Akkerman1(3, 12));
        WriteLine(watch.Elapsed);

        def watch = Stopwatch.StartNew();
        WriteLine(Akkerman2(3, 12));
        WriteLine(watch.Elapsed);
    }

32765
00:00:05.3120469
32765
00:00:00.2155528

WH>module Util
WH>{
WH>    public IsEmpty[T](this e : IEnumerable[T]) : bool
WH>    {
WH>        !IsNotEmpty(e);
WH>    }
WH>    public IsNotEmpty[T](this e : IEnumerable[T]) : bool
WH>    {
WH>        e.GetEnumerator().MoveNext();
WH>    }
WH>}

WH>[/code]

Кстати, хороший метод. Добавлю как я его в стандартную библиотеку :).
Только малость доработаю напильником:
[c#]
using System;
using System.Console;
using Nemerle.Utility;
using SCG = System.Collections.Generic;

module Ex
{
  public IsEmpty[T](this seq : array[T]) : bool { seq.Length == 0 }
  public IsEmpty(this seq : System.Collections.ICollection) : bool { seq.Count == 0 }
  
  public IsEmpty[T](this seq : SCG.IEnumerable[T]) : bool
  {
    | []                                    => true
    | _ :: _                                => false
    | ary is array[T]                       => IsEmpty(ary)
    | col is System.Collections.ICollection => IsEmpty(col)
    | _                                     => seq.GetEnumerator().MoveNext()
  }
}

module Program
{
  Main() : void
  {
    def print(seq) { WriteLine($"$(seq.GetType().Name): '..$(seq)' => $(seq.IsEmpty())") }
    print(array[1]);
    print(array(0));
    print([1]);
    print([1].Tail);
    print(SCG.List());
    print(SCG.List(array[1, 2]));
    _ = ReadLine();
  }
}

Int32[]: '1' => False
Int32[]: '' => True
Cons: '1' => False
Nil: '' => True
List`1: '' => True
List`1: '1, 2' => False

VD>  public IsEmpty[T](this seq : SCG.IEnumerable[T]) : bool
VD>  {
VD>    | []                                    => true
VD>    | _ :: _                                => false
VD>    | ary is array[T]                       => IsEmpty(ary)
VD>    | col is System.Collections.ICollection => IsEmpty(col)
VD>    | _                                     => seq.GetEnumerator().MoveNext()
VD>  }
VD>}
VD>

module Ex
{
  public IsEmpty   (this seq : System.Collections.ICollection) : bool { seq.Count == 0 }
  public IsEmpty[T](this seq : array[T])                       : bool { seq.Length == 0 }
  public IsEmpty[T](this seq : list[T])                        : bool
  {
    | []     => true
    | _ :: _ => false
    | null   => true
  }
  
  public IsEmpty[T](this seq : SCG.IEnumerable[T])             : bool
  {
    | []                                    => true
    | _ :: _                                => false
    | ary is array[T]                       => IsEmpty(ary)
    | col is System.Collections.ICollection => IsEmpty(col)
    | null                                  => true
    | _                                     =>
      foreach (_ in seq) // This for call IDisposable...
        Nemerle.Imperative.Return(false);
      true
  }
}