Strange behavior of map<XXX, unknown>

[hdelattr]

Hello,
I am new to GAML and I noticed that map<string, unknown> behave somewhat strangely;

I suppose I should just always cast mapped values to the right type while using them. Could someone explain me why I do get those strange behaviors though?

consider the following code;

/* Map string -> unknown */
		map<string, unknown> foo <- ["a"::1.0, "b"::1];
		write "type_of(foo[a]): " + type_of(foo["a"]); // float (OK)
		write "foo[a]: " + foo["a"]; // 1.0 (OK)
		write "foo[a] * 1.5 = " + foo["a"] * 1.5; // 1.5 (OK)
		write "type_of(foo[b]): " + type_of(foo["b"]); // int (OK)
		write "foo[b] + 1 = " + foo["b"] + 1; // 11 (?!)
		
		/* pointer copy */
		map<string, unknown> qux <- foo;
		foo["a"] <- 2.0; // since it is a pointer copy (I suppose), it also affects qux["a"] (OK)
		write "type_of(qux[a]): " + type_of(qux["a"]); // float (OK)
		write "qux[a] * 1.5 = " + qux["a"] * 1.5; // 3.0 (OK)
		write "type_of(qux[b]): " + type_of(qux["b"]); // int (OK)
		write "qux[b] + 1 = " + qux["b"] + 1; // 11 (!?) 
		
		/* Pointer copy sent to a species */
		create bar number: 1 with: [baz::foo] returns: _bar;
		bar my_bar <- first(_bar);
		foo["a"] <- 6.0; // since it is yet another pointer copy, it also affects my_bar.baz["a"] (OK)
		write "my_bar.baz[b] + 1 = " + my_bar.baz["b"] + 1; // 11 (!?)
		write "type_of(my_bar.baz['a']): " + type_of(my_bar.baz['a']); // float (OK)
		write "my_bar.baz['a']: " + my_bar.baz['a']; // 6.0 (OK)
		write "float(my_bar.baz['a']) * 1.5 = " + float(my_bar.baz["a"]) * 1.5; // 9.0 (OK)
		write "foo[a] * 1.5 = " + foo["a"] * 1.5; // 9.0 (OK) if we use the original pointer, everything is fine
		write "qux[a] * 1.5 = " + qux["a"] * 1.5; // 9.0 (OK) if we use the second pointer, everything is fine
		/* But if we use the third pointer, an error occurs;
		 * Error message;
		 * ClassCastException: class.java.lang.Double cannot be cast to class ummisco.gaml.extensions.image.GamaImage (java.lang.Double is in module.java.base of loader 'bootstrap'; ummisco.gaml.extensions.image.GamaImage is in unnamed module of loader org.eclipse.osgi.inte
		 */ 
		write "my_bar.baz['a'] * 1.5 = " + my_bar.baz["a"] * 1.5; 

[lesquoyb]

Hello and thank you for your detailed example model.

The first issue you encounter: having 11 instead of 2 is not really a bug but simply a problem of priority of operations. What is read by the interpreter is something like this:

write "some string" + <float> + <float>;

and the priority is this one:

write ( ("some string" + <float>) + float)

so in that context all + are to be interpreted as concatenation and not addition. You don't see that with the multiplication example because the multiplication has a higher priority than the addition, and so

write "some string" + <float> * <float>;

resolves like this:

write ("some string" + (<float> * <float>));

and so the concatenation is done after floats are multiplied together.
You can fix that by forcing the order yourself with parenthesis or using the sample operator which will generate the prefixed string for you, for example:

write sample(foo["b"] + 1);

Nonetheless your example underlined two real problems with manipulating maps of unknown objects:

1. when the element stored is an int, it is rightfully typed as an int, but as soon as you do an arithmetical operation on it, it is cast into a float
2. when the map is accessed from inside an agent, there are some confusion about the type itself (this is your last line where the interpreter thinks it is an image)

I will create proper issues to track them down and hopefully fix this quickly, in the meantime a simple workaround for you will be to force cast in the code to the type you want to interact with (so instead of foo["a"] + 123, do int(foo["a"]) + 123).