Написать на языке Prolog программу для решения известной задачи о волке, козе и капусте

% main.pro
 
implement main
    open
        core,
        console %, list, math, string
 
constants
    wolf : symbol = "wolf".
    goat : symbol = "goat".
    cabbage : symbol = "cabbage".
    alone : symbol = "alone".
    left : symbol = "left".
    right : symbol = "right".
 
domains
    slist = string*.
    state = wgc(string, slist, slist).
    history = state*.
    moves = tuple{state, string}*.
 
class predicates
    solve_dfs : (state, history, moves) nondeterm (i,i,o).
    initial_state : (state) procedure (o).
    final_state : (state) determ anyflow.
    move : (state, string) multi (i,o).
    update : (state, string, state) nondeterm (i,i,o).
    update_boat : (string, string) determ (i,o).
    update_bank : (string, string, slist, slist, slist, slist) nondeterm (i,i,i,i,o,o).
    select : (string, slist, slist) nondeterm (i,i,o).
    insert : (string, slist, slist) nondeterm (i,i,o).
    precedes : (string, string) nondeterm (i,i).
    legal : (state) determ (i).
    illegal : (slist) nondeterm (i).
    test : () determ.
 
clauses
    test() :-
        initial_state(State),
        write(State),
        nl,
        solve_dfs(State, [State], Moves),
        foreach tuple(CurrentState, Animal) in Moves do
            write(CurrentState, " -> ", Animal),
            nl
        end foreach,
        final_state(State1),
        write(State1),
        nl,
        !.
 
    solve_dfs(State, _, []) :-
        final_state(State).
    solve_dfs(State, History, [tuple(State, Move) | Moves]) :-
        move(State, Move),
        update(State, Move, State1),
        legal(State1),
        not(State1 in History),
        solve_dfs(State1, [State1 | History], Moves).
 
    initial_state(wgc(left, [wolf, goat, cabbage], [])).
 
    final_state(wgc(right, [], [wolf, goat, cabbage])).
 
    move(wgc(left, L, _), Cargo) :-
        Cargo in L.
    move(wgc(right, _, R), Cargo) :-
        Cargo in R.
    move(wgc(_, _, _), alone).
 
    update(wgc(B, L, R), Cargo, wgc(B1, L1, R1)) :-
        update_boat(B, B1),
        update_bank(Cargo, B, L, R, L1, R1).
 
    update_boat(left, right).
    update_boat(right, left).
 
    update_bank(alone, _, L, R, L, R).
    update_bank(Cargo, left, L, R, L1, R1) :-
        select(Cargo, L, L1),
        insert(Cargo, R, R1).
    update_bank(Cargo, right, L, R, L1, R1) :-
        select(Cargo, R, R1),
        insert(Cargo, L, L1).
 
    insert(X, [Y | Ys], [X, Y | Ys]) :-
        precedes(X, Y).
    insert(X, [Y | Ys], [Y | Zs]) :-
        precedes(Y, X),
        insert(X, Ys, Zs).
    insert(X, [], [X]).
 
    precedes(wolf, _).
    precedes(_, cabbage).
 
    legal(wgc(left, _, R)) :-
        not(illegal(R)).
    legal(wgc(right, L, _)) :-
        not(illegal(L)).
 
    illegal(L) :-
        wolf in L,
        goat in L.
    illegal(L) :-
        goat in L,
        cabbage in L.
 
    select(X, [X | Xs], Xs).
    select(X, [Y | Ys], [Y | Zs]) :-
        select(X, Ys, Zs).
 
class predicates
    run : (integer).
clauses
    run(7) :-
        write("Задача о волке, козе и капусте"),
        nl,
        test,
        !.
    run(_).
 
    run() :-
        initUtf8,
        setConsoleTitle("Visual Prolog 9 Personal Edition: Консольное приложение"),
        run(7),
        _ = readLine().
 
end implement main
 
goal
    main::run.