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

12 Jul 2011

      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