Below in code, the representation of a expert system to give response to a pattern of problems in a device (in this case, a mobile one), with the result being the probable cause of the issues, but as you may have seen in the title, this throw a especific error:
go :- catch(Problem),
print("Your problem is probably a"),
print(Problem),
print("Issue"),
nl.
input(Question) :-
write('You have problems such as the follwing:'),
write(Question),
write('?'),
read(output),
nl,
(( output == yes; output == y)
->
assert(yes(Question));
assert(no(Question)), fail).
:- dynamic yes/3, no/1.
verify(Problem):-
(yes(Problem)
-> true;
(no(Problem)
->
fail;
input(Problem))).
undo :- retract(yes(_)),fail.
undo :- retract(no(_)),fail.
undo.
grasp(low_battery) :- low_battery,!.
grasp(software_problem) :- software_problem,!.
grasp(hardware_problem) :- low_battery,!.
%grasp(virus_or_memory_issue) :- virus_or_memory_issue,!.
low_battery :-
verify(phone_not_recharged),
verify(charger_not_working).
software_problem :-
verify(device_turns_on_but_crashes),
verify(some_program_dont_work),
verify(more_than_one_program_crashes_after_awhile),
verify(some_programs_are_not_updated_or_deprecated).
%hardware_problem :-
%verify(device_dont_turn_on),
%verify(device_warmth_frequently),
%verify(screen_exhibits_atipical_visual_patters),
%verify(problems_began_or_intensified_after_fall_or_any_damage).
As a result, the given console is as follows:
ERROR: Unknown procedure: catch/1
ERROR: However, there are definitions for:
ERROR: catch/3
ERROR:
ERROR: In:
ERROR: [11] catch(_4812)
ERROR: [10] go at c:/users/victo/onedrive/documentos/prolog/sistema_especialista.pl:1
ERROR: [9] toplevel_call(user:user:go) at c:/program files/swipl/boot/toplevel.pl:1158
Exception: (11) [user] catch(_4356) ?
Searching for material I've found very little on such matter, and other algoritms I've found were quite not like this one. Any help would be very welcome.
Related
A little test code with no particular meaning:
:- use_module(library(chr)).
:- chr_constraint foo/1, bar/1, anyone/2.
foo(X) \ bar(Y) <=> anyone(X,Y).
anyone(_,Y) <=> bar(Y) | writef("bar(%w) exists\n",[Y]).
anyone(_,Y) <=> writef("bar(%w) does not exist\n",[Y]).
If the above is consulted from the SWI Prolog command line and then run with:
?- foo(8),bar(10).
there is overflow after some time:
Could not reenable global-stack
Could not reenable global-stack
ERROR: Out of global-stack.
ERROR: No room for exception term. Aborting.
Could not reenable global-stack
ERROR: Out of global-stack.
ERROR: No room for exception term. Aborting.
ERROR: Execution Aborted
% Execution Aborted
However, if the code for the second rule is changed by moving the test for bar from the guard ot the head:
:- use_module(library(chr)).
:- chr_constraint foo/1, bar/1, anyone/2.
foo(X) \ bar(Y) <=> anyone(X,Y).
anyone(_,Y),bar(Y) <=> writef("bar(%w) exists\n",[Y]). % changed!
anyone(_,Y) <=> writef("bar(%w) does not exist\n",[Y]).
then execution terminates:
?- foo(8),bar(10).
bar(10) does not exist
foo(8).
Is this an accident of the implementation? It does seem a bit dicey.
Furthermore, the above code was written because I wanted to test whether the constraint to be removed from the store (here, bar(Y)) would be available in the body of the rule. Apparently not, it is already gone when the rule body executes; but is this implementation dependent or a necessary or specified behaviour of CHR?
I am getting an error when i tried to read a file as operator expected.
main:-
open('cr1.txt',read,Str),
read_houses(Str,Houses),
close(Str),
write(Houses), nl.
read_houses(Stream,[]):-
at_end_of_stream(Stream).
read_houses(Stream,[X|L]):-
\+ at_end_of_stream(Stream),
read(Stream,X),
read_houses(Stream,L).
I am learning Prolog and .(a,[]) == [a]. should return true in SWI-Prolog, but it gives me an error saying
ERROR: Type error: `dict' expected, found `a' (an atom)
ERROR: In:
ERROR: [11] throw(error(type_error(dict,a),_4020))
ERROR: [10] '$type_error'(dict,a) at /Applications/SWI-
Prolog.app/Contents/swipl/boot/init.pl:3369
ERROR: [9] '$dicts':'.'(a,[],_4086) at /Applications/SWI-
Prolog.app/Contents/swipl/boot/dicts.pl:46
ERROR: [8] '<meta-call>'(user:(...,...)) <foreign>
ERROR: [7] <user>
Anyone knows how to fix this?
Start the SWI Prolog executable with the --traditional command line option (comment due to user:false).
Then it works:
1 ?- .(a,[]) == [a].
true.
2 ?- current_prolog_flag( traditional, X).
X = true.
3 ?- set_prolog_flag( traditional, false).
ERROR: set_prolog_flag/2: No permission to modify flag `traditional'
4 ?-
This is mentioned in the documentation here (see "traditional", near the bottom of the page).
As can be seen, attempting to change it from within the running SWI session, fails.
I tried the code below and I got:
ERROR: No permission to open websocket `'ws://localhost:9999''.
Why?
If I use root(.), it's ok.
UPDATED (correct code):
:- use_module(library(http/websocket)).
:- use_module(library(http/thread_httpd)).
:- use_module(library(http/http_dispatch)).
:- use_module(library(http/http_path)).
:- use_module(library(http/http_authenticate)).
:- initialization main.
main :-
run.
:- http_handler(root(ws), http_upgrade_to_websocket(echo, []), [spawn([])]).
echo(WebSocket) :-
ws_receive(WebSocket, Message),
( Message.opcode == close
-> true
; ws_send(WebSocket, Message),
echo(WebSocket)
).
run :-
run(9999).
run(Port) :-
http_server(http_dispatch, [port(Port)]).
stop :-
stop(9999).
stop(Port) :-
http_stop_server(Port, []).
In abstract terms, If you use root(X), then this means that the path where this is available is /X.
So, if you specify root(ws), then in your case, you would have to access:
ws://localhost:9999/ws
If you specify root(.) then / suffices etc.
Next time, please specify a complete example, so that others can actually try out your code without having to guess the remainder of your snippet.
I'd like to print a message and stop the evaluation of the predicate. How do I do that?
Take a look at this link where the catch/3 and throw/1 mechanisms in Prolog are described.
It is possible to throw an exception or handle an exception using this mechanism.
The example (given on the site) is:
p:- true.
p:- throw(b).
q:- catch(p, B, write('hellop')), r(c).
r(X) :- throw(X).
Then the call:
?- catch(p, X, (write('error from p'), nl)).
will illustrate the ecxeption handling.
I played with a few other examples which I found. This might be usefull.
p :- throw(b).
r(X) :- throw(X).
q:- catch(p, B, format('Output1: Error from throwing p')), r(B).
catch(throw(exit(1)), exit(X), format('Output: `w', [X])).
Output: 1
1 is thrown to catcher 'exit(X)' and recovered by format('Output: ~w', [X])),
catch(p, C, format('hellop')).
Output: hellop
p throws 'b' which is recovered by writing 'hellop'
catch(q, C, format('Output2, Recovering q: helloq ')).
Output1: Error from throwing p
Output2, Recovering q: helloq
Ben
The stderr stream is aliased to user_error (see https://www.swi-prolog.org/pldoc/man?section=streamalias )
You can write a term (like a string) to a stream using write/2.
You can stop the program using halt.
For example:
% Happy case. Comes first, uses ! to avoid taking the alternative branch
foo(X) :- bar(X, Y), baz(Y), !.
% Fallback branch, in case the above failed. Writes a message and halts.
foo(X) :-
write(user_error, "Couldn't foo"),
halt.