10:47 a.m.
I have the basics to backward chaining working now, using both named and
positional arguments and mix of both. Mixed positional/named syntax is
based conceptually on the RuleML proposal for POSL:
http://ruleml.org/submission/ruleml-shortation.html
POSL provides a bridge between the positional terms, often used in
Prolog, and "slotted" names used in OO languages. POSL allows the best
of both worlds.
I'm building out the tests, which should illustrate the behaviour and
syntax here:
https://github.com/droolsjbpm/drools/tree/master/drools-compiler/src/test...
Still lots to do to improve the over all syntax and consistency across
patterns. The last test is a geneology style test which is probably more
intesting to people. There is still an issue here when using eval. I
currently use "new Variable" to indicate an unbound unification
variable, the problem is that evals and other things generate code
expecting the original object type, say "String" and this results a cast
error (see sibling rule). I want to avoid an explicit instanceof check
for unwrapping and will be working on that over the weekend.
There is enough there now to give people an idea of what it looks like.
I'll try and put together a "roadmap" for BC, along with more details of
the syntax next week once it all comes together.
If anyone wants to help on this, you know where to fine me :)
irc.codehaus.org #drools
Mark
11:56 a.m.
Stilton good is favourite mine.
The force is strong in this one.
sent on the move
On 16 Apr 2011 16:48, "Mark Proctor" <mproctor(a)codehaus.org> wrote:
I have the basics to backward chaining working now, using both named
and
positional arguments and mix of both. Mixed positional/named syntax is
based conceptually on the RuleML proposal for POSL:
http://ruleml.org/submission/ruleml-shortation.html
POSL provides a bridge between the positional terms, often used in
Prolog, and "slotted" names used in OO languages. POSL allows the best
of both worlds.
I'm building out the tests, which should illustrate the behaviour and
syntax here:
https://github.com/droolsjbpm/drools/tree/master/drools-compiler/src/test...
Still lots to do to improve the over all syntax and consistency across
patterns. The last test is a geneology style test which is probably more
intesting to people. There is still an issue here when using eval. I
currently use "new Variable" to indicate an unbound unification
variable, the problem is that evals and other things generate code
expecting the original object type, say "String" and this results a cast
error (see sibling rule). I want to avoid an explicit instanceof check
for unwrapping and will be working on that over the weekend.
There is enough there now to give people an idea of what it looks like.
I'll try and put together a "roadmap" for BC, along with more details of
the syntax next week once it all comes together.
If anyone wants to help on this, you know where to fine me :)
irc.codehaus.org #drools
Mark
_______________________________________________
rules-dev mailing list
rules-dev(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-dev
1:40 p.m.
I will take a look at the test and try to think about something to include
in the emergency service app.
If you think about an use for BC in my app I can easily add it beacuse I'm
using the snapshots.
During the week I will ping you if I have an idea.
Greetings.
PS: michael I will ping you too to see if you can help me with some DTables
:)
On Sat, Apr 16, 2011 at 1:56 PM, Michael Anstis <michael.anstis(a)gmail.com>wrote:
Stilton good is favourite mine.
The force is strong in this one.
sent on the move
On 16 Apr 2011 16:48, "Mark Proctor" <mproctor(a)codehaus.org> wrote:
> I have the basics to backward chaining working now, using both named and
> positional arguments and mix of both. Mixed positional/named syntax is
> based conceptually on the RuleML proposal for POSL:
> http://ruleml.org/submission/ruleml-shortation.html
>
> POSL provides a bridge between the positional terms, often used in
> Prolog, and "slotted" names used in OO languages. POSL allows the best
> of both worlds.
>
> I'm building out the tests, which should illustrate the behaviour and
> syntax here:
>
https://github.com/droolsjbpm/drools/tree/master/drools-compiler/src/test...
>
> Still lots to do to improve the over all syntax and consistency across
> patterns. The last test is a geneology style test which is probably more
> intesting to people. There is still an issue here when using eval. I
> currently use "new Variable" to indicate an unbound unification
> variable, the problem is that evals and other things generate code
> expecting the original object type, say "String" and this results a cast
> error (see sibling rule). I want to avoid an explicit instanceof check
> for unwrapping and will be working on that over the weekend.
>
> There is enough there now to give people an idea of what it looks like.
> I'll try and put together a "roadmap" for BC, along with more details
of
> the syntax next week once it all comes together.
>
> If anyone wants to help on this, you know where to fine me :)
> irc.codehaus.org #drools
>
> Mark
>
> _______________________________________________
> rules-dev mailing list
> rules-dev(a)lists.jboss.org
> https://lists.jboss.org/mailman/listinfo/rules-dev
_______________________________________________
rules-dev mailing list
rules-dev(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-dev
--
- CTO @ http://www.plugtree.com
- MyJourney @ http://salaboy.wordpress.com
- Co-Founder @ http://www.jbug.com.ar
- Salatino "Salaboy" Mauricio -
1:44 a.m.
The geneology example, as here
http://kti.mff.cuni.cz/~bartak/prolog/contents.html, now works :)
It's the latest test here:
https://github.com/droolsjbpm/drools/blob/master/drools-compiler/src/test...
For the data:
// grand parents
ksession.insert( new Man("john") );
ksession.insert( new Woman("janet") );
// parent
ksession.insert( new Man("adam") );
ksession.insert( new Parent( "john", "adam") );
ksession.insert( new Parent( "janet", "adam") );
ksession.insert( new Man("stan") );
ksession.insert( new Parent( "john", "stan") );
ksession.insert( new Parent( "janet", "stan") );
// grant parents
ksession.insert( new Man("carl") );
ksession.insert( new Woman("tina") );
// parent
ksession.insert( new Woman("eve") );
ksession.insert( new Parent( "carl", "eve") );
ksession.insert( new Parent( "tina", "eve") );
// parent
ksession.insert( new Woman("mary") );
ksession.insert( new Parent( "carl", "mary") );
ksession.insert( new Parent( "tina", "mary") );
ksession.insert( new Man("peter") );
ksession.insert( new Parent( "adam", "peter" ) );
ksession.insert( new Parent( "eve", "peter" ) );
ksession.insert( new Man("paul") );
ksession.insert( new Parent( "adam", "paul" ) );
ksession.insert( new Parent( "mary", "paul" ) );
ksession.insert( new Woman("jill") );
ksession.insert( new Parent( "adam", "jill" ) );
ksession.insert( new Parent( "eve", "jill" ) );
it gives the output:
woman
janet
tina
eve
mary
jill
man
john
adam
stan
carl
peter
paul
father
father( carl, mary )
father( carl, eve )
father( adam, jill )
father( adam, paul )
father( adam, peter )
father( john, stan )
father( john, adam )
mother
mother( mary, paul )
mother( eve, jill )
mother( eve, peter )
mother( tina, mary )
mother( tina, eve )
mother( janet, stan )
mother( janet, adam )
son
son( paul, mary )
son( paul, adam )
son( peter, eve )
son( peter, adam )
son( stan, janet )
son( stan, john )
son( adam, janet )
son( adam, john )
daughter
daughter( jill, eve )
daughter( jill, adam )
daughter( mary, tina )
daughter( mary, carl )
daughter( eve, tina )
daughter( eve, carl )
siblings
sibling( jill, peter )
sibling( jill, paul )
sibling( jill, peter )
sibling( paul, jill )
sibling( paul, peter )
sibling( peter, jill )
sibling( peter, jill )
sibling( peter, paul )
sibling( mary, eve )
sibling( mary, eve )
sibling( eve, mary )
sibling( eve, mary )
sibling( stan, adam )
sibling( stan, adam )
sibling( adam, stan )
sibling( adam, stan )
fullSiblings
fullSiblings( jill, peter )
fullSiblings( jill, peter )
fullSiblings( peter, jill )
fullSiblings( peter, jill )
fullSiblings( mary, eve )
fullSiblings( mary, eve )
fullSiblings( eve, mary )
fullSiblings( eve, mary )
fullSiblings( stan, adam )
fullSiblings( stan, adam )
fullSiblings( adam, stan )
fullSiblings( adam, stan )
fullSiblings2
fullSiblings2( jill, peter )
fullSiblings2( jill, peter )
fullSiblings2( peter, jill )
fullSiblings2( peter, jill )
fullSiblings2( mary, eve )
fullSiblings2( mary, eve )
fullSiblings2( eve, mary )
fullSiblings2( eve, mary )
fullSiblings2( stan, adam )
fullSiblings2( stan, adam )
fullSiblings2( adam, stan )
fullSiblings2( adam, stan )
uncle
uncle( stan, jill )
uncle( stan, paul )
uncle( stan, peter )
uncle( stan, jill )
uncle( stan, paul )
uncle( stan, peter )
aunt
aunt( mary, jill )
aunt( mary, peter )
aunt( mary, jill )
aunt( mary, peter )
aunt( eve, paul )
aunt( eve, paul )
grantParents
grantParents( tina, paul )
grantParents( carl, paul )
grantParents( tina, jill )
grantParents( tina, peter )
grantParents( carl, jill )
grantParents( carl, peter )
grantParents( janet, jill )
grantParents( janet, paul )
grantParents( janet, peter )
grantParents( john, jill )
grantParents( john, paul )
grantParents( john, peter )
1:53 a.m.
Initial things to do:
-Patterns should also work with positionals, based on @Position annotation
-Expressions for query arguments should allow previous rule/global
bindings and execute an "mvel return value" to resolve them prior to
being passed to the query
-Figure out good way for queries to approximate prolog behaviour of
rules with same name where it unions the results.
-Queries should allow field constriants, ==, >= etc. The behaviour for
this is a unbound output variable on the field, which is filtered
against the expression.
-Allow bindings to the query itself and use a special implemention of
the MVEL's PropertyHandler to allow bean like access to it. So
declarations are like fields.
-More extensive testing to find out what is not working or broken, that
normal works in prolog like systems.
-Allow ? to differentiate between push and pull data sources. ? can be
used on a normal pattern to indicate it's a one off pull (query). ? When
not added to a query indicates that the query should be left "open" to
receive more data over time.
-Support open queries, this is where the query window is left open and
new data is propagated as a result.
9:57 a.m.
Here is a more friendly example based around "Adventures in Proglog"'s
"Nani Search". This is just a sampling of queries and rules, which it
uses to provide an adventure like game environment. The "?" means to
pull results, rather than the normal reactive nature of patterns.
http://www.amzi.com/AdventureInProlog/
query niceFood( String thing, String location )
location(thing, location) and
edible(thing)
end
query connect( String x, String y )
door(x, y;)
or
door(y, x;)
end
query look(String place, List things, List exits)
things : List() from accumulate( Location(thing, place;) ,
collectList( thing ) )
food : List() from accumulate( ?niceFood(thing, place;) ,
collectList(
thing ) )
exits : List() from accumulate( ?connect(place, exit;) ,
collectList(
[place, exit] ) )
end
rule reactiveLook when
Here( place : location)
?look2(place, things, exits)
then System.out.println( " You are in the " + place );
System.out.println( " You can see " + things );
System.out.println( " You can eat" + eat );
System.out.println( " You can go to " + exits );
end
-----Output----
You are in the kitchen
You can see [crackers, broccoli, apple]
You can eat[crackers, apple]
You can go to [[kitchen, dining room], [kitchen, cellar]]
11:08 a.m.
This doesn't seem to be quite correct.
- There's a fact "location" and another one "Location" - are
they the
same?
- Query "look" is defined; query "look2" is referenced.
- How is the fact L/location defined?
Regards
Wolfgang
On 18 April 2011 16:57, Mark Proctor <mproctor(a)codehaus.org> wrote:
Here is a more friendly example based around "Adventures in
Proglog"'s
"Nani Search". This is just a sampling of queries and rules, which it
uses to provide an adventure like game environment. The "?" means to
pull results, rather than the normal reactive nature of patterns.
http://www.amzi.com/AdventureInProlog/
query niceFood( String thing, String location )
location(thing, location) and
edible(thing)
end
query connect( String x, String y )
door(x, y;)
or
door(y, x;)
end
query look(String place, List things, List exits)
things : List() from accumulate( Location(thing, place;) ,
collectList( thing ) )
food : List() from accumulate( ?niceFood(thing, place;) ,
collectList(
thing ) )
exits : List() from accumulate( ?connect(place, exit;) ,
collectList(
[place, exit] ) )
end
rule reactiveLook when
Here( place : location)
?look2(place, things, exits)
then System.out.println( " You are in the " + place );
System.out.println( " You can see " + things );
System.out.println( " You can eat" + eat );
System.out.println( " You can go to " + exits );
end
-----Output----
You are in the kitchen
You can see [crackers, broccoli, apple]
You can eat[crackers, apple]
You can go to [[kitchen, dining room], [kitchen, cellar]]
_______________________________________________
rules-dev mailing list
rules-dev(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-dev
11:42 a.m.
On 18/04/2011 17:08, Wolfgang Laun wrote:
This doesn't seem to be quite correct.
* There's a fact "location" and another one "Location" - are
they
the same?
that misses something, it was just a sample of queries. I had a location
query that maps to the Location fact.
"query location( String thing, String location ) \n" +
"
org.drools.integrationtests.BackwardChainingTest.Location( thing :
thing, location : location ) \n"+
"end\n" +
That shouldn't be needed after the changes sotty jsut did to allow
positional of Fact patterns too.
* Query "look" is defined; query "look2" is referenced.
I already updated the blog.
* How is the fact L/location defined?
There is a single knowlege store, that hasn't changed. it's no
different to the way that standard querries work.
Mark
Regards
Wolfgang
On 18 April 2011 16:57, Mark Proctor <mproctor(a)codehaus.org
<mailto:mproctor@codehaus.org>> wrote:
Here is a more friendly example based around "Adventures in Proglog"'s
"Nani Search". This is just a sampling of queries and rules, which it
uses to provide an adventure like game environment. The "?" means to
pull results, rather than the normal reactive nature of patterns.
http://www.amzi.com/AdventureInProlog/
query niceFood( String thing, String location )
location(thing, location) and
edible(thing)
end
query connect( String x, String y )
door(x, y;)
or
door(y, x;)
end
query look(String place, List things, List exits)
things : List() from accumulate( Location(thing, place;) ,
collectList( thing ) )
food : List() from accumulate( ?niceFood(thing, place;) ,
collectList(
thing ) )
exits : List() from accumulate( ?connect(place, exit;) ,
collectList(
[place, exit] ) )
end
rule reactiveLook when
Here( place : location)
?look2(place, things, exits)
then System.out.println( " You are in the " + place );
System.out.println( " You can see " + things );
System.out.println( " You can eat" + eat );
System.out.println( " You can go to " + exits );
end
-----Output----
You are in the kitchen
You can see [crackers, broccoli, apple]
You can eat[crackers, apple]
You can go to [[kitchen, dining room], [kitchen, cellar]]
_______________________________________________
rules-dev mailing list
rules-dev(a)lists.jboss.org <mailto:rules-dev@lists.jboss.org>
https://lists.jboss.org/mailman/listinfo/rules-dev
_______________________________________________
rules-dev mailing list
rules-dev(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-dev
5002
days inactive
5004
days old
7 comments
4 participants
participants (4)
-
Mark Proctor -
Mauricio Salatino -
Michael Anstis -
Wolfgang Laun