[Haskell] Signature van Lambda functie aanpassen

[Boudewijn]

Hoihoi

Ik ben wat fijn aan het coden:

code:

haalMaxPalindrome :: [Int] -> [Int]
haalMaxPalindrome l = head (filter (\x -> reverse x == x) (map (splitsGetal [])l ))

Hier gaat een lijst van getallen in, die ik wil splitsen in lijsten. Deze functie werkt goed (behalve dat ik er vanuit ging dat de head van de lijst ook het hoogste getal is).

Lijst-splitsen gaat prima:

code:

splitsGetal :: [Int] -> Int  -> [Int]
splitsGetal l n = if n <10 then l++[n] else splitsGetal (l++[n `mod`10]) (n `div` 10)

Werkt prima, echter als ik de aanroep van head weghaal:

code:

haalMaxPalindrome :: [Int] -> [Int]
haalMaxPalindrome l =filter (\x -> reverse x == x) (map (splitsGetal[]) l )

code:

euler4.hs:26:43:
    Couldn't match expected type `[a]' against inferred type `Int'
    In the first argument of `reverse', namely `x'
    In the first argument of `(==)', namely `reverse x'
    In the expression: reverse x == x

Waarom gaat krijgt die lambda functie nu een int ipv een [int] voor zijn kiezen? Ik snap niet wat de aanroep op head (op het resultaat van de lambda wordt uitgevoerd) hierop voor invloed heeft.

Kan iemand me een beetje de goede kant op helpen?


Overige deel van de code trouwens:

code:

module Main where

main::IO()
main =  do
 let n = [1..100] in
  let m = [1..100] in
    let factorMatrix =reverse( (\x -> foldl (++) [] x) (map (multList n) m)) in
     print $(haalMaxPalindrome factorMatrix      )

-- vermenigvuldigt x met alle elementen in de lijst
multList :: [Int] -> Int -> [Int]
multList l n =  map (n*) l

-- splits 123 in [1,2,3] etc
splitsGetal :: [Int] -> Int  -> [Int]
splitsGetal l n = if n <10 then l++[n] else splitsGetal (l++[n `mod`10]) (n `div` 10)


-- splits 123 in [1,2,3] etc
-- splitsGetal :: [Int] -> Int  -> [Int]
-- splitsGetal l n = if n <10 thenm Splits alle* factoren die aangeleverd worden op in lijsten zodat de palindroom functie werkt
-- Filter op palindromische lijsten
-- haal de het eerste element uit de lijst
-- *= en dat alles met lazy evaluation ;-)
haalMaxPalindrome :: [Int] -> [Int]
haalMaxPalindrome l =filter (\x -> reverse x == x) (map (splitsGetal[]) l )

offtopic:
Ja niet de meest efficiente oplossing

[RayNbow]

Boudewijn schreef op vrijdag 05 december 2008 @ 22:37:
[...]
Kan iemand me een beetje de goede kant op helpen?

Laten we beginnen met wat je had:

code:

haalMaxPalindrome :: [Int] -> [Int]
haalMaxPalindrome l = head (filter (\x -> reverse x == x) (map (splitsGetal [])l ))

Hier gaat een lijst van getallen in, die ik wil splitsen in lijsten. Deze functie werkt goed (behalve dat ik er vanuit ging dat de head van de lijst ook het hoogste getal is).

Type van head:

code:

head :: [a] -> a

Je geeft op dat haalMaxPalindrome uiteindelijk een [Int] oplevert, dus dan moet a = [Int] geleden. Het argument van head moet dan van het type [[Int]] zijn. Het argument van head is het resultaat van filter. Deze laatste functie heeft het type:

code:

filter :: (b -> Bool) -> [b] -> [b]

Er moet gelden dat [b] = [[Int]], dus b = [Int]. De lambda moet dus het type [Int] -> Bool hebben. Het is af te leiden dat dit type verenigbaar is met het meest algemene type van de lambda:

code:

(\x -> reverse x == x) :: Eq c => [c] -> Bool

Werkt prima, echter als ik de aanroep van head weghaal:

code:

haalMaxPalindrome :: [Int] -> [Int]
haalMaxPalindrome l =filter (\x -> reverse x == x) (map (splitsGetal[]) l )

code:

euler4.hs:26:43:
    Couldn't match expected type `[a]' against inferred type `Int'
    In the first argument of `reverse', namely `x'
    In the first argument of `(==)', namely `reverse x'
    In the expression: reverse x == x

Waarom gaat krijgt die lambda functie nu een int ipv een [int] voor zijn kiezen? Ik snap niet wat de aanroep op head (op het resultaat van de lambda wordt uitgevoerd) hierop voor invloed heeft.

Zonder head geldt er iets anders. We reiteren eerst het type van haalMaxPalindrome en filter:

code:

haalMaxPalindrome :: [Int] -> [Int]
filter :: (b -> Bool) -> [b] -> [b]

Het resultaat van filter is het resultaat van haalMaxPalindrome. Er moet dus gelden dat [b]=[Int], dus b=Int. De filter functie vraagt dus een predicaat van type Int -> Bool, maar het meest algemene type van de lambda is Eq a => [a] -> Bool. Dit is een type error gezien Int = [a] niet verenigbaar is.

Btw, ik zie aan de filename dat je aan Project Euler problem 4 werkt? De Haskell oplossing kan in 4 regels (waarvan 3 lets).