hello Everyone thanks for the help. I'm now trying to make this work on a empty list. But my question is. When the definition is : [a] -> [a] [a] Is it correct that I don't can use. length xs = 0 | [] Roelof ----------------------------------------

Subject: Re: [Haskell-beginners] function defenition. Do I understand it right? From: d@vidplace.com Date: Mon, 11 Jul 2011 18:56:42 -0400 CC: beginners@haskell.org To: rwobben@hotmail.com

On Jul 11, 2011, at 5:13 PM, Roelof Wobben wrote:

...

What I try to achieve is this:

[1,2,3,4] will be [1,2] [3,4]

[1,2,3,4,5] will be [1,2,3] [3,4,5]

So, I think what you want is this http://codepad.org/kjpbtLfR

Is that correct?

Oke, I have now this as function definition. halve (xs) | length xs `mod` 2 == 0 = (take n xs, drop n xs) | otherwise = (take (n+1) xs, drop (n+1) xs) where n= length xs `div` 2 main = do putStrLn $ show $ halve [1,2,3,4] putStrLn $ show $ halve [1,2,3] this one works except for empty lists. So I thought this would work . halve (xs) | length xs == 0 = [] | length xs `mod`2 == 0 = (take n xs, drop n xs) | otherwise = (take (n+1) xs, drop (n+1) xs) where n = length xs `div`2 but then I see this error : Error occurred ERROR line 2 - Type error in guarded expression *** Term : (take n xs,drop n xs) *** Type : ([b],[b]) *** Does not match : [a] So I assume that a function must always have the same output and can't have 1 or 2 lists as output. Is this the right assumption. Roelof ________________________________

Date: Tue, 12 Jul 2011 10:34:25 +0100 Subject: Re: [Haskell-beginners] function defenition. Do I understand it right? From: edwards.benj@gmail.com To: rwobben@hotmail.com CC: beginners@haskell.org

I don't even understand what you are trying to do :)

if you want to pattern match on the empty list

foo :: [a] -> [a] foo [] = 0 foo (x:xs) = undefined

if you want to use the guard syntax

foo xs | null xs = 0 | otherwise = undefined

Ben

On 12 July 2011 10:02, Roelof Wobben mailto:rwobben@hotmail.com> wrote:

hello

Everyone thanks for the help.

I'm now trying to make this work on a empty list.

But my question is.

When the definition is :

[a] -> [a] [a]

Is it correct that I don't can use.

length xs = 0 | []

Roelof

----------------------------------------

...

Subject: Re: [Haskell-beginners] function defenition. Do I understand it right? From: d@vidplace.commailto:d@vidplace.com Date: Mon, 11 Jul 2011 18:56:42 -0400 CC: beginners@haskell.orgmailto:beginners@haskell.org To: rwobben@hotmail.commailto:rwobben@hotmail.com

On Jul 11, 2011, at 5:13 PM, Roelof Wobben wrote:

...

What I try to achieve is this:

[1,2,3,4] will be [1,2] [3,4]

[1,2,3,4,5] will be [1,2,3] [3,4,5]

So, I think what you want is this http://codepad.org/kjpbtLfR

Is that correct?

---

Beginners mailing list Beginners@haskell.orgmailto:Beginners@haskell.org http://www.haskell.org/mailman/listinfo/beginners

Oke, So I changed everything to this : halve (xs) | null xs = ([],[]) | length xs `mod` 2 == 0 = (take n xs, drop n xs) | otherwise = (take (n+1) xs, drop (n+1) xs) where n= length xs `div` 2 main = do putStrLn $ show $ halve [1,2,3,4] putStrLn $ show $ halve [1,2,3] putStrLn $ show $ halve [] But now I see this message : Error occurred ERROR line 7 - Unresolved top-level overloading *** Binding : main *** Outstanding context : Show b Roelof ________________________________

Date: Tue, 12 Jul 2011 10:57:04 +0100 Subject: Re: [Haskell-beginners] function defenition. Do I understand it right? From: edwards.benj@gmail.com To: rwobben@hotmail.com CC: beginners@haskell.org

Yes, you are totally correct.

your guard for length zero should be ([],[]). The type of the function is

halve :: [a] -> ([a], [a])

so all the code paths have to finish with that type.

Incidentally taking the length of a linked list forces you to walk the entire list. You are better off checking as to whether it is empty or not.

Regards, Ben

On 12 July 2011 10:44, Roelof Wobben mailto:rwobben@hotmail.com> wrote:

Oke,

I have now this as function definition.

halve (xs) | length xs `mod` 2 == 0 = (take n xs, drop n xs) | otherwise = (take (n+1) xs, drop (n+1) xs) where n= length xs `div` 2

main = do putStrLn $ show $ halve [1,2,3,4] putStrLn $ show $ halve [1,2,3]

this one works except for empty lists.

So I thought this would work .

halve (xs) | length xs == 0 = []

| length xs `mod`2 == 0 = (take n xs, drop n xs)

| otherwise = (take (n+1) xs, drop (n+1) xs)

where n = length xs `div`2

but then I see this error :

Error occurred ERROR line 2 - Type error in guarded expression *** Term : (take n xs,drop n xs) *** Type : ([b],[b]) *** Does not match : [a]

So I assume that a function must always have the same output and can't have 1 or 2 lists as output.

Is this the right assumption.

Roelof

________________________________

...

Date: Tue, 12 Jul 2011 10:34:25 +0100 Subject: Re: [Haskell-beginners] function defenition. Do I understand it right? From: edwards.benj@gmail.commailto:edwards.benj@gmail.com To: rwobben@hotmail.commailto:rwobben@hotmail.com CC: beginners@haskell.orgmailto:beginners@haskell.org

I don't even understand what you are trying to do :)

if you want to pattern match on the empty list

foo :: [a] -> [a] foo [] = 0 foo (x:xs) = undefined

if you want to use the guard syntax

foo xs | null xs = 0 | otherwise = undefined

Ben

On 12 July 2011 10:02, Roelof Wobben

mailto:rwobben@hotmail.commailto:rwobben@hotmail.com>> wrote:

...

hello

Everyone thanks for the help.

I'm now trying to make this work on a empty list.

But my question is.

When the definition is :

[a] -> [a] [a]

Is it correct that I don't can use.

length xs = 0 | []

Roelof

----------------------------------------

...

Subject: Re: [Haskell-beginners] function defenition. Do I understand it right? From:

d@vidplace.commailto:d@vidplace.commailto:d@vidplace.com>

...

...

Date: Mon, 11 Jul 2011 18:56:42 -0400 CC: beginners@haskell.orgmailto:beginners@haskell.orgmailto:beginners@haskell.org> To: rwobben@hotmail.commailto:rwobben@hotmail.commailto:rwobben@hotmail.com>

On Jul 11, 2011, at 5:13 PM, Roelof Wobben wrote:

...

What I try to achieve is this:

[1,2,3,4] will be [1,2] [3,4]

[1,2,3,4,5] will be [1,2,3] [3,4,5]

So, I think what you want is this http://codepad.org/kjpbtLfR

Is that correct?

---

Beginners mailing list

Beginners@haskell.orgmailto:Beginners@haskell.orgmailto:Beginners@haskell.org>

...

http://www.haskell.org/mailman/listinfo/beginners

_______________________________________________ Beginners mailing list Beginners@haskell.orgmailto:Beginners@haskell.org http://www.haskell.org/mailman/listinfo/beginners

On Tue, Jul 12, 2011 at 11:43:10AM +0000, Roelof Wobben wrote:

Oke,

So I changed everything to this :

halve (xs) | null xs = ([],[])

You do not need this case. ([], []) is what halve [] already would have returned even without this case: length [] == 0, so it would evaluate to (take 0 [], drop 0 []) which is ([], []).

| length xs `mod` 2 == 0 = (take n xs, drop n xs) | otherwise = (take (n+1) xs, drop (n+1) xs) where n= length xs `div` 2

main = do putStrLn $ show $ halve [1,2,3,4] putStrLn $ show $ halve [1,2,3] putStrLn $ show $ halve []

But now I see this message :

Error occurred ERROR line 7 - Unresolved top-level overloading *** Binding : main *** Outstanding context : Show b

This message is just because it cannot figure out the type of [] in 'putStrLn $ show $ halve []'. You can write putStrLn $ show $ halve ([] :: [Int]) to give it an explicit type. It's a bit annoying since we happen to know that the type of the list makes no difference, but the compiler can't figure that out. -Brent

----------------------------------------

Date: Tue, 12 Jul 2011 09:15:45 -0400 From: byorgey@seas.upenn.edu To: beginners@haskell.org Subject: Re: [Haskell-beginners] function defenition. Do I understand it right?

On Tue, Jul 12, 2011 at 11:43:10AM +0000, Roelof Wobben wrote:

...

Oke,

So I changed everything to this :

halve (xs) | null xs = ([],[])

You do not need this case. ([], []) is what halve [] already would have returned even without this case: length [] == 0, so it would evaluate to (take 0 [], drop 0 []) which is ([], []).

...

| length xs `mod` 2 == 0 = (take n xs, drop n xs) | otherwise = (take (n+1) xs, drop (n+1) xs) where n= length xs `div` 2

main = do putStrLn $ show $ halve [1,2,3,4] putStrLn $ show $ halve [1,2,3] putStrLn $ show $ halve []

But now I see this message :

Error occurred ERROR line 7 - Unresolved top-level overloading *** Binding : main *** Outstanding context : Show b

This message is just because it cannot figure out the type of [] in 'putStrLn $ show $ halve []'. You can write

putStrLn $ show $ halve ([] :: [Int])

to give it an explicit type. It's a bit annoying since we happen to know that the type of the list makes no difference, but the compiler can't figure that out.

-Brent

_______________________________________________ Beginners mailing list Beginners@haskell.org http://www.haskell.org/mailman/listinfo/beginners

Hello, Problem solved. See this url: http://codepad.org/jMPCO1UE I have tested the difference with [int] and [Char]. With Int You get this output ([],[]) and with Char this one ["",""] Everyone thanks for the help and patience. Roelof