Реализация "последнего" в Prolog

Вопрос 1:

системы Prolog не всегда могут решить, будет ли предложение применяться до его выполнения. Конкретные обстоятельства зависят от выполнения. То есть вы не можете полагаться на это решение в целом. Системы улучшаются от выпуска к выпуску. Рассмотрим как самый простой случай:

?- X = 1 ; 1 = 2.
X = 1 ;
false.

очень умный Пролог может обнаружить, что 1 = 2 всегда терпит неудачу, и поэтому просто ответ . С другой стороны, такие "ум" очень дорогостоящ в реализации, и время лучше потратить на оптимизацию более частых случаев.

так почему прологи показывают это вообще? Основная причина заключается в том, чтобы не просить кротко другого ответа, если Пролог уже знает, что нет никакого другого ответа. Поэтому до этого улучшения вам был предложен другой ответ для всех запросов, содержащих переменные, и вы получили false или " нет " на каждом запросе с точно одним ответом. Это было так громоздко, что многие программисты никогда не спрашивали о следующем ответе и поэтому не были предупреждены о непреднамеренных ответах.

и вторичная причина заключается в том, чтобы держать вас в курсе ограничений реализации: если Prolog запрашивает другой ответ на этот общий запрос, это означает, что он по-прежнему использует некоторое пространство, которое может накапливать и съедать все ваши вычислительные ресурсы.

в вашем примере с last1/2 вы столкнулись с таким случаем. И вы уже сделали что-то очень умное, кстати: вы попытался минимизировать запрос, чтобы увидеть первое появление неожиданного поведения.

в вашем примере query last1([1,2],X) система Prolog не смотрит на весь список [1,2] но только смотрит на главный функтор. Поэтому для системы Prolog запрос выглядит так же, как last1([_|_],X), когда он решает, какие пункты применить. Эта цель теперь подходит для обоих предложений, и именно поэтому Prolog будет помнить второе предложение в качестве альтернативы для опробования.

но, подумайте об этом: этот выбор теперь возможен для всех элементы, но последние! Это означает, что вы платите некоторую память за каждый элемент! Вы можете наблюдать это, используя очень длинный список. Это я получаю на своем крошечном 32-битном ноутбуке - вам может потребоваться добавить еще один ноль или два в большей системе:

?- length(L,10000000), last1(L,E).
ERROR: Out of local stack

С другой стороны, предопределенные last/2 работает:

?- length(L,10000000), last(L,E).
L = [_G343, _G346, _G349, _G352, _G355, _G358, _G361, _G364, _G367|...].

в самом деле, он использует постоянный космос!

там теперь есть два выхода из этого:

1. попробуйте оптимизировать определение. Да, вы можете это сделать, но вам нужно быть очень умным! Например, определение @back_dragon неверно. Часто бывает, что начинающие пытаются оптимизировать программу, когда на самом деле разрушают ее семантику.

2. спросите себя, действительно ли вы определяете тот же предикат, что и last/2. На самом деле, нет.

вопрос 2:

считаем:

?- last(Xs, X).
Xs = [X] ;
Xs = [_G299, X] ;
Xs = [_G299, _G302, X] ;
Xs = [_G299, _G302, _G305, X] ;
Xs = [_G299, _G302, _G305, _G308, X] 
...

и

?- last1(Xs, X).
** loops **

таким образом, ваше определение отличается в этом случае определением SWI. Обменяйте порядок пунктов.

?- length(L,10000000), last2(L,E).
L = [_G343, _G346, _G349, _G352, _G355, _G358, _G361, _G364, _G367|...] ;
false.

опять же, это false! Но на этот раз, большой список работ. И на этот раз, минимальный запрос:

?- last2([1],E).
E = 1 ;
false.

и ситуация очень похожа: опять же, Prolog будет смотреть на запрос так же, как last2([_|_],E) и придет к выводу, что применяются оба положения. По крайней мере, теперь у нас постоянные накладные расходы вместо линейных.

есть несколько способов преодолеть эти накладные расходы чистым способом - но все они очень сильно зависят от внутренностей реализации.