As far as I am aware, most functional programming languages today use a call-by-value eager evaluation strategy with some exceptions like Haskell. I am curious if it is possible for a language to have a mixed evaluation strategy: for example, a language where everything is evaluated lazily by default but some functions can be marked as eager and are evaluated as such. I am not interested about emulating different evaluation semantics (like using thunks to create laziness) but where the language itself allows for mixed modes.
Almost every mainstream programming language mixes strict and eager evaluation. In particular, in almost all mainstream programming languages, subroutine calls, function applications, and operator applications are evaluated eagerly, except conditional operations.
For example, in C,
foo ? x : y will only evaluate
foo is false and only evaluate
foo is true.
foo is evaluated eagerly, but
y are evaluated lazily.
There are some programming languages which eagerly evaluate both branches, but they are very rare, and not mainstream.