如何为Prolog非确定性目标的解添加索引？求更优方案

Great question! Your current approach works, but relying on non-backtrackable global variables (nb_setval/nb_getval) introduces side effects, and findnsols forces you to build full solution lists even when you don't need them. Let's fix this with pure, declarative Prolog that lets you generate indexed solutions one at a time, no global state required.

1. Core Idea: Recursive, Backtrackable Counter #

Instead of a global counter, we'll pass the current index as a parameter in a recursive predicate. This keeps state local and respects Prolog's backtracking behavior, so you can generate solutions one by one without building a full list.

Here's a reusable predicate that wraps your non-deterministic goal and adds an index starting from any value you choose:

enumerate_with_index(Goal, StartIdx, Idx, Val) :-
    % First, run the goal to get a value, assign the current index
    call(Goal, Val),
    Idx = StartIdx.
enumerate_with_index(Goal, StartIdx, Idx, Val) :-
    % Then, increment the index and recurse to get the next solution
    NextIdx is StartIdx + 1,
    enumerate_with_index(Goal, NextIdx, Idx, Val).

How to Use It #

For your test case with L = [a,b,c,d,e], you can query it directly to get solutions one at a time:

?- L = [a,b,c,d,e], enumerate_with_index(member(It, L), 0, Idx, It).
Idx = 0, It = a ;
Idx = 1, It = b ;
Idx = 2, It = c ;
Idx = 3, It = d ;
Idx = 4, It = e.

Each time you press ;, you get the next indexed solution—no list is built unless you explicitly collect it.

2. Limit to N Solutions (Without Building a List) #

If you only want the first N indexed solutions, you can add a simple guard to stop recursion once the index reaches your limit:

enumerate_n_indexed(Goal, StartIdx, MaxN, Idx, Val) :-
    StartIdx < MaxN,
    call(Goal, Val),
    Idx = StartIdx.
enumerate_n_indexed(Goal, StartIdx, MaxN, Idx, Val) :-
    StartIdx < MaxN,
    NextIdx is StartIdx + 1,
    enumerate_n_indexed(Goal, NextIdx, MaxN, Idx, Val).

Usage for your test case (get first 3 solutions):

?- L = [a,b,c,d,e], enumerate_n_indexed(member(It, L), 0, 3, Idx, It).
Idx = 0, It = a ;
Idx = 1, It = b ;
Idx = 2, It = c.

Why This Is Better Than Your Current Approach #

• No global side effects: The counter is local to the predicate call, so backtracking works as expected (no leftover state from previous queries).
• No mandatory list generation: You get solutions one at a time, which is perfect if you want to process each value immediately without storing all of them.
• Declarative style: The code describes what you want (indexed solutions) rather than how to do it (manipulating global variables).

Bonus: Collect Solutions into a List (If You Need To) #

If you ever do want a list of indexed solutions, you can use findall with the core predicate—no need for findnsols or global variables:

?- L = [a,b,c,d,e], findall((Idx, It), enumerate_with_index(member(It, L), 0, Idx, It), Out).
Out = [(0, a), (1, b), (2, c), (3, d), (4, e)].

内容的提问来源于stack exchange，提问作者Jacek