And I am trying to tell the following:
in
"
octave:4> foo_cs = foo{:}
foo_cs = a
"
one can see, that that "not object" is somehow converted into 'foo_cs',
using whatever implicit rules.
Likewise, in
"
octave:6> sizeof(1 + 2)
ans = 8
"
the "1 + 2", which is an _expression_, is first converted (apparently) into
a _single_ double value, and the size of that double value is (apparently)
displayed.
So, the inconsistency, as I see it, is:
arithmetic expressions are _by_ _default_ converted into a _single_
memory location holding their value, and that memory location size in
bytes is dispalyed;
_opposed_ _to_ _that_
comma separated list is _not_ converted when 'sizeof' is called, but
some _deafault_ conversion is called in case of
"
octave:4> foo_cs = foo{:}
foo_cs = a
".
I.e. why for arithmetic expressions in case of "sizeof(1 + 2)" I see
something like:
invisible_result = 1 + 2; sizeof(invisible_result)
, but for comma-separated list in case of "sizeof(foo{:})" I do _not_ see
invisible_result = foo{:}; sizeof(invisible_result)
I'm confused on your use of word inconsistency.
In case A, something happens.
In case B, something else happens.
This isn't an inconsistency, its how different things (an object vs. a comma separated list) are handled by octave.
I'm not sure if this is an entirely accurate analogy, but I think of comma separated lists as almost like a macro. foo{:} is shorthand (for lack of a better term) for writing out each element in the list with commas in between them.
The assignment when you write:
foo_cs = foo{:}
is the same as if you wrote
foo_cs = foo{1},foo{2},...,foo{end};
Thus the result of the line
foo_cs = foo{:}
is to assign the first cell of foo to the variable foo_cs and that is it.
A small example:
octave-3.2.4.exe:2> foo{1} = 4;
octave-3.2.4.exe:3> foo{2} = 5;
octave-3.2.4.exe:4> c = foo{:}
c = 4
octave-3.2.4.exe:5> c = 4,5;
c = 4
Hope this helps.