jason-users Mailing List for jason

I forgot to mention that the output not exactly as you suggest:

 [X,Y]
 [_13,_14,_15]

But _13 is unified with X, _14 with Y and _15 with Z. So the program:

+!start <- L=[X,Y]; .print(L); ?append(L, [Z], L2); .print(L2); X=a;
Y=b; Z=c; .print(L2).

will print:

 [a,b,c]

Jomi

ps.: that was a *great* bug :-)

Jomi Fred Hubner wrote:
> Stephen,
> 
> I (hopefully) fixed the second bug. the jar at 	
> 	http://www.emse.fr/~hubner/x/jason.jar
> contains that fix.
> 
> Regards,
> 
> Jomi
> 
> Jomi Fred Hubner wrote:
>> Dear Stephen,
>>
>> thanks very much for reporting those problems.
>>
>> the first problem is fixed, the sources committed in the SVN sources,
>> and a compiled version is available at
>> http://www.emse.fr/~hubner/x/jason.jar.
>>
>> the second problem is quite difficult to fix.... we are still thinking
>> on a solution.
>>
>> Thanks again,
>>
>> Jomi
>>
>>
>> Stephen Cranefield wrote:
>>> I am having two problems with Jason 1.1.1.
>>>
>>>    1. The univ operator (=..) causes a NullPointerException if its left
>>>       argument is an atom.  This is because the constructor for the Atom
>>>       class calls super(functor, 0), which results in the two-argument
>>>       Structure constructor being called, and this does not initialise
>>>       the terms list (which =.. attempts to retrieve).
>>>
>>>       To get around this problem I have written rules defining
>>>       univ(Term, List):
>>>
>>>         univ(T, L) :- .atom(T) & L=[T,[],[]].
>>>         univ(T, L) :- not .atom(T) & T=..L.
>>>
>>>       (Note, for those who haven't used =.. in Jason, it works
>>>       differently from the Prolog version - the right hand side is a
>>>       list with three elements: the predicate, a list of arguments, and
>>>       a list of annotations).
>>>
>>>       However, this doesn't work due to the problem below.
>>>    2. Unification doesn't seem to work correctly for test goals that
>>>       match rules, such as the univ ones above and the append rule below:
>>>
>>>         append([], L, L).
>>>         append([H|T], L1, [H|L2]) :- append(T, L1, L2).
>>>
>>>         !start.
>>>
>>>         +!start <- L=[X,Y]; .print(L); ?append(L, [Z], L2); .print(L2).
>>>
>>>         /* Expected output: [X,Y]
>>>                             [X,Y,Z]
>>>            Actual output:   [X,Y]
>>>                             [H,H,_28]
>>>         */
>>>
>>> Regards,
>>> Stephen
>>>  
>>> ----
>>> Stephen Cranefield                      
>>> Department of Information Science
>>> University of Otago
>>> New Zealand
>>>
>>>
>>> ------------------------------------------------------------------------
>>>
>>> -------------------------------------------------------------------------
>>> Check out the new SourceForge.net Marketplace.
>>> It's the best place to buy or sell services for
>>> just about anything Open Source.
>>> http://sourceforge.net/services/buy/index.php
>>>
>>>
>>> ------------------------------------------------------------------------
>>>
>>> _______________________________________________
>>> Jason-users mailing list
>>> Jas...@li...
>>> https://lists.sourceforge.net/lists/listinfo/jason-users
> 

-- 
Jomi Fred Hubner
ENS Mines Saint-Etienne
158 Cours Fauriel
42023 Saint-Etienne Cedex 02
France
http://www.emse.fr/~hubner

Stephen,

I (hopefully) fixed the second bug. the jar at 	
	http://www.emse.fr/~hubner/x/jason.jar
contains that fix.

Regards,

Jomi

Jomi Fred Hubner wrote:
> Dear Stephen,
> 
> thanks very much for reporting those problems.
> 
> the first problem is fixed, the sources committed in the SVN sources,
> and a compiled version is available at
> http://www.emse.fr/~hubner/x/jason.jar.
> 
> the second problem is quite difficult to fix.... we are still thinking
> on a solution.
> 
> Thanks again,
> 
> Jomi
> 
> 
> Stephen Cranefield wrote:
>> I am having two problems with Jason 1.1.1.
>>
>>    1. The univ operator (=..) causes a NullPointerException if its left
>>       argument is an atom.  This is because the constructor for the Atom
>>       class calls super(functor, 0), which results in the two-argument
>>       Structure constructor being called, and this does not initialise
>>       the terms list (which =.. attempts to retrieve).
>>
>>       To get around this problem I have written rules defining
>>       univ(Term, List):
>>
>>         univ(T, L) :- .atom(T) & L=[T,[],[]].
>>         univ(T, L) :- not .atom(T) & T=..L.
>>
>>       (Note, for those who haven't used =.. in Jason, it works
>>       differently from the Prolog version - the right hand side is a
>>       list with three elements: the predicate, a list of arguments, and
>>       a list of annotations).
>>
>>       However, this doesn't work due to the problem below.
>>    2. Unification doesn't seem to work correctly for test goals that
>>       match rules, such as the univ ones above and the append rule below:
>>
>>         append([], L, L).
>>         append([H|T], L1, [H|L2]) :- append(T, L1, L2).
>>
>>         !start.
>>
>>         +!start <- L=[X,Y]; .print(L); ?append(L, [Z], L2); .print(L2).
>>
>>         /* Expected output: [X,Y]
>>                             [X,Y,Z]
>>            Actual output:   [X,Y]
>>                             [H,H,_28]
>>         */
>>
>> Regards,
>> Stephen
>>  
>> ----
>> Stephen Cranefield                      
>> Department of Information Science
>> University of Otago
>> New Zealand
>>
>>
>> ------------------------------------------------------------------------
>>
>> -------------------------------------------------------------------------
>> Check out the new SourceForge.net Marketplace.
>> It's the best place to buy or sell services for
>> just about anything Open Source.
>> http://sourceforge.net/services/buy/index.php
>>
>>
>> ------------------------------------------------------------------------
>>
>> _______________________________________________
>> Jason-users mailing list
>> Jas...@li...
>> https://lists.sourceforge.net/lists/listinfo/jason-users
> 

-- 
Jomi Fred Hubner
ENS Mines Saint-Etienne
158 Cours Fauriel
42023 Saint-Etienne Cedex 02
France
http://www.emse.fr/~hubner

Dear Stephen,

thanks very much for reporting those problems.

the first problem is fixed, the sources committed in the SVN sources,
and a compiled version is available at
http://www.emse.fr/~hubner/x/jason.jar.

the second problem is quite difficult to fix.... we are still thinking
on a solution.

Thanks again,

Jomi


Stephen Cranefield wrote:
> I am having two problems with Jason 1.1.1.
> 
>    1. The univ operator (=..) causes a NullPointerException if its left
>       argument is an atom.  This is because the constructor for the Atom
>       class calls super(functor, 0), which results in the two-argument
>       Structure constructor being called, and this does not initialise
>       the terms list (which =.. attempts to retrieve).
> 
>       To get around this problem I have written rules defining
>       univ(Term, List):
> 
>         univ(T, L) :- .atom(T) & L=[T,[],[]].
>         univ(T, L) :- not .atom(T) & T=..L.
> 
>       (Note, for those who haven't used =.. in Jason, it works
>       differently from the Prolog version - the right hand side is a
>       list with three elements: the predicate, a list of arguments, and
>       a list of annotations).
> 
>       However, this doesn't work due to the problem below.
>    2. Unification doesn't seem to work correctly for test goals that
>       match rules, such as the univ ones above and the append rule below:
> 
>         append([], L, L).
>         append([H|T], L1, [H|L2]) :- append(T, L1, L2).
> 
>         !start.
> 
>         +!start <- L=[X,Y]; .print(L); ?append(L, [Z], L2); .print(L2).
> 
>         /* Expected output: [X,Y]
>                             [X,Y,Z]
>            Actual output:   [X,Y]
>                             [H,H,_28]
>         */
> 
> Regards,
> Stephen
>  
> ----
> Stephen Cranefield                      
> Department of Information Science
> University of Otago
> New Zealand
> 
> 
> ------------------------------------------------------------------------
> 
> -------------------------------------------------------------------------
> Check out the new SourceForge.net Marketplace.
> It's the best place to buy or sell services for
> just about anything Open Source.
> http://sourceforge.net/services/buy/index.php
> 
> 
> ------------------------------------------------------------------------
> 
> _______________________________________________
> Jason-users mailing list
> Jas...@li...
> https://lists.sourceforge.net/lists/listinfo/jason-users

-- 
Jomi Fred Hubner
ENS Mines Saint-Etienne
158 Cours Fauriel
42023 Saint-Etienne Cedex 02
France
http://www.emse.fr/~hubner

I am having two problems with Jason 1.1.1.

1.	The univ operator (=..) causes a NullPointerException if its
left argument is an atom.  This is because the constructor for the Atom
class calls super(functor, 0), which results in the two-argument
Structure constructor being called, and this does not initialise the
terms list (which =.. attempts to retrieve).
	
	To get around this problem I have written rules defining
univ(Term, List):
	
	  univ(T, L) :- .atom(T) & L=[T,[],[]].
	  univ(T, L) :- not .atom(T) & T=..L.
	
	(Note, for those who haven't used =.. in Jason, it works
differently from the Prolog version - the right hand side is a list with
three elements: the predicate, a list of arguments, and a list of
annotations).
	
	However, this doesn't work due to the problem below.
	
2.	Unification doesn't seem to work correctly for test goals that
match rules, such as the univ ones above and the append rule below:
	
	  append([], L, L).
	  append([H|T], L1, [H|L2]) :- append(T, L1, L2).
	
	  !start.
	
	  +!start <- L=[X,Y]; .print(L); ?append(L, [Z], L2);
.print(L2).
	
	  /* Expected output: [X,Y]
	                      [X,Y,Z]
	     Actual output:   [X,Y]
	                      [H,H,_28]
	  */

Regards,
Stephen
 
----
Stephen Cranefield                      
Department of Information Science
University of Otago
New Zealand

Hi all,

we developed a team to participated in the Agent Contest 2008 (http://cig.in.tu-clausthal.de/AgentContest 
) using Jason as the programming language. All the code of our team is  
available at

http://downloads.sourceforge.net/jason/jason-team-AgentContest2008.zip

Besides using Jason, the team is programmed using an organisational  
approach, based on notions of groups and roles provided by MOISE+.

Regards,

Jomi, Rafael, Gauthier