The incremental nature of a compiler, then does not make it that we would call it an Interpreter. We would call it an incremental compiler. That's a compiler, which can compile all expression, regardless of the size of the expression, not just 'whole programs'.
Why not? I would.
> Nobody there would call them interpreter because of that.
The following is Clozure Common Lisp. Every single input is compiled directly to machine code. Feed it source text and everything is compiled. Each and every expression.
Why should I call a direct native code compiler an 'Interpreter'? Makes no sense.
? (let ((f (lambda (a)
(+ 1 a))))
(disassemble f)
(funcall f 2))
;;; (lambda (a) (+ 1 a))
L0
(leaq (@ (:^ L0) (% rip)) (% fn)) ; [0]
(cmpl ($ 8) (% nargs)) ; [7]
(jne L57) ; [10]
(pushq (% rbp)) ; [12]
(movq (% rsp) (% rbp)) ; [13]
(pushq (% arg_z)) ; [16]
;;; (+ 1 a)
(leaveq) ; [17]
(testb ($ 7) (% arg_z.b)) ; [18]
(jne L39) ; [22]
(addq ($ 8) (% arg_z)) ; [24]
(jo L32) ; [28]
(repz)
(retq) ; [30]
L32
(jmpq (@ .SPFIX-OVERFLOW)) ; [32]
L39
(movl ($ 8) (% arg_y.l)) ; [39]
(jmpq (@ .SPBUILTIN-PLUS)) ; [44]
;;; #<no source text>
L57
(uuo-error-wrong-number-of-args) ; [57]
3 ; resultTraditionally, the twain ne'er did meet. However, many (most?) modern interpreters include a compiler as part of their implementation. Using a compiler in this manner is "Just in Time" (JIT) compilation.
So a box that takes Clozure Common Lisp and converts it to machine code is a compiler.
A box that takes Clozure Common Lisp, feeds it into this compiler to obtain machine code, and executes this machine code immediately, is an interpreter, using JIT compilation to do its interpretation.
The interpreter executes that language, not another.
> A box that takes Clozure Common Lisp, feeds it into this compiler to obtain machine code, and executes this machine code immediately, is an interpreter, using JIT compilation to do its interpretation.
It's neither an interpreter not using JIT compilation. It's an AOT compiler. It's just an incremental compiler.
Nowadays it's the norm for interpreted languages to be JIT-compiled. They still universally call themselves interpreted languages because the jitter is an implementation detail, and the use of one does nothing to negate the characteristics they're trying to advertise when describing themselves as interpreted languages.
Think of it this way: Can I take a text file containing source code in the language and execute it anywhere that has a special program for executing files written in that language (commonly known as an interpreter)? Or do I have to manually perform an intermediate step of converting the program to some binary representation using a special program for doing that (commonly known as a compiler), and then execute the output that program produces?