For most type classes and instances, the proofs that the corresponding laws hold break horribly if you substitute their free variables with nonterminating computations. For instance, `0 * x = 0` doesn't hold if `x` is `undefined`.
How would a strict language help? `0 * x = 0` doesn't hold if `x` is substituted by a non-terminating computation `f ()`. What exactly would be the benefit?
In a strict language, non-terminating computations aren't values in the first place. So you can't substitute `x` with bottom.
I don't think I've grasped the distinction between substituting a variable of type t with a value of type t versus an expression of type t.
There's no such distinction. But, in the operational semantics of a call-by-value language, variables are only substituted with values.
Or, to be consistent with the terminology I've used in other comments, in any language, a value is something a variable can be substituted with. It's just that, in a call-by-value language, variables can never be substituted with unfinished computations.
You do get 0 * x <= 0. You just need a splash of domain theory to make the medicine go down.
Can you give an example?