Thanks to both Paul and Julien. I ended up using most of Julien's solution but wrote main this way: main(!IO) :- io.format("DOG + ANT = CAT\n", [], !IO), solutions( (pred({DOG, ANT, CAT}::out) is nondet :- dogAntCat(DOG, ANT, CAT)), Solutions ), ( if Solutions = [] then io.format("No Result.", [], !IO) else io.write_list(Solutions, "\n", writeDogAntCat, !IO), io.nl(!IO) ). So I could keep my old dogAntCat definition. It just felt better to have the option of flipping one of the arguments to an in argument at some point. I have a question about reordering predicates. The example had this to do that dogAntCat predicate: D0 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], C0 = 0, list.delete(D0, G, D1), list.delete(D1, T, D2), T = (G + T + C0) mod 10, C1 = (G + T + C0) / 10, list.delete(D2, O, D3), list.delete(D3, N, D4), A = (O + N + C1) mod 10, A\=0, C2 = (O + N + C1) / 10, list.delete(D4, D, D5), list.delete(D5, A, D6), C = (D + A + C2), D \= 0, 0 = (D + A + C2) / 10, list.delete(D6, C, _), DOG = 100 * D + 10 * O + G, ANT = 100 * A + 10 * N + T, CAT = 100 * C + 10 * A + T. is it equivalent to do: D0 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], C0 = 0, list.delete(D0, G, D1), list.delete(D1, T, D2), list.delete(D2, O, D3), list.delete(D3, N, D4), list.delete(D4, D, D5), list.delete(D5, A, D6), list.delete(D6, C, _), A = (O + N + C1) mod 10, A\=0, C2 = (O + N + C1) / 10, T = (G + T + C0) mod 10, C1 = (G + T + C0) / 10, C = (D + A + C2), D \= 0, 0 = (D + A + C2) / 10, DOG = 100 * D + 10 * O + G, ANT = 100 * A + 10 * N + T, CAT = 100 * C + 10 * A + T. It feels like it would be, but I'm not sure if the compiler does infer that kind of thing. <div>On 18/07/07, Julien Fischer <<a href="mailto:juliensf@csse.unimelb.edu.au">juliensf@csse.unimelb.edu.au</a>> wrote:<blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;"> Hi, On Wed, 18 Jul 2007, Nikolas Everett wrote: > I'm sure you get this a lot, but how can I ask Mercury to do something with > all the solutions that it finds for some predicate? At this point I'd just > like to print out all of my solutions, but I'm sure there are better things > to do then that. > > I've started with one of the programs in the Ralph Becket's tutorial and > produced the below. I've messed around a little with the solutions module, > but haven't gotten any where. The directory samples/solutions in the Mercury distribution contains exaqmple of how to use the predicates in the solutions module. There is also a brief discussion of the predicates in this module in the Prolog-to-Mercury transition guide, which is available here. <<a href="http://www.cs.mu.oz.au/research/mercury/information/doc-latest/mercury_trans_guide/All_002dsolutions.html#All_002dsolutions">http://www.cs.mu.oz.au/research/mercury/information/doc-latest/mercury_trans_guide/All_002dsolutions.html#All_002dsolutions </a>> > :- module first. > :- interface. > :- import_module io. > > :- pred main(io::di, io::uo) is cc_multi. > > :- implementation. > :- import_module int, list, string. > > main(!IO) :- > io.format("DOG + ANT = CAT\n", [], !IO), > ( if > dogAntCat(DOG, ANT, CAT) > then > io.format("%d + %d = %d\n", [i(DOG), i(ANT), i(CAT)], !IO) > else > io.format("No result.", [], !IO) > ). > > :- pred dogAntCat(int::out, int::out, int::out) is nondet. > dogAntCat(DOG, ANT, CAT) :- > ( if > D0 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], C0 = 0, > pick(D0, G, D1), > pick(D1, T, D2), > T = (G + T + C0) mod 10, C1 = (G + T + C0) / 10, > pick(D2, O, D3), > pick(D3, N, D4), > A = (O + N + C1) mod 10, A\=0, C2 = (O + N + C1) / 10, > pick(D4, D, D5), > pick(D5, A, D6), > C = (D + A + C2), D \= 0, 0 = (D + A + C2) / 10, > pick(D6, C, _) > then > DOG = 100 * D + 10 * O + G, > ANT = 100 * A + 10 * N + T, > CAT = 100 * C + 10 * A + T > else > fail > ). The if-then-else in the body of this clause is redundant. > :- pred pick(list(int)::in, int::out, list(int)::out) is nondet. > pick([X | Xs], X, Xs). > pick([X | Xs], Y, [X | Zs]) :- pick(Xs, Y, Zs). This predicate is available in the standard library in the list module under the name list.delete/3. A version of the above program that writes out all solutions using the predicate solutions/2 is: :- module first. :- interface. :- import_module io. :- pred main(io::di, io::uo) is det. :- implementation. :- import_module int. :- import_module list. :- import_module solutions. :- import_module string. main(!IO) :- io.format("DOG + ANT = CAT\n", [], !IO), solutions(dogAntCat, Solutions), ( Solutions = [], io.format("No result.", [], !IO) ; Solutions = [_ | _], io.write_list(Solutions, "\n", write_solution, !IO), io.nl(!IO) ). :- pred dogAntCat({int, int, int}::out) is nondet. dogAntCat({DOG, ANT, CAT}) :- D0 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], C0 = 0, list.delete(D0, G, D1), list.delete(D1, T, D2), T = (G + T + C0) mod 10, C1 = (G + T + C0) / 10, list.delete (D2, O, D3), list.delete(D3, N, D4), A = (O + N + C1) mod 10, A \= 0, C2 = (O + N + C1) / 10, list.delete(D4, D, D5), list.delete(D5, A, D6), C = (D + A + C2), D \= 0, 0 = (D + A + C2) / 10, list.delete(D6, C, _), DOG = 100 * D + 10 * O + G, ANT = 100 * A + 10 * N + T, CAT = 100 * C + 10 * A + T. :- pred write_solution({int, int, int}::in, io::di, io::uo) is det. write_solution({DOG, ANT, CAT}, !IO) :- io.format("%d + %d = %d", [i(DOG), i(ANT), i(CAT)], !IO). Cheers, Julien. -------------------------------------------------------------------------- mercury-users mailing list Post messages to: <a href="mailto:mercury-users@csse.unimelb.edu.au">mercury-users@csse.unimelb.edu.au</a> Administrative Queries: <a href="mailto:owner-mercury-users@csse.unimelb.edu.au"> owner-mercury-users@csse.unimelb.edu.au</a> Subscriptions: <a href="mailto:mercury-users-request@csse.unimelb.edu.au">mercury-users-request@csse.unimelb.edu.au</a> -------------------------------------------------------------------------- </blockquote></div>