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: 
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; }

```
I would say that the "someFunction() + 2" is an expression being evaluated. Then I would say that "x = someFunction() + 2" is a statement, because most languages would generally evaluate the function's return plus two, and then assign that value to x.