an idea about possreps

#1

I just had this idea about possreps.

In another context, someone discussing methods, or functions
that are bound very closely to a specific type, commented
that he thought that such functions should be extremely
limited, rather than the grab-bag that OOP usually produces.
I thought this a rather interesting comment, and after thinking
about it for a long time decided it was a good comment,
but that I didn't really know how to measure how well a
design achieved that goal. Looking at, say, java.util.String,
it is clear that many of its methods are not all that essential.
charAt() or getBytes() seem fairly intrincic, but something
like toUpperCase() doesn't seem to have much to do
directly with the type, and something like split() seems
to be overkill.

It is more or less sensible in OOP to put all these things
in the class; it's common practice and it's also convenient.
But that's not the same thing as essential.

I vaguely sense that what D&D are thinking about with
their THE_ operators is the same thing as I'm thinking
of as the essential methods.

The idea I had was simply this: that the essential operators
are exactly those that return selector arguments. This
is clearly necessary to convert from one possrep to another;
what's less clear is if that case necessarily has to be
exposed. (That code might only exist under the covers in
the possrep implementation.) It's also unclear if it's sufficient.

Marshall

PS. This idea just popped in to my head; hence it is not very mature.

#2

On 3 feb, 05:31, Marshall <marshall.spi... (AT) gmail (DOT) com> wrote:

Quote:

I just had this idea about possreps.

In another context, someone discussing methods, or functions
that are bound very closely to a specific type, commented
that he thought that such functions should be extremely
limited, rather than the grab-bag that OOP usually produces.
I thought this a rather interesting comment, and after thinking
about it for a long time decided it was a good comment,
but that I didn't really know how to measure how well a
design achieved that goal.

That's actually not that hard. You can formalize this by introducing a
notion of completeness that says that a set of operations for a
certain type / domain is complete if it holds that when we add the
domain / type and its operations to a computationally complete
programming or query language it stays computationally complete (*).

A set of operations is then called essential for a domain if any
proper subset of them is not complete in the above sense. Note that
this set is not necessarily unique.

(*) Computationally complete is a stronger notion than Turing
complete. In many cases the two coincide, but here their difference
matters. Roughly it means that for all types available in the language
you can express all computable functions over these types.

-- Jan Hidders

#3

On 3 feb, 05:31, Marshall <marshall.spi... (AT) gmail (DOT) com> wrote:

Quote:

I just had this idea about possreps.

In another context, someone discussing methods, or functions
that are bound very closely to a specific type, commented
that he thought that such functions should be extremely
limited, rather than the grab-bag that OOP usually produces.
I thought this a rather interesting comment, and after thinking
about it for a long time decided it was a good comment,
but that I didn't really know how to measure how well a
design achieved that goal.

That's actually not that hard. You can formalize this by introducing a
notion of completeness that says that a set of operations for a
certain type / domain is complete if it holds that when we add the
domain / type and its operations to a computationally complete
programming or query language it stays computationally complete (*).

A set of operations is then called essential for a domain if any
proper subset of them is not complete in the above sense. Note that
this set is not necessarily unique.

(*) Computationally complete is a stronger notion than Turing
complete. In many cases the two coincide, but here their difference
matters. Roughly it means that for all types available in the language
you can express all computable functions over these types.

-- Jan Hidders

#4

On 3 feb, 05:31, Marshall <marshall.spi... (AT) gmail (DOT) com> wrote:

Quote:

I just had this idea about possreps.

In another context, someone discussing methods, or functions
that are bound very closely to a specific type, commented
that he thought that such functions should be extremely
limited, rather than the grab-bag that OOP usually produces.
I thought this a rather interesting comment, and after thinking
about it for a long time decided it was a good comment,
but that I didn't really know how to measure how well a
design achieved that goal.

That's actually not that hard. You can formalize this by introducing a
notion of completeness that says that a set of operations for a
certain type / domain is complete if it holds that when we add the
domain / type and its operations to a computationally complete
programming or query language it stays computationally complete (*).

A set of operations is then called essential for a domain if any
proper subset of them is not complete in the above sense. Note that
this set is not necessarily unique.

(*) Computationally complete is a stronger notion than Turing
complete. In many cases the two coincide, but here their difference
matters. Roughly it means that for all types available in the language
you can express all computable functions over these types.

-- Jan Hidders

#5

On 3 feb, 05:31, Marshall <marshall.spi... (AT) gmail (DOT) com> wrote:

Quote:

I just had this idea about possreps.

In another context, someone discussing methods, or functions
that are bound very closely to a specific type, commented
that he thought that such functions should be extremely
limited, rather than the grab-bag that OOP usually produces.
I thought this a rather interesting comment, and after thinking
about it for a long time decided it was a good comment,
but that I didn't really know how to measure how well a
design achieved that goal.

That's actually not that hard. You can formalize this by introducing a
notion of completeness that says that a set of operations for a
certain type / domain is complete if it holds that when we add the
domain / type and its operations to a computationally complete
programming or query language it stays computationally complete (*).

A set of operations is then called essential for a domain if any
proper subset of them is not complete in the above sense. Note that
this set is not necessarily unique.

(*) Computationally complete is a stronger notion than Turing
complete. In many cases the two coincide, but here their difference
matters. Roughly it means that for all types available in the language
you can express all computable functions over these types.

-- Jan Hidders

#6

On 3 feb, 05:31, Marshall <marshall.spi... (AT) gmail (DOT) com> wrote:

Quote:

I just had this idea about possreps.

In another context, someone discussing methods, or functions
that are bound very closely to a specific type, commented
that he thought that such functions should be extremely
limited, rather than the grab-bag that OOP usually produces.
I thought this a rather interesting comment, and after thinking
about it for a long time decided it was a good comment,
but that I didn't really know how to measure how well a
design achieved that goal.

That's actually not that hard. You can formalize this by introducing a
notion of completeness that says that a set of operations for a
certain type / domain is complete if it holds that when we add the
domain / type and its operations to a computationally complete
programming or query language it stays computationally complete (*).

A set of operations is then called essential for a domain if any
proper subset of them is not complete in the above sense. Note that
this set is not necessarily unique.

(*) Computationally complete is a stronger notion than Turing
complete. In many cases the two coincide, but here their difference
matters. Roughly it means that for all types available in the language
you can express all computable functions over these types.

-- Jan Hidders

#7

On 3 feb, 05:31, Marshall <marshall.spi... (AT) gmail (DOT) com> wrote:

Quote:

I just had this idea about possreps.

In another context, someone discussing methods, or functions
that are bound very closely to a specific type, commented
that he thought that such functions should be extremely
limited, rather than the grab-bag that OOP usually produces.
I thought this a rather interesting comment, and after thinking
about it for a long time decided it was a good comment,
but that I didn't really know how to measure how well a
design achieved that goal.

That's actually not that hard. You can formalize this by introducing a
notion of completeness that says that a set of operations for a
certain type / domain is complete if it holds that when we add the
domain / type and its operations to a computationally complete
programming or query language it stays computationally complete (*).

A set of operations is then called essential for a domain if any
proper subset of them is not complete in the above sense. Note that
this set is not necessarily unique.

(*) Computationally complete is a stronger notion than Turing
complete. In many cases the two coincide, but here their difference
matters. Roughly it means that for all types available in the language
you can express all computable functions over these types.

-- Jan Hidders

#8

On 3 feb, 05:31, Marshall <marshall.spi... (AT) gmail (DOT) com> wrote:

Quote:

I just had this idea about possreps.

In another context, someone discussing methods, or functions
that are bound very closely to a specific type, commented
that he thought that such functions should be extremely
limited, rather than the grab-bag that OOP usually produces.
I thought this a rather interesting comment, and after thinking
about it for a long time decided it was a good comment,
but that I didn't really know how to measure how well a
design achieved that goal.

That's actually not that hard. You can formalize this by introducing a
notion of completeness that says that a set of operations for a
certain type / domain is complete if it holds that when we add the
domain / type and its operations to a computationally complete
programming or query language it stays computationally complete (*).

A set of operations is then called essential for a domain if any
proper subset of them is not complete in the above sense. Note that
this set is not necessarily unique.

(*) Computationally complete is a stronger notion than Turing
complete. In many cases the two coincide, but here their difference
matters. Roughly it means that for all types available in the language
you can express all computable functions over these types.

-- Jan Hidders

#9

On 3 feb, 05:31, Marshall <marshall.spi... (AT) gmail (DOT) com> wrote:

Quote:

I just had this idea about possreps.

In another context, someone discussing methods, or functions
that are bound very closely to a specific type, commented
that he thought that such functions should be extremely
limited, rather than the grab-bag that OOP usually produces.
I thought this a rather interesting comment, and after thinking
about it for a long time decided it was a good comment,
but that I didn't really know how to measure how well a
design achieved that goal.

That's actually not that hard. You can formalize this by introducing a
notion of completeness that says that a set of operations for a
certain type / domain is complete if it holds that when we add the
domain / type and its operations to a computationally complete
programming or query language it stays computationally complete (*).

A set of operations is then called essential for a domain if any
proper subset of them is not complete in the above sense. Note that
this set is not necessarily unique.

(*) Computationally complete is a stronger notion than Turing
complete. In many cases the two coincide, but here their difference
matters. Roughly it means that for all types available in the language
you can express all computable functions over these types.

-- Jan Hidders

#10

On Feb 3, 11:59 pm, Jan Hidders <hidd... (AT) gmail (DOT) com> wrote:

Quote:

On 3 feb, 05:31, Marshall <marshall.spi... (AT) gmail (DOT) com> wrote:

I just had this idea about possreps.

In another context, someone discussing methods, or functions
that are bound very closely to a specific type, commented
that he thought that such functions should be extremely
limited, rather than the grab-bag that OOP usually produces.
I thought this a rather interesting comment, and after thinking
about it for a long time decided it was a good comment,
but that I didn't really know how to measure how well a
design achieved that goal.

That's actually not that hard. You can formalize this by introducing a
notion of completeness that says that a set of operations for a
certain type / domain is complete if it holds that when we add the
domain / type and its operations to a computationally complete
programming or query language it stays computationally complete (*).

A set of operations is then called essential for a domain if any
proper subset of them is not complete in the above sense. Note that
this set is not necessarily unique.

(*) Computationally complete is a stronger notion than Turing
complete. In many cases the two coincide, but here their difference
matters. Roughly it means that for all types available in the language
you can express all computable functions over these types.

I think in practice one would typically only define the set of all
computable functions over a given type indirectly by defining a set of
essential operators. IOW, essential operators seem to have an
axiomatic character to me.