Could the strictness properties be stated in the specification (i.e. include some QuickCheck properties that define the strictness) On Thu, Mar 17, 2011 at 12:25 PM, Bas van Dijk wrote:

Hello,

I would like to propose making inits and tails less strict:

 inits                   :: [a] -> [[a]] -inits []                =  [[]] -inits (x:xs)            =  [[]] ++ map (x:) (inits xs) +inits xs                =  [] : case xs of +                                  []   -> [] +                                  x:xs -> map (x:) (inits xs)

 tails                   :: [a] -> [[a]] -tails []                =  [[]] -tails xxs@(_:xs)        =  xxs : tails xs +tails xxs               =  xxs : case xxs of +                                   []   -> [] +                                   _:xs -> tails xs

Having a lazier inits allows the elegant: nats = map length (inits nats) which loops for the current definition. This definition was due to John Tromp: http://www.mail-archive.com/haskell@haskell.org/msg21044.html

Discussion deadline: 2 weeks.

Regards,

Bas

_______________________________________________ Libraries mailing list Libraries@haskell.org http://www.haskell.org/mailman/listinfo/libraries

On 3/17/11 3:25 PM, Bas van Dijk wrote:

I would like to propose making inits and tails less strict:

inits :: [a] -> [[a]] -inits [] = [[]] -inits (x:xs) = [[]] ++ map (x:) (inits xs) +inits xs = [] : case xs of + [] -> [] + x:xs -> map (x:) (inits xs)

tails :: [a] -> [[a]] -tails [] = [[]] -tails xxs@(_:xs) = xxs : tails xs +tails xxs = xxs : case xxs of + [] -> [] + _:xs -> tails xs

Having a lazier inits allows the elegant: nats = map length (inits nats) which loops for the current definition. This definition was due to John Tromp: http://www.mail-archive.com/haskell@haskell.org/msg21044.html

+1. -- Live well, ~wren

On 18 March 2011 06:25, Bas van Dijk wrote:

I would like to propose making inits and tails less strict:

 inits                   :: [a] -> [[a]] -inits []                =  [[]] -inits (x:xs)            =  [[]] ++ map (x:) (inits xs) +inits xs                =  [] : case xs of +                                  []   -> [] +                                  x:xs -> map (x:) (inits xs)

 tails                   :: [a] -> [[a]] -tails []                =  [[]] -tails xxs@(_:xs)        =  xxs : tails xs +tails xxs               =  xxs : case xxs of +                                   []   -> [] +                                   _:xs -> tails xs

Having a lazier inits allows the elegant: nats = map length (inits nats) which loops for the current definition. This definition was due to John Tromp: http://www.mail-archive.com/haskell@haskell.org/msg21044.html

I'm not against this proposal, but am just curious: is there any reason/need for this lazier definition apart from an elegant (but possibly not actually needed/useful) trick? -- Ivan Lazar Miljenovic Ivan.Miljenovic@gmail.com IvanMiljenovic.wordpress.com