Haskell Question

I'm trying to make a program in Haskell that compares two [Char] and returns a [Integer] of all the positions that the Chars are the same.

commons :: [Char] -> [Char] -> [Integer]
commons a b = case (a, b) of
        ([], _) -> []
        (_, []) -> []
        (_, _) -> fcommons 0 a b []

fcommons n s1 s2 set = case (s1, s2) of
        ([], _) -> set
        (_, []) -> set
        (a:b, c:d) -> if a==c then fcommons n+1 b d (set:n)
        else fcommons n+1 b d set

I end up getting this error:

ERROR "commons.hs":7 - Type error in function binding
*** Term           : fcommons
*** Type           : [a] -> [b] -> [b] -> a -> a
*** Does not match : [a] -> a
*** Because        : unification would give infinite type

I'm new to Haskell and have no idea why this is happening.

Also, sorry if this is a really shitty way to write hscode.

yes, it's really shitty, so shitty it looks like a joke.


commons :: [Char] -> [Char] -> [Integer]
commons a b = fcommons 0 a b []

fcommons _ [] _ set = set
fcommons [] _ _ set = set
fcommons n (a:b) (c:d) set | a == c    = fcommons (n+1) b d (set:n)
                           | otherwise = fcommons (n+1) b d set

that is the same thing, rewritten in a good style. anyway, the error is that you're doing set:n, but it's actually n:set. why?
it's head:tail, the head is an element of the same type as the elements of the list, in this case, an integer. and tail must be a list.

still, using an accumulator is not how it's done. the "good" way (in haskell, at least) is:

commons :: [Char] -> [Char] -> [Integer]
commons a b = fcommons 0 a b

fcommons _ [] _ = []
fcommons [] _ _ = []
fcommons n (a:b) (c:d) | a == c    = n : fcommons (n+1) b d
                       | otherwise = fcommons (n+1) b d

this still can be done better, but I won't get into harder ground.

>>2
>>3
well, haskell itself is shitty, so...

ps: read sicp

Just zip it! :)

commons a b = [i|(i,eq) <- zip [0..] $ zipWith (==) a b, eq]

>>5
That's clever!  I've spent like 3 minutes or so on it until I got that eq gets either True or False and i|(i,eq) doesn't yield number if eq /= True.  Thanks >>5.  Haskell rules.

So, breaking it down:

Prelude> zipWith (==) "abcd" "xbxde"
[False,True,False,True]

Prelude> zip [0..] $ zipWith (==) "abcd" "xbxde"
[(0,False),(1,True),(2,False),(3,True)]

Prelude> [i|(i,eq) <- zip [0..] $ zipWith (==) "abcd" "xbxde", eq]
[1,3]

So, eq will e.g. be False for the first item (and i 1). And as you say that it will skip that item.

HAY GUISE

(loop for i from 0
      for a across "abcd"
      for b across "xbxde"
      when (eq a b) collect i)

>>8
Loop is a much more advanced language than most.

iter is more advanced than ruby and python put together

actually I think the loop example is

[i | i <- [0..] | a <- "abcd" |  b <- "xbxde", a == b]

in GHC, let the haskell masters tell me if this is true.

OP here. 

The REAL problem was that I forgot pars around the n+1s.  Well, I guess the real problem is that I'm a fucking idiot.  You've all been there once, no?

I guess the real problem is that I'm a fucking idiot
that was obvious from
Haskell Question
Haskell


commons xs ys = [c | (a,b,c) <- zip3 xs ys [1..], a == b]
maximum pretty

>>13
you are just upset because you don't understand nomads

commons = (.) (length . filter (uncurry (==))) . zip

not dubs

^{HAX MY ANUS}

>>18
you win hard
/thread

>>23
Actually, >>18 doesn't work, here's an improved version:
commons xs ys = sum [1 | (a,b) <- zip xs ys, a == b]

Uh, make that
commons xs ys = sum [1 | (x, y) <- zip xs ys, x == y]

>>24
It does work, actually.
quote from op
returns a [Integer] of all the positions that the Chars are the same
Yours on the other hand doesn't.

/prog/ will be spammed continuously until further notice. we apologize for any inconvenience this may cause.