Why can Lambda Calculus not represent some combinators? This paper suggests that there are combinators (representing symbolic computations) that can not be represented by the Lambda calculus (if I understand things correctly):
There are several things that one may want to do in practice and that cannot be directly expressed in the lambda calculus.

The SF calculus is an example. Its expressive power is not news; the interesting part of the paper (not shown in the slides) is the category theory behind it. The SF calculus is analogous to a lisp implementation where you allow functions to inspect the representation of their argument — so you can write things like (print (lambda (x) (+ x 2))) ​⟹ "(lambda (x) (+ x 2))".

Another important example is Plotkin's parallel or. Intuitively speaking, there's a general result that states that lambda calculus is sequential: a function that takes two arguments must pick one to evaluate first. It's impossible to write a lambda term or such that (or ⊤ ⊥) ⟹ ⊤, (or ⊥ ⊤) ⟹ ⊤ and or ⊥ ⊥ ⟹ ⊥ (where ⊥ is a non-terminating term and ⊤ is a terminating term). This is known as “parallel or” because a parallel implementation could make one step of each reduction and stop whenever one of the argument terminates.

Yet another thing you can't do in the lambda calculus is input/output. You'd have to add extra primitives for it.

Of course, all these examples can be represented in the lambda calculus by adding one level of indirection, essentially representing lambda terms as data. But then the model becomes less interesting — you lose the relationship between functions in the modeled language and lambda abstractions.