I'm trying to grasp how to Wolfram Language uses symbolic expressions for everything. The concept of doing so makes sense to me, but the language doesn't behave how I predict.
I understand how writing
x + y is really writing
But my understanding then predicts that writing
56 is really writing
Integer. And that writing something like
2 + 3 is really writing
FullForm says otherwise, though. If I do
FullForm I just get back
56. And if I do
FullForm[Integer] I get back
TreeForm agrees with
FullForm. Here is what predict I should see when doing
TreeForm[Integer + 56 * 2]:
And here's what I actually get:
So what's happening to cause these difference between my prediction and what I actually see?
The answer may have something to do with "atomic objects", which are briefly discussed here: https://reference.wolfram.com/language/tutorial/BasicObjects.html#15871
It's not very helpful, though. Why are these objects atomic? What is the use of having both
Integer? And why does
56 is specifically supposed to be atomic--not breakable into any smaller pieces, like a head?
AtomQ is a thing. But what does the Q stand for? http://reference.wolfram.com/language/ref/AtomQ.html is silent on the rationale behind the name.
Based on answers and comments made prior to this edit, I've updated my understanding.
I think my basic problem was that I assumed that an expression passed to
TreeForm is not evaluated. This would be the intuitive behavior, especially for a student learning about the order of arithmetic operations.
But that behavior would also require that different functions differ on whether they choose to evaluate an expression or not, and that would introduce an rather arbitrary complexity to the whole enchilada. Users would need to remember which functions do or don't evaluate expressions passed as arguments. Yech.
If, however, I go with the idea that expressions are always evaluated, then it makes perfect sense that
FullForm[2 + 2] and
FullForm[Plus[2, 2]] give back
2 + 2 and
Plus[2, 2] would be evaluated before
FullForm ever got to see them.
And so immediately wondered about how to prevent an expression from being evaluated. And
HoldForm appeared, and now I can do
TreeForm[HoldForm[2 + 2]] to get:
Which is fundamentally what I expect.
However. It still doesn't make sense that
Head gives back
Integer. As before,
56 is supposed to be atomic. It's obvious that it's useful to be able test what 56 is, but I'm having hard time coping with the idea that a thing described as atomic.. isn't. And that's a different question.
Thanks to those who helped sort me out.