Question: I read that an expression is anything that gives some value, like `2 + X`, while a statement is any instruction to the computer to execute something, like `print("hi")`.

What about the following line of code?

`X = someFunction() + 2`

`someFunction()` returns some numerical value (I think a lot of languages wouldn't compile this code if it didn't), and thus `someFunction() + 2` is 'something that yields some value' - aka an expression.

But, `someFunction()` is code to be executed, thus a statement.

My question:

There are often lines of code that **equal some value**, but are also an **instruction to be executed**. What are these lines of code considered?

Answer: 
In certain computer languages called "functional languages", everything--including the code that prints "hi"--is an expression. At the other extreme, you can write code in machine language (so you, not a compiler, are deciding exactly what sequence of bytes should compose the executable program), and at that level practically everything (even adding 2 to something) is an "instruction to the computer to execute something".

I've used a lot of different computer languages, and a far as I can recall, in each case there was documentation somewhere defining what makes a statement in that particular language (if indeed the language even has a concept of "statement"). The definition is based on syntax, not so much on what the code does.

For example, in C or C++, if you write

```
{ x + 2; }

```

then technically the "x + 2;" is a statement. It is a useless statement that doesn't do anything, but syntactically, it is a statement nevertheless. In fact, one way to write a statement in C is to just append a semicolon to an expression (<http://msdn.microsoft.com/en-us/library/1t054cy7.aspx>). You don't even need the expression; a semicolon by itself can be a statement (<http://msdn.microsoft.com/en-us/library/h7zyw61x.aspx>).

By the way, in C++, the '+' in an expression such as (x + 2) may actually be a function call. So if you say anything that calls a function is a statement, then (x + 2) would be, or at least could be, a statement in C++. But I don't know any authority who defines it that way.
tldr; It is a statement *when* it is parsed as statement, and an expression *when* it is parsed as an expression. The rules of which depend upon the particular language in question.

Expressions and statements should *not* be confused with "what actually happens" underneath, but merely as describing the [*syntax* constructs of a language's grammar](http://en.wikipedia.org/wiki/Syntax_%28programming_languages%29).

Because the grammar and parsing rules [generally] depend on the program as a whole, taking part of an expression and using it as a statement, where such is allowed, does *not* indicate that it is a statement, much less when it appears in an expression context.

---

As for the particular example given, it depends on programming language *and* where the construct appears. Some languages support assignments as expressions, while others do not.

For instance, consider this JavaScript (see [Appendix A of ES5](http://es5.github.io/#A) for the grammar rules).

```
{ x = y = f() + 2 }

```

In this case, the block *is* a statement (BlockStatement) and `x = ..` is also considered a "statement" (although it is *really* an Expression via Statement -> ExpressionStatement) while `y = ..` *is* an expression. Likewise, `f()` is an expression (technically, `f` is also an expression in JavaScript) and `2` is an expression and `f() + 2` is an expression.

However, the following is [*invalid* Pascal](http://wiki.freepascal.org/Becomes) because Pascal's *syntax* does not support `:=` (assignment) in an expression and an assignment is always a statement.

```
X := Y := F() + 2

```

Some languages also forbid general expressions as statements, which further throws off the notion that, in `y = EXPR`, it is correct to consider `EXPR` a valid statement. The following is *invalid C#*, but is dubiously valid in JavaScript and many other languages.

```
{ f() + 2; }

```