#3631: Overload the Prelude iterate to support list input
---------------------------------+------------------------------------------
    Reporter:  shelbymoore3      |        Owner:                  
        Type:  feature request   |       Status:  closed          
    Priority:  normal            |    Milestone:                  
   Component:  Prelude           |      Version:  6.10.4          
    Severity:  normal            |   Resolution:  wontfix         
    Keywords:                    |   Difficulty:  Unknown         
    Testcase:                    |           Os:  Unknown/Multiple
Architecture:  Unknown/Multiple  |  
---------------------------------+------------------------------------------
Comment (by [email protected]):

 Replying to [comment:9 shelbymoore3]:
 > That is reasonable, except that small tweaks can be easily buried in a
 mailing list.

 I agree that sometimes they get lost - but that can also be a sign of lack
 of support within the community.  If a proposed change cannot gather an
 enthusiastic crowd who want it implemented, then the idea just isn't worth
 the effort of changing all the consequentially-impacted software etc to
 support it.

 >  Also it is well known that consensus is not the way to write the best
 software.  Small teams slaughter large monoliths.

 The Haskell community values consensus, especially on standard and far-
 reaching components like the Prelude.

 > This idea is not ill-formed.

 Has anyone pointed out yet that your 'iterate' function is non-
 terminating?  Each recursive call builds a larger data structure (or
 rather, a thunk for it), but there is no base-case to the recursion, so no
 value is ever returned to the caller.  This is the kind of beginner's
 mistake that is posted (and ironed out) every day on haskell-cafe@, or
 beginn...@.  The input of the community really can help you write better
 (working) code.

 > Perhaps that is because type inference doesn't scale and should be
 avoided entirely, except for local usage:

 You will find it hard to convince anyone in the Haskell community that
 type inference is a bad idea. :-)

 > It is not totally unreasonable, except it doesn't scale.  You are going
 to have adjust if Haskell is going to move out of the research and into
 mainstream, then busy business people are going to come and make quick
 inputs, and if you shut them out, then you are shooting yourself in the
 foot.

 Letting any beginner who has studied Haskell for one week, modify the
 Prelude that is used by every Haskell programmer everywhere, without
 discussion and consensus, is what does not scale.

-- 
Ticket URL: <http://hackage.haskell.org/trac/ghc/ticket/3631#comment:11>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler
_______________________________________________
Glasgow-haskell-bugs mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

Reply via email to