Vfrdtyky

I'm trying to do a simple tree search in Prolog, and I need a function that would return a list of children for a given node.

My code is:

root(a).

node(a, [b, c]).

node(b, ).

node(c, [d, e, f]).

node(d, ).

node(e, ).

node(f, ).



children(node(_, Kids), Kids).



node_matches(_,_).

node_matches(Criteria, [Head|Tail]) :- node_matches(Criteria, Head), node_matches(Criteria, Tail).



search_node(Criteria, [Node]) :- node_matches(Criteria, Node), search_node(Criteria, children(Node)).

Currently I'm getting and error Undefined procedure: children/1, which makes sense, because I haven't implemented a function with 1 argument.
How can I implement such a function?

Since you are interested in a list, why not considering the use of DCGs for the task? After all, DCGs describe lists and they yield easily readable code. Conveniently, your given facts node/2 provide the direct successors of a node in a list, so it is opportune to use a list of nodes to be visited as the DCGs single argument. The DCG itself could be named after what it describes, for example children//1. You can define a calling predicate, let's also give it a nice descriptive name, say node_children/2, that uses phrase/2 to call the DCG:

node_children(N,C) :-

   node(N,Succs),             % Succs are the direct successors of node N

   phrase(children(Succs),C). % based on them the DCG children//1 describes the list C

The DGC children//1 has to describe a list that consists of all the nodes in its argument-list and their respective children, that is, their respective successors, their successors' successors, and so on (that wording already bears the scent of recursion :-). So children//1 might look something like this:

children() -->       % if there are no nodes

   .                 % there are no children

children([N|Ns]) -->   % N, the first node in the list...

   {node(N,Succs)},    % ...has the direct successors Succs...

   [N],                % ...and is in the list of children...

   children(Succs),    % ...as well as its successors and their children...

   children(Ns).       % ...as well as the other nodes in the list

In the first goal of the recursive rule of children//1, {node(N,Succs)}, you can observe how predicates can be called in a DCG, namely enclosed by braces. Now let's see node_children/2 in action:

   ?- node_children(a,C).

C = [b,c,d,e,f]

   ?- node_children(b,C).

C = 

   ?- node_children(c,C).

C = [d,e,f]

You can also ask more general queries like What nodes and respective children are there?:

   ?- node_children(N,C).

C = [b,c,d,e,f],

N = a ? ;

C = ,

N = b ? ;

C = [d,e,f],

N = c ? ;

C = ,

N = d ? ;

C = ,

N = e ? ;

C = ,

N = f

Or Which nodes have three children?:

   ?- C=[_,_,_], node_children(N,C).

C = [d,e,f],

N = c ? ;

no

Two closing remarks: You can see how the DCG children//1 is translated into a predicate by querying ?- listing(children).. To learn more about DCGs I can wholeheartedly recommend this DCG Primer.