[Haskell-cafe] Lazy series [was : Preventing sharing]

[Arjen]

On 01/09/2016 07:11 PM, Tom Ellis wrote:
> On Sat, Jan 09, 2016 at 07:04:17PM +0100, Arjen wrote:
>> If I'm not mistaken, a strict language implies that arguments are
>> evaluated before function calls.  To calculate exps, you need to add 1 to
>> the result of the function call integral on argument exps.
>
> Sure, but why should evaluating exps actually do anything?  If exps is of
> function type then evaluating it need not do anything at all!
>
>> To evaluate that call, it first evaluates the arguments: exps.  And so
>> on...  This causes a non-terminating calculation, I would expect.
>
> I disagree, for the reason above.
>
>> IMHO, unless you add explicit laziness to a strict language, which
>> some do but it requires some extra syntax, this cannot be done.
>
> You don't even need explicit laziness.  Having exps be of function type will
> do.  That means evaluating it will terminate early.
>
>> If you propose that a function (or anything with a function type) is
>> implicitly lazy, then I think that you are describing a
>> lazy/non-strict language.
>
> I'm not sure what you're getting at here.  I'm not proposing that function
> application is evaluated lazily, I'm claiming that functions themselves are
> lazy datatypes since they contain computations that are only run when you
> applying them to arguments.
>
> Tom

I was thinking of exps as a value (having a non-function type). Maybe 
I'm wrong or just not understanding the issue fully. How do you 
differentiate between expression that are values and those that are 
function applications on arguments?

If I were to print the value of exps, like main = print exps. How would 
I express this? Or is it print's responsibility to evaluate the argument?
Say, exps has type Integer. How does print differentiate between a 
actual value (print 42) and unevaluated expressions (print exps)?

kind regards, Arjen