wiki.visual-prolog.com - User contributions [en]

3rd:HTML drawer

2011-05-29T14:54:05Z

Steve Lympany: /* Downloads */ new link

drawHTML.DLL is a DLL is written in VIP7.3. The DLL can be linked with VIP projects - the "glue" code and examples are provided. It is used simply to draw nice text: you can control text colour and font styles using HTML tags. Text wrapping and centring are dynamic, and both can apply to different parts of the same HTML text. The main call is (you will recognise):

'''DrawHTML:drawTextInRect(WindowType,RCT,HTML,FLAGS)'''

Also, certain attributes can be called from your own code e.g.

'''DrawHTML:set_wrap(true),'''

A limited number of tags are understood. Some of these are standard HTML, and some are unique to the DLL.
==Standard HTML tags==

*<nowiki></nowiki> ''italic'' 
*<nowiki></nowiki> '''bold''' 
*<nowiki></nowiki> underline 
*<nowiki> </nowiki> new line
*<nowiki></nowiki> subscript
*<nowiki></nowiki> superscript
*<nowiki><par></nowiki> also new line
*<nowiki><t></nowiki> tab
*<nowiki><big></nowiki> increase font size </big>
*<nowiki></nowiki> decrease font size 
*<nowiki> <a ref=\"some text\">hyperlink</a></nowiki>. Anchor: if the user clicks on this word, the callback will return "some text".
*<nowiki><img src=\"file.bmp\"></nowiki> draws an image.
==Non-standard Tags==

*<nowiki><c></nowiki> centred text on </c> ... and off
*<nowiki><wr></nowiki> turn wrapping on </wr> ... and off
*<nowiki><lm=\"20\"></nowiki> left margin = 20 pixels
*<nowiki><font=\"arial\"></nowiki> change font
*<nowiki><color=\"#FF00FF\"></nowiki> set text colour </color>
*<nowiki><hi></nowiki>text within these tags are hidden when hide=active, and displayed as normal when hide=inactive</hi>

==Downloads==
Further information and downloads can be found here:
http://www.acsumama.com/vip/drawhtml/index.htm

3rd:Tools & Support

2011-05-26T14:29:18Z

Steve Lympany: /* Miscellaneous */ Web Easy

=== Text Editors and Utilities ===

* Powerful text editor (not free): [http://www.boxersoftware.com/ Boxer Text Editor]
* Free Text editor: [http://notepad-plus.sourceforge.net/uk/site.htm Notepad++]
* Powerful editor: [http://www.textpad.com/ TextPad]
* Diff tool: [http://www.scootersoftware.com/ Beyond Compare]
* Regular Expressions tool: [http://www.ultrapico.com/Expresso.htm Expresso]
* Follow file changes while they happen: [http://tailforwin32.sourceforge.net/ Tail for Win32]
* Windows bug "File in use" - very useful [http://ccollomb.free.fr/unlocker/ Free File unlocker]

=== Creating Help Files ===

* CHM Editor : [http://visual-chm.wekasoft.downloadsoftware4free.com/ Visual CHM ] Cheap
* CHM Editor : [http://www.vizacc.com/downloads.aspx Visacc] Free.
* WYSIWYG HTML editor (Use Netscape '''7.2'''): [http://browser.netscape.com/downloads/archive/ Netscape Browser Archive] Free
* HTML editor: [http://www.pagebreeze.com/ PageBreeze] Cheap but look at Web Easy 8

=== Microsoft Windows Support ===

* Windows Problem Solving [http://winhlp.com/ Windows Problem Solver (winhlp.com)]
* Toolbox (free) [http://technet.microsoft.com/en-us/sysinternals/bb545027.aspx Sysinternals Utilities] (from [http://technet.microsoft.com Microsoft Technet]). Notice especially:
** [http://technet.microsoft.com/en-us/sysinternals/bb896653.aspx Process Explorer]
** [http://technet.microsoft.com/en-us/sysinternals/bb896645.aspx Process Monitor]

=== Miscellaneous ===

* Charting Tool: [http://www.pacestar.com/wizflow/index.html WizFlow]
* Easy Flash Editor (Swish Max2) : [http://www.swishzone.com/index.php SWiSHzone]
* BNF stuff : [http://www.garshol.priv.no/download/text/bnf.html BNF and EBNF] by ''Lars Marius Garshol''
* BNF Stuff : [http://cui.unige.ch/db-research/Enseignement/analyseinfo/AboutBNF.html What is BNF notation?] by ''Th. Estier, CUI - University of Geneva''
* Windows apps reviews : [http://www.winsupersite.com/reviews/ SuperSite Reviews] on ''Paul Thurrott's SuperSite for Windows''.
* Windows installer: [http://www.jrsoftware.org/isinfo.php INNOSET].
* Website creator: [http://www.webeasysite.com/UK/ Web Easy] Very good, and cheap

__NOTOC__

Steve Lympany: Added "Availability/Versions" and Examples sections, plus tidy up

===Basics===

Microsoft provides a Speech API - SAPI - which covers both Speech Recognition and Speech Synthesis. It is provided as a DLL, which works very nicely (thanks to Thomas and co.) with Visual Prolog 7.2. It is surprisingly accurate and responsive, even with a cheap microphone. Microsoft has produced SAPI recognizers for 4-5 languages including English. PDC has produced a SAPI recognizer for Danish:
[http://www.pdc.dk/dk/dictus/ Dictus]. There may also be SAPI recognizers for other languages (but other than MS and PDC there don't seem to be any).

SAPI is the link between programs and Speech Recognition Engines, much like ODBC is the link between programs and SQL databases.

Generally, the COM/DLL is provided with Windows (but see below - "Availability"). With a copy of the DLL in your project folder, it's easy to import it into your project. It is not necessary for it to be there at run time (i.e. there's no need to distribute it with your app to end users).

[http://www.microsoft.com/downloads/details.aspx?FamilyID=5e86ec97-40a7-453f-b0ee-6583171b4530&displaylang=en MS Download site]; you need the 68Mb file '''SpeechSDK51.exe''' near the bottom of the page.

The SAPI overviews are here:

* [http://msdn.microsoft.com/en-us/library/aa911607.aspx SAPI5.0 overview]
* [http://msdn.microsoft.com/en-us/library/ms720151(VS.85).aspx SAPI5.3 overview]
To do - SAPI5.1 on the MS site?

When your program runs, you say something into the mic, pause, and the speech callback predicate is called. You then extract what was spoken as a string_list, which you pass onto your own predicate to process. 
To do - Other data can be extracted? 
Describe where the Speech Recognition Engine itself resides.
 

===Setting up your project===

When you create a new VIP project and try to generate the prolog "glue" to the SAPI COM, the code generated is not perfect. You will have noticed in the forum that this is not a trivial task, and everyone seems to write their COMs differently. So Thomas has provided the tidied-up code here:

* [http://discuss.visual-prolog.com/viewtopic.php?t=8206 SAPI COM glue]

So first generate the faulty COM code using the IDE (at the point where you add the DLL to the project) so that all the folders and classes are created, and then overwrite these files with the correct code in Windows explorer. 

===Dictation versus Commands===

Briefly, SAPI works in two modes. One is dictation - a "free form" mode for dictating letters etc. SAPI does a reasonable job. ToDo - is there a training mode? 

The second mode is "command mode" whereby SAPI is provided with a grammar that makes it easier for it to understand, since there is a restricted limited number of words to work with. If you give it a grammar such as:

* "turn red"
* "turn blue"

it will totally ignore the command if you say "turn yellow" - the callback function is not called at all. If you say "turn bed", it will probably return the "turn red", or nothing at all.

The grammar file required (if you don't want dictation) is an XML file. The help file for writing an XML grammar file is provided in the download above. The rules for writing the XML file are straightforward, and for simple grammars the XML is easy to write. But if you get something slightly wrong (even though the XML structure itself is correct), you will get an exception when your program loads and compiles it(the SAPI engine compiles the XML).

The grammar file can have a rule saying "dictation" (free form) is expected. 
===Grammar Format Tags===
The XML Grammar Format Tags are described the SDK Manual. Briefly these are:
<pre>
<GRAMMAR> - the file starts with this, and ends with </GRAMMAR>;
<RULE> - the tag for defining sentences (a list of other tags). A RULE parent must always be <GRAMMAR>;
<DICTATION> - for free-form dictation;
<LIST> or <L> - children can be lists of PHRASEs for example;
<PHRASE> or - specifying the words to be recognised;
<OPT> or <O> - specifying words that might be said (i.e optional);
<RULEREF> - for recursively calling other RULEs;
<WILDCARD> - to allow recognition of some phrases without failing due to irrelevant, or ignorable words;
<RESOURCE> - to store arbitrary string data on rules (e.g. for use by a CFG Interpreter);
<TEXTBUFFER> - used for applications needing to integrate a dynamic text box or text selection with a voice command.
</pre> 
Many of the tags can have children which are other tags, but not all, and equally some tags are restricted as to their parent tag. <DICTATION> and <RULEREF> can have no children. <RULE> can only have <GRAMMAR> as a parent. <GRAMMAR> must have one or more <RULE>s as children, and no other type (except <ID> which is discussed below). 

Only the <PHRASE> and <OPT> tags contain words/phrases that will be recognisable spoken words 
=== SAPI.DLL Availability/Versions ===

*Windows Vista and Windows 7: SAPI 5.3 is part of Windows Vista and Windows 7, but it will only work for the languages that Microsoft supports (and Danish with PDC's engine).

*Windows XP: On XP you will get SAPI 5.1 with Office 2003 (but not 2007), and you can get it as part of the SDK download mentioned above. And you can get it as a installer merge module to merge into an installer you create yourself.

*Notes: 
** You cannot (do not!) install SAPI 5.1 on a Vista or Windows 7. 
** A program that uses SAPI 5.1 can also (without any changes) use SAPI 5.3. 
** The SAPI import provided by PDC is actually based on SAPI 5.3 (but it probably does not expose anything that is not also in 5.1). SAPI 5.3 is a conservative extension of SAPI 5.1. It's forwards compatible: a program that works with 5.1 will also work with 5.3, but not necessarily the other way around. 

=== Examples ===
Here are a few examples of grammars. These are the actual contents stored in the XML file.

# Example 1 - Recognises the word "hello" only.
<PRE>
<GRAMMAR>
<RULE>
hello
</RULE>>
</GRAMMAR>
</PRE>
to do 
=== References ===

* [[wikipedia:Microsoft Speech API]]

Steve Lympany: /* Fact variables */

This page contains a collection of basic examples for (mainly) the newer constructs found in VIP7.
 
=== Fact variables ===

Fact variables are the only mutable types in VIP.

'''Examples - "reminder- ordinary facts"'''

<vip>facts
ndb_int:(integer). % a nondeterministic fact (0 to any number of values)
db_int:(integer,string) determ. % a deterministic fact (0 to 1 value)</vip>

These types of fact are asserted and retracted.

'''Examples - "fact variables"'''
<vip>facts
zz_int:integer:=0.
zz_fred:integer:=erroneous.

domains
dom=dom(string,chaindb:ref).

facts
zz_dom:dom:=erroneous.

clauses
pred():-
zz_int:=7,
stdio::write("\n zz_int = ",zz_int), %will write "zz_int=7"
zz_int:=zz_int+20,
stdio::write("\n zz_int = ",zz_int), %will write "zz_int=27"
succeed.</vip>

A fact variable is great for counting eg.

<vip>predicates
how_many:()->integer Count.
clauses
how_many()=_:-
zz_int:=0,
some_nondeterm_fact_or_pred(),
zz_int:=zz_int+1,
fail.
how_many()=zz_int.
clauses
pred():-
stdio::write("\n There are ",how_many()," items").
</vip>
 

=== Lists - findall and list comprehension ===

See [http://wiki.visual-prolog.com/index.php?title=Lists_and_Recursion Lists and Recursion] 
<vp>findall()</vp> has been depricated, so use the list comprehension construct.

'''Examples'''
<vip>facts
ndb:(integer). %default is nondeterm for a fact
clauses
ndb(1).
ndb(2).
ndb(3).
....
ndb(10).
clauses
pred_old():-
findall(X,ndb(X),List).
%results in List = [1,2,3,4,5,6,7,8,9,10]
clauses
pred_new():-
List=[X||ndb(X)].
%results in List = [1,2,3,4,5,6,7,8,9,10]
clauses
pred_filter():-
List=[X||ndb(X), X>6].
%results in List = [7,8,9,10]

pred_filter():-
List=[X||ndb(X), X mod 2=0].
%results in List = [2,4,6,8,10]

pred_filter():-
List=[X||ndb(X), X mod 2=0, X<7].
%results in List = [2,4,6]

pred_filter():-
zz_int:=0,
List=[X||ndb(X), X mod 2=0, X<7, zz_int:=zz_int+1].
%results in List = [2,4,6] and zz_int=3.

pred_filter():-
List=[X||ndb(X), Y=pred2(X), Y>10]. %with pred2(X)=X^2.
%results in List = [4,5,6,7,8,9,10]
%reason - X=3 gives Y=9 which is < 10.

pred_other():-
L=[1,2,3,4,5,6,7,8,9,10],
LIST=[ X || X = list::getMember_nd(L)].
%results in List= L

pred_other():-
Primes=[X||X=std::fromto(1,300),
L1=[Y||Y=std::fromto(2,150)],
tt(X,L1)].
%results in List= prime numbers, with:
class predicates
tt:(integer,integer*) determ.
clauses
tt(_X,[]):-!.
tt(X,[X|_]):-!.
tt(X,[Y|L]):-
X mod Y<>0,
tt(X,L).

</vip>
 
=== if-then-else (code) ===

'''Examples'''

<vip>clauses
pred(X):-
if X>0 then
stdio::write("\n X>0") %the last line in each block has no comma
else
stdio::write("\n X<=0")
end if.

pred(X):-
if X>0 then
stdio::write("\n X>0")
elseif X = 0 then
stdio::write("\n X=0")
else
stdio::write("\n X<0")
end if.

clauses
pred(X,Y)=Z:-
if X=0 then
Z="x is zero"
elseif X>0 then
if pred3(Y)=true then
Z="x>0 and pred(Y) is true"
else
Z="x>0 and pred(Y) is false"
end if %note, no comma here either
else
Z="x <0"
end if.</vip>

 
=== #if #then #else (directive for conditional compilation) ===

'''Examples'''

<vip>constants
u64_con=1.
int_con=2.
real_con=3.

compile_big_con=u64_con. %change this and then recompile.

#if compile_big_con=u64_con #then
predicates
pred:()->unsigned64.
clauses
pred()=U64:-
U64=78766.

#elseif compile_big_con=int_con #then
predicates
pred:()->integer.
clauses
pred()=Int:-
Int=20.

#else
predicates
pred:(real [out]).
clauses
pred(0.766).

#endif</vip>

'''Note''' 
Code construct uses <vp>if - then</vp>, <vp>elseif - then</vp>, <vp>else</vp>, <vp>end if</vp> 
compiler directive uses <vp>#if - #then</vp>, <vp>#elseif - #then</vp>, <vp>#else</vp>, <vp>#endif</vp>
 (just the "end if" is "different")

 
=== Trap and try/catch/finally ===

See [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Terms/Try-catch-finally Try-catch-finally] 
Note, in
[http://wiki.visual-prolog.com/index.php?title=Language_Reference/Built-in_entities/Predicates Built-in entities/Predicates] 
suggests using <vp>try-end try</vp> instead of <vp>trap(_,_,_)</vp>

'''Example 1'''

<vip>clauses
pred_all():-
try
call_pred_that_might_crash(0)
catch ErrorNo do
call_own_exception_pred(ErrorNo)
finally
always_call_this_anyway()
end try.

class predicates
call_pred_that_might_crash:(integer).
call_own_exception_pred:(pointer ErrorNo).
always_call_this_anyway:().
clauses
call_pred_that_might_crash(X):-
Y=9/X.

call_own_exception_pred(ErrorNo):-
vpiCommonDialogs::note("crashed").

always_call_this_anyway():-
vpiCommonDialogs::note("finally reached").</vip>

'''Example 2'''

<vip>clauses
pred_some():-
try
call_pred_that_might_crash(0)
finally
always_call_this_anyway()
end try.</vip>

% in this case, VIP will automatically pop up its exception dialog

'''Example 3'''

<vip>clauses
pred_some():-
try
call_pred_that_might_crash(0)
catch ErrorNo do
call_own_exception_pred(ErrorNo)
end try.</vip>

'''Example 4''' - illegal - it must have a <vp>catch</vp> or <vp>finally</vp>

<vip>clauses
pred_illegal():-
try
call_pred_that_might_crash(0)
end try.</vip>

 
=== 64 bit numbers - history ===
Up to VIP7.1, integer64 etc were defined as: 
<vip>
domains
unsigned64 = unsigned64(unsigned32 Low, unsigned32 High).
integer64 = integer64(unsigned32 Low, integer32 High).
</vip>

In VIP7.2 these have been renamed: 
<vip>
unsigned64_struct = unsigned64(unsigned Low, unsigned High).
integer64_struct = integer64(unsigned Low, integer High).
</vip>

So, for example, in VIP7.1:
<vip>
getFileProperties : (
string FileName,
fileSystem_api::fileAttributes Attributes,
fileSystem_api::fileSize Size,
core::gmtTimeValue Creation,
core::gmtTimeValue LastAccess,
core::gmtTimeValue LastChange)
procedure (i,o,o,o,o,o).
</vip>
if you needed use (and write) '''fileSize''' and times, you would have to have done some juggling (such as converting them to real numbers).
 To generate a 64 bit random number: 
<vip>predicates %before VIP7.2
gen64:()->unsigned64.
clauses
gen64()=U64:-
N= 2^32,
Low=math::random(N+0),
High=math::random(N+0),
U64=unsigned64(Low,High).
</vip>

and possibly you would have needed (e.g.) '''math::add''': 

<vip>
add : (core::unsigned64 Augend, core::unsigned64 Addend) -> core::unsigned64 Sum
</vip>

It's now totally straightforward in VIP7.2 - just treat 64 bit numbers like any other number. You may also want these conversions - found in '''core::''' - for old code (this snippet is stolen from [http://discuss.visual-prolog.com/viewtopic.php?t=7927 Thomas' post]) 
<vip>
predicates
toUnsigned64 : (unsigned64_struct) -> unsigned64.
fromUnsigned64 : (unsigned64) -> unsigned64_struct.
toInteger64 : (integer64_struct) -> integer64.
fromInteger64 : (integer64) -> integer64_struct.
</vip>
 
And just for reference: 
[http://wiki.visual-prolog.com/index.php?title=Language_Reference/Built-in_entities/Domains#integer integer] range = -2^31 to +2^31 = -2147483648 .. 2147483647 
[http://wiki.visual-prolog.com/index.php?title=Language_Reference/Built-in_entities/Domains#unsigned unsigned] range = 0 to (2^32)-1 = 4294967295 
[http://wiki.visual-prolog.com/index.php?title=Language_Reference/Built-in_entities/Domains#integer64 integer64] range = -2^63 to 2^63 
[http://wiki.visual-prolog.com/index.php?title=Language_Reference/Built-in_entities/Domains#unsigned64 unsigned64] range= 0 to (2^64)-1 = 18446744073709551615 (=1.844..E19) 
 

=== Polymorphic Domains ===
See [http://wiki.visual-prolog.com/index.php?title=Objects_and_Polymorphism Objects and Polymorphism] 

First, check out the definitions - '''core::tuple{}'''. And while you're there, just below, see '''core::predicate{}''' and '''core::function{}''', then followed by '''comparator{A}''' and '''list{A}'''. 

The domains in class '''list::''' are polymorphic, but you can define your own polymorphic domains. Here are some examples:
<vip>domains
poly_dom{A,B}=poly_def(A,B).
</vip>
When you use it in your code, A and B can be any other domain. 
The domain name is '''poly_dom{A,B}''', and you reference it you must use its whole name (not just '''poly_dom''') e.g. 
<vip>
domains
joe{A,B}=poly_dom{A,B}*.
/* the next two lines are illegal
poly_dom{A,B}=poly_def(A,B)*.
poly_dom{A,A}=poly_def(A,A).
*/
fred{A,B}=fred(poly_dom{A,B},integer).

maybe_silly_dom{A,B}=silly2(A,B);
silly(A);
pd(poly_dom{A,B});
poly_dom(A,B);%IS NOT THE SAME POLY_DOM!! (notice no braces)
s(string).

another{A}=i(integer);
s(string);
a(A);
self(another({A}).

facts
zz_poly_dom:poly_dom{integer,integer}:=erroneous.

class predicates
p_morphic_test:().
clauses
p_morphic_test():-
zz_poly_dom:=poly_def(1,5),
call_pd(zz_poly_dom),
fail.
p_morphic_test():-
PD=poly_def(1,["an example","or two"]),
call_pd(PD),
fail.
p_morphic_test():-
Q= [poly_def(X, Y) || X= std::fromTo(1, 4),
Y= std::fromTo(1, 5)],
stdio::write("\n",Q),
fail.
p_morphic_test().

class predicates
call_pd:(poly_dom{A,B}).
clauses
call_pd(POLY_DOM):-
stdio::write("\n",POLY_DOM),
fail.
call_pd(poly_def(A,B)):-%note this is POLY_DEF
stdio::write("\n",A,B),
fail.
call_pd(_).

</vip>

 
=== Properties ===

Properties in a class are used almost identically to fact variables, but properties can be set directly (from another class), without having to declare a public predicate to make the change.

'''Example'''

<vip>interface fred
domains
complete_dom=is_complete;
not_complete.
properties
prop_complete : complete_dom.
end interface fred</vip>

In '''fred.pro''':

<vip>
implement fred
facts
zz_complete:complete_dom:=erroneous.

clauses %for the property
prop_complete()=zz_complete. %get
prop_complete(COMPLETE):-zz_complete:=COMPLETE. %set</vip>

In some other class that calls class fred:

<vip>implement other
open fred
clauses
pred():-
Fred=fred::new(),
Fred:prop_complete:=is_complete,% to set the value
Value=Fred:prop_complete,!. %get</vip>
 
=== Comparators and compare ===
First, look at the definition of '''core::comparator''': 
<vip>
domains
comparator{T} = function{T, T, compareResult}.
</vip>
'''compareResult's''' definition can is found here:
[http://wiki.visual-prolog.com/index.php?title=Language_Reference/Built-in_entities/Domains#compareResult compareResult]
 
'''Examples'''
<vip>
class predicates
p_compare_test:().
clauses
p_compare_test():-
CompareResult=compare(7,2).
%will bind CompareResult to '''greater()'''
%(because 7 > 2)
p_compare_test():-
CompareResult=compare(2,2).
%will bind CompareResult to '''equal()'''
p_compare_test():-
CompareResult=compare("a","z").
%will bind CompareResult to '''less()'''
</vip>

But you may wish to check your own domains to see which is "greater" - and of course you must define this yourself, by defining your own predicate as a '''core::comparator''' 
Here is a simple domain in which only the integer parts of the variables are checked to see which is greater: 
<vip>
domains
s=s(string,integer).

class predicates
compare_it: core::comparator{s}.
clauses
compare_it(A,B)=CompareResult:-%since this is a core::function(T,T,compareResult)
A=s(_,I),
B=s(_,J),
if I<J then
CompareResult=less()
elseif I=J then
CompareResult=equal()
else
CompareResult=greater()
end if.

class predicates
p_compare_test:().
clauses
p_compare_test():-
S1=s("abc",7),
S2=s("fred",9),
CompareResult=compare_it(S1,S2),
%will give CompareResult=less, since 7<9.
</vip>
...a bit pointless since the string part of the variables have been ignored, but it is easy to see how to expand '''compare_it()''' to your own needs.
 
=== More on core::function and core::predicate ===
Again, please check out '''core::function'''. '''core::predicate''' is essentially the same, but does not return a value. 
'''Example 1'''
<vip>
class predicates
two_times:function{integer,integer}.
clauses
two_times(A)=2*A.
class predicates
p_function:().
clauses
p_function():-
Z=two_times(2),
%binds Z to 4

</vip>
'''Example 2'''
<vip>
domains
fred_dom{A,B}=predicate{A,B}.
class predicates
fred_pred: fred_dom{A,B}.
clauses
fred_pred(A,B):-
stdio::write("\n",A," ",B).
class predicates
p_function:().
clauses
p_function():-
fred_pred("one",2).
</vip>
'''Example 3'''
<vip>
class predicates
add_pred: function{integer,integer}.
clauses
add_pred(B)=B+1.

class predicates
p_function:().
clauses
p_function():-
X=add_pred(5),
%X is mound to 6
</vip>
 

=== Anonymous predicates ===

''(under development)''
See [http://wiki.visual-prolog.com/index.php?title=Language_Reference/Terms/Anonymous_Predicates Anonymous_Predicates]

'''Examples'''

<vip>clauses
run() :-
Anon={()=9},
K=Anon().
%results in K=9
run() :-
Anon={=88},
K=Anon().
%results in K=88.
run():-
Anon={(A,B)=A+B},
K=Anon(4,8),
%results in K=12.
run():-
Anon={
(A,B)=C:-
R=math::random(7),
C=A+B+R,
stdio::wRite("RRRR=",R)
},
K=Anon(4,8).
%results in K=12 + a random number <7

run():-
Anon={=f_abc(3)},
K=Anon(),
stdio::write("\nI={=f_abc(3)} gives ",K),
fail.
run().</vip>

=== Threads ===

To start a thread:

<vip>clauses
pred():-
_=thread::start(fred).

predicates
fred:().
clauses
fred():-.....</vip>

fred can have no arguments, so no argument brackets are allowed:
<vip>
_=thread::start(fred())</vip>

is illegal. But the thread can access data prepared before it is started.

<vip>facts
zz_int:integer:=erroneous.
clauses
pred():-
zz_int:=88,
_=thread::start(fred).

predicates
fred:().
clauses
fred():-
K=zz_int,
...</vip>