Mercury – это новый функционально-логический язык программирования со строгой типизацией, системой режимов аргументов и детерминизмом предикатов. Синтаксис частично унаследован от Пролога, система типов похожа на Haskell.
...
Так же, для ограничения перебора разработчикам Пролога пришлось включать в него некоторые недекларативные возможности, например, отсечения и циклы по неуспеху. В итоге при написании оптимизированной программы утрачивается вся красота декларативного подхода, и возникают серьезные трудности с пониманием кода и отладкой. Фактически Пролог не является чисто декларативным языком, он имеет императивные особенности, то есть многие части кода зависят от порядка следования целей в предикате.
...
Во-первых, нужно было что-то делать с типизацией, поэтому все современные логические языки содержат систему типов. Во-вторых, было бы очень неплохо перейти от интерпретации к компиляции программ, и наконец, надо решить главную проблему логического подхода – низкую производительность.

Разработчики Mercury сделали свой язык чисто декларативным, полностью убрав из него все императивные возможности. Ввели развитую систему типов, режимы аргументов, категории детерминизма предикатов и условные операторы. Оказалось, что такой подход имеет право на существование и, несмотря на некоторые трудности с организацией ввода-вывода, дает высокопроизводительный код. Причем оптимизация программы в этом случае производится автоматически самим компилятором, а не программистом, избавляя его от необходимости продумывания последовательности выполнения алгоритма.
...
Плюс, в Mercury разработчикам удалось объединить в одной парадигме логический и функциональный подход программирования. А так же бонусом является способность компилятора находить многие логические ошибки, за счет чего код программы становится более надежным.

Компилятор Mercury открыт и бесплатен (распространяется по лицензии GPL), работает на всех современных операционных системах. Особенностью языка является то, что он способен транслировать код во многие популярные языки программирования: C, Java, Erlang, IL для платформы .NET.

var x = (CheckedInt<range>)usualInt;

V>>У тебя обычный интерпретатор получится, если ты его задействуешь. Единственно что, парсить будет не интерпретатор, а ты, и будешь подавать готовое АСТ. И подавать запаришься, насколько я понял.

X1 x1 = GetX2();  // GetX2 имеет тип X2
var x2 = GetX2();

father(X, Y) :- parent(X, Y), male(X).
mother(X, Y) :- parent(X, Y), female(X).

C>father(X, Y) :- parent(X, Y), male(X).
C>mother(X, Y) :- parent(X, Y), female(X).
C>

class Entity1 { 
    public bool male { get; }
    public bool female { get; }
}

// каждое правило возвращает цепочку утверждений/фактов или null
// (или список цепочек, если ответов несколько)
Iterator<Term> father(Entity x, Entity y) {
    if(x.Male && y.parent_2.Contains(x)) { // или x.parent_1.Contains(y)
        yield return term_male_xxx;   // _xxx и _yyy - некие автогенеренные номера для именования переменных-экземпляров фактов/правил
        yield return term_father_yyy;
    }
}

bool father_check_only(Entity x, Entity y) {
    return x.Male && y.parent_2.Contains(x);
}

// Сгенерированный код запроса father(a, b)?
// в обобщенном виде для интерпретатора - всегда список цепочек вывода (т.е. от 0-ля до oo цепочек вывода)
Iterator<Iterator<Term>> father_2_query(object x, object y) { 
    const int relationId_father_2 = xxx;  // ID 2-арного отношения father, известно после этапа обработки исходного текста
    Relation relationFather_2 = relations[relationId_father_2];  // оверхед даже на доступ к каждой таблице отношений

    // проходимся по всем фактам и правилам, задающим отношение
    foreach(Term_2 ruleOrFact in relationFather_2) {
        // вложено итерируем каждую цепочку вывода
        foreach(Iterator<Iterator<Term>> answerChain in ruleOrFact.invoke(a, b))
            foreach(Iterator<Term> answer in answerChain)
                yield return answer;  // разумеется, для некоторого функционального языка
                                      // уже существуют библиотечные ф-ии для "склейки" итераторов,
                                      // но интересно показать, что происходит на самом деле      
    }       
}        

// Утверждение-правило: father(X, Y) :- parent(X, Y), male(X).
// которое достанет из таблицы отношений вышеприведенный код запроса.
// _xxx - автогенеренный порядковый номер правила
Iterator<Iterator<Term>> father_2_xxx(object a, object b) {
    const int relationId_parent_2 = yyy;  // известно после этапа обработки исходного текста
    Relation parent_2 = relations[relationId_parent_2]; 
    
    // проходимся по всем фактам/правилам parent(X, Y)
    foreach(Term_2 ruleOrFactParent in parent_2 ) {
        // проходимся по всем цепочкам вывода parent(X, Y) 
        foreach(Iterator<Iterator<Term>> chainParent in ruleOrFactParent.invoke(a, b)) {
            const int relationId_male_1 = xxx;  // известно после этапа обработки исходного текста
            Relation male_1 = relations[relationId_male_1]; 
    
            // проходимся по всем фактам-правилам male(X)
            foreach(Term_1 termMale in male_1) {
                // проходимся по всем цепочкам-вывода male(X) для каждого факта-правила
                foreach(Iterator<Iterator<Term>> chainMale in termMale.invoke(a)) {
                    // конкатенируем 2 цепочки вывода, т.е. полностью перемножаем два множества
                    foreach(Iterator<Term> parent_N in chainParent) 
                    {
                        yield return parent_N;

                        foreach(Iterator<Term> male_M in chainMale) {
                            yield return male_M;
                    }   
                }
            }
        }  
    }
}