My solution based on Bernie's solution: init :: [a] -> [a] init xs = foldr (left (length xs)) xs xs left :: Int -> a -> [a] -> [a] left n x xs | n == length xs = [] | otherwise = x : xs I use the foldr return value for the empty list as the input itself. Use this value as a marker to signify that I am at the end of the list by checking its length. On 2005/04/10, at 17:13, Bernard Pope wrote:

On Sun, 2005-04-10 at 15:44 +0900, Kaoru Hosokawa wrote:

...

I've been working through Thompson's exercises and got to one I could not solve. It's Exercise 9.13. This is where I need to define init using foldr.

init :: [a] -> [a] init "Greggery Peccary" ~> "Greggary Peccar"

Hi,

Here's a tentative solution:

myinit xs = foldr (f (length xs)) [] xs where f len next [] | len == 1 = [] | otherwise = [next] f len next list@(x:xs) | length list + 1 == len = next : xs | otherwise = x : next : xs

-- Kaoru Hosokawa khosokawa@gmail.com

On 2005/04/16, at 12:57, Hamilton Richards wrote:

At 10:50 AM +0900 2005/4/16, Kaoru Hosokawa wrote:

...

My solution based on Bernie's solution:

init :: [a] -> [a] init xs = foldr (left (length xs)) xs xs

left :: Int -> a -> [a] -> [a] left n x xs | n == length xs = [] | otherwise = x : xs

I use the foldr return value for the empty list as the input itself. Use this value as a marker to signify that I am at the end of the list by checking its length.

Using length causes this definition of init to fail on infinite lists.

Oh. I haven't learned how to handle infinite data structures yet, but is init defined for infinite lists in the first place? -- Kaoru Hosokawa khosokawa@gmail.com

Daniel Fischer writes:

On second thoughts, I think Maybe [a] is nicer than (Bool, [a]).

Cool, this was my idea, too. Best regards, Christop Bauer -- let () = let rec f a w i j = Printf.printf "%.20f\r" a; let a1 = a *. i /. j in if w then f a1 false (i +. 2.0) j else f a1 true i (j +. 2.0) in f 2.0 false 2.0 1.0

On Mon, 11 Apr 2005, Christoph Bauer wrote:

Kaoru Hosokawa writes:

...

I've been working through Thompson's exercises and got to one I could not solve. It's Exercise 9.13. This is where I need to define init using foldr.

init :: [a] -> [a] init "Greggery Peccary" ~> "Greggary Peccar"

This is as far as I got:

init xs = foldr left [] xs

left :: a -> [a] -> [a] left x [] = [] left x1 : (x2 : xs) = x1 : (left x2 xs)

But this returns [] and doesn't work. I can't get "left" to know that it is working with the rightmost element. It just throws away every element when its right hand side is empty.

I found a solution that works for Strings, but I am looking for a more general solution. This exercise may yet again be one of those that is difficult to solve with my current knowledge of Haskell, but I'm asking anyway.

Ok, my second haskell program ;-):

module Init where

import Maybe

left :: a -> Maybe [a] -> Maybe [a] left x None = (Just []) left x (Just l) = (Just (x:l))

left x = Just . maybe [] (x:)

init :: [a] -> [a] init xs = fromJust . foldr left Nothing xs

fromMaybe (error "init: empty list") instead of fromJust

Sure, there is a better solution...

Extended question: How to do it without foldr? :-) init xs = zipWith const xs (tail xs) But this does not check for empty lists. :-(

At 6:53 PM +0200 2005/4/12, Henning Thielemann wrote:

On Tue, 12 Apr 2005, Hamilton Richards wrote:

...

Here's a solution:

...

init :: [a] -> [a] init xs = tail (foldr keep [] xs) where keep :: a -> [a] -> [a] keep x [] = [x] keep x [y] = [x,x] keep x (y:z:zs) = x:x:y:zs

Nice idea!

One case can be eliminated.

...

init :: [a] -> [a] init xs = tail (foldr keep [] xs) where keep :: a -> [a] -> [a] keep x [] = [x] keep x (_:zs) = x:x:zs

Yes, much nicer! Thanks, --Ham -- ------------------------------------------------------------------ Hamilton Richards, PhD Department of Computer Sciences Senior Lecturer The University of Texas at Austin 512-471-9525 1 University Station C0500 Taylor Hall 5.138 Austin, Texas 78712-0233 ham@cs.utexas.edu hrichrds@swbell.net http://www.cs.utexas.edu/users/ham/richards ------------------------------------------------------------------