What's the difference between 56 and Integer[56]? [duplicate]

Question

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 Plus[x, y].

But my understanding then predicts that writing 56 is really writing Integer[56]. And that writing something like 2 + 3 is really writing Plus[Integer[2], Integer[3]].

FullForm says otherwise, though. If I do FullForm[56] I just get back 56. And if I do FullForm[Integer[56]] I get back Integer[56].

TreeForm agrees with FullForm. Here is what predict I should see when doing TreeForm[Integer[56] + 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?

Edit:

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 56 and Integer[56]? And why does Head[56] produce Integer if 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.

Edit 2:

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 FullForm or 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 4, because 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[56] 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.

Answer 1

Integer[56] has no special meaning in Mathematica. However, Integer is a symbol, so it's a perfectly valid expression by itself. 56 is a valid argument. So, Integer[56] is a proper expression, although it has no built-in meaning. You may, however, write patterns that match it, so you may define your own transformations that apply to it. That's how Mathematica works: it's an expression rewriting language. If it doesn't recognize a valid expression, it leaves it alone.

Answer 2

Integer is not a function.

Consider this

a = f[b]
Head@a

f

Now, if the Head of a is f, does it mean that a is the same as f[a]? clearly not. So, why you expect 56 to be the same as Integer[56] given that Integer is not a function?