[GHC] #14367: Lazy evaluation can be invalidated

[GHC]

#14367: Lazy evaluation can be invalidated
-------------------------------------+-------------------------------------
        Reporter:  vanto             |                Owner:  (none)
            Type:  bug               |               Status:  new
        Priority:  normal            |            Milestone:
       Component:  Compiler          |              Version:  8.2.1
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  Other             |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by vanto):

 Replying to [[span(style=color: #FF0000, goldfire, third time )]]:\\
 > If you'd like a change in this behavior, please submit a ghc-proposal:
 that's the only accepted way to suggest a change to GHC's specification.
 \\
 Yes I know that but you are not interested in what I say, is'nt  it? \\

 >Until then, this ticket is out of scope.\\
 This is your point of view, not mine because these are ideas that serve
 for the ticket, like you, when you write your ideas in other tickets. It's
 the same thing.
 \\
 >Otherwise, GHC will run only well-typed programs.\\
 Yes. Imagine that behind the argument {{{x}}} there are a hundred other
 expressions? And still imagines there are hundred other functions like
 this one? This is possible, you do not know!
 All these expressions must be well typed. And yet they will never be
 used. They will still be checked by the type inference algorithm.
 Waste of time! And possible danger thereafter. We do not keep unnecessary
 things in a program. The type inference algorithm computes, it does not
 make any decision. And why? Because it was never thought to do this. It
 would have been better to ask oneself
 before checking whether the expression or the function to be used is well
 typed if it will later serve in another function or in another
 expression.Otherwise what is the use of testing functions or expressions
 if we know that they will never be used? Since the language exists, has
 anyone ever thought of that? The type inference can be improved not by
 calculation but by adding decision making. But that is another matter,
 is'nt it?

-- 
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14367#comment:6>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler