Re: Types in Mathematica

• To: mathgroup at smc.vnet.net
• Subject: [mg62987] Re: Types in Mathematica
• From: Sseziwa Mukasa <mukasa at jeol.com>
• Date: Sat, 10 Dec 2005 06:02:56 -0500 (EST)
• References: <dn22fb\$kum\$1@smc.vnet.net> <200512081442.jB8EgCda002721@ljosalfr.globalsymmetry.com> <F44AB4A1-92CA-49D7-ABDD-E94D8270B8EC@jeol.com> <200512081419.17348.hattons@globalsymmetry.com> <dnbmt9\$5qf\$1@smc.vnet.net> <-4qdnaBC0M37OgTeRVn-uQ@speakeasy.net>
• Sender: owner-wri-mathgroup at wolfram.com

```On Dec 9, 2005, at 10:48 AM, Steven T. Hatton wrote:

>
> Sseziwa Mukasa wrote:
>>> But a Complex will always have a real and an imaginary component.
>>> A Rational
>>> will always have a numerator and a denominator.
>>
>> And a List always contains zero or more expressions.
>
> I don't see that to be containment in the same sense as a Complex
> contains
> its values.

You're right it's not exactly the same because Complex is an atom and
a list is not.

> expression/symbol with the head Complex.

Only an expression can have the head Complex, a symbol has the head
Symbol and to prevent confusion I think we should agree to keep that
straight.

>   Even if we do view an
> expression with the head List as a data structure containing elements
> (often called arguments), we are still able to describe it in terms
> of the
> functions which can operate on it, as well as the data abstraction it
> represents.

Of which the abstraction is what?

> When using expressions to represent ADTs we usually don't want to
> simply
> extract values using Part.  We want to treat it as if we do not
> know the
> internal structure.  We only know the interface.

I don't think I agree with this, we know several things about Part
with respect to expressions: Part cannot take anything beyond the 0th
(head) element of atoms, Part returns a Message when the index is
greater than the depth of the expression being taken apart, Part
returns the expression corresponding to an argument of the larger
expression when 0 < the second argument to part <= Depth[first
argument].  If you consider the arguments to be internal structure
then the behavior of Part makes it necessary that you treat
expressions as if you know something about their internals.  It also
makes clear what an atom is: a Depth 0 object.

> You cannot extract the components of an expression with head
> Complex using
> Part[].

Because by definition you cannot do that to any atom and an
expression of the form Complex[_,_] is an atom.

>   You have to "ask nicely".  For Lists, I believe that Part[] /is/

I don't consider this exceptional, all you have to do is distinguish
the behavior of Part between things that are atoms and things that
are not, all the rest follows logically.

> I just found this and have only glanced at it, but I believe it
> will give a
> good context for further discussion on this matter:
>
> http://library.wolfram.com/infocenter/Conferences/4680/

Thank you for the pointer, I'll read it.

> What determines (holds) the value of Arg[1+I]?

The value of Arg[1+I] is Arg[1+I] there are also rewrite rules for
equivalent expressions where equivalence is defined by expr1==expr2
being congruent to True eg:

In[54]:=
FullForm[Arg[1 + I]]
Arg[1 + I] == Times[1/4, Pi]

Out[54]//FullForm=
Times[Rational[1,4],Pi]

Out[55]=
True.

>   Where does it "live"?

In the space of arguments to the evaluator.  Since there are rewrite
rules associated with Arg one has to be careful about when they look
at an Arg expression depending on what they want to do with it.
Since all the rewrite expressions for Arg have the same value with
respect to N[Arg[_]] then if one is concerned with the value the head
is irrelevant, when one is interested in the Head though a Hold or
Unevaluated must be used to prevent the expression from being rewritten.

> You might find this interesting:
> http://www.nomic.net/~nomicwiki/index.php/GameOfNomic

I've run across it but it's been a while since I read Hofstader,

> My point in talking about multiple dimensions is to try to
> categorize the
> kinds of stuff that can be associated (attached to) a symbol.
> These might
> be viewed similarly to how domains in relational databases are viewed.

There are actually some very interesting theoretical on relations and
how then end up being implemented in RDBMSes (short version,
poorly).  While we continue on our tour of programming languages the
logic languages would be appropriate examples for reasoning about
relations.  And they too bear a strong relationship (pun not
intended) to LISP like languages.

> UpValues
> DownValues
> OwnValues
> SubValues

These things are side effects of the evaluator, like In and Out, not
fundamental.  They are very useful though because they describe
expressions we can use to interact with the rewrite rules used by the
evaluator itself.

> Arguments (elements)
> Dr. Mader describes options as named arguments (implying order
> independence).
> Options
>
> Attributes

Attributes are definitely an interesting beast, I'm not sure but I
suspect they can be considered a special set of rules used by the
evaluator.

> internal data

I'm not sure internal data is any more worth worrying about to a
Mathematica programmer as a naked quark is to a nuclear engineer.

> messages

Message are just expressions, which is why you can trace on Message
[___] to stop evaluation at a point a message is issued.  Messages
are not atomic.

> Context (symbol is probably best understood as a fully qualified
> name.)

Likewise a Context is just another expression whose value is a side
effect of the evaluator (in particular of Get[] and Needs[]