www.jammni.de

Logo - Kleiner Drache
Login
Username:

Passwort:

Daten merken
Auto-Login
Registrieren
 
Online
niemand
 
Forumsuche
Suche nach:

Logo - DracheHaskell-Forum

Smoki

Gepostet:
21.05.2011 23:23

Property Methode  
Hallo,
also mein Problem ist das folgende:
Ich sollte die Funktinen Colour_Is , And, Not, und Wheels implementieren, sowie die Property prop1
Die Funktionen sind implementiert
nun soll prop1 so implementiert werden das es das gleiche ergibt wie take 3 cars (die ersten drei autos aus der liste)

jedoch habe ich das problem das ich noch kein Oder umgesetzt habe, nun wollte ich das tun jedoch bekomme ich immer den fehler :
D:\\Eigene Dateien\\Dropbox\\strategy.hs:26:16:
parse error on input `->\'
Failed, modules loaded: none.


Hier mal der Quelltext:

module Blueprint where

data Colour = Blue | Green | Red
deriving ( Eq, Show )

data Car = Car { wheels :: Integer
, colour :: Colour
}
deriving ( Eq, Show )

data Property = Colour_Is Colour
| Wheels Ordering Integer
| And Property Property
| Not Property
deriving Show

check :: Property -> Car -> Bool
check prop car = case prop of
Colour_Is col -> col == colour car
Wheels ord num -> case ord of
LT -> num > wheels car
EQ -> num == wheels car
And l r -> check l car && check r car
Not p -> not (check p car)

cars = [ Car { wheels = 4, colour = Red }
, Car { wheels = 2, colour = Blue }
, Car { wheels = 14, colour = Green }
, Car { wheels = 4, colour = Green }
, Car { wheels = 2, colour = Red }
]

prop1 :: Property
prop1 = Wheels EQ 5

test :: Bool
test = and
[ check ( Wheels EQ 4 ) ( cars !! 0 )
, check ( Wheels LT 3 ) ( cars !! 1 )
, check ( And ( Wheels EQ 14 ) ( Colour_Is Green )) ( cars !! 2 )
, check ( Not ( Colour_Is Red ) ) ( cars !! 3 )
, filter ( check prop1 ) cars == take 3 cars
]


Wenn ich dann aber mal das Or einfüge kommt oben genannter Fehler
:

module Blueprint where

data Colour = Blue | Green | Red
deriving ( Eq, Show )

data Car = Car { wheels :: Integer
, colour :: Colour
}
deriving ( Eq, Show )

data Property = Colour_Is Colour
| Wheels Ordering Integer
| And Property Property
| Not Property
| Or Property Property
deriving Show

check :: Property -> Car -> Bool
check prop car = case prop of
Colour_Is col -> col == colour car
Wheels ord num -> case ord of
LT -> num > wheels car
EQ -> num == wheels car
And l r -> check l car && check r car
Not p -> not (check p car)
Or x y -> check y car ||check y car

cars = [ Car { wheels = 4, colour = Red }
, Car { wheels = 2, colour = Blue }
, Car { wheels = 14, colour = Green }
, Car { wheels = 4, colour = Green }
, Car { wheels = 2, colour = Red }
]

prop1 :: Property
prop1 = Wheels EQ 5

test :: Bool
test = and
[ check ( Wheels EQ 4 ) ( cars !! 0 )
, check ( Wheels LT 3 ) ( cars !! 1 )
, check ( And ( Wheels EQ 14 ) ( Colour_Is Green )) ( cars !! 2 )
, check ( Not ( Colour_Is Red ) ) ( cars !! 3 )
, filter ( check prop1 ) cars == take 3 cars
]
Zum Seitenanfang    
 
Landei

Gepostet:
22.05.2011 12:54

   
Kann es eventuell einfach an der Einrückung liegen?
Zum Seitenanfang    
 
Smoki

Gepostet:
22.05.2011 15:32

   
Tja gute Frage,... aber es ist ziemlich chaotisch, denn im notepad++ wird es bei mir auch normal angezeigt und nicht so derb weit eingerückt wie hier zB.

woran kann das liegen? Welche restriktionen gibt es denn seitens haskell bezüglich leerzeichen, einrückungen , abstätzen etc ?!
Zum Seitenanfang    
 
Landei

Gepostet:
22.05.2011 21:41

   
Siehe http://en.wikibooks.org/wiki/Haskell/Indentation

Aber wie gesagt, ist nur eine Vermutung.
Zum Seitenanfang    
 
Landei

Gepostet:
23.05.2011 08:52

   
Es ist die Einrückung: Vor Or steht bei dir ein Tab, so dass es zwar optisch auf der gleichen Höhe wie And und Not steht, aber nicht logisch. Einfach statt des Tabs Leerzeichen eingeben, und schon geht es
.
Ganz nebenbei gesagt fände ich diese Form lesbarer:


check :: Property -> Car -> Bool
check (Colour_Is col) car = col == colour car
check (Wheels LT num) car = num > wheels car
check (Wheels EQ num) car = num == wheels car
check (And l r) car = check l car && check r car
check (Not p) car = not (check p car)
check (Or x y) car = check y car || check y car


Und hast du den Fall
check (Wheels GT num) car = num < wheels car
vergessen, oder soll das so sein?
Zum Seitenanfang    
 
Smoki

Gepostet:
23.05.2011 17:04

   
Erstmal vielen Dank.
Nachdem ich die Einrückung alles ordentlich gemacht habe, ging es dann endlich :DD oh man, was für eine Sprache xD
Bisher war das halt nie ein Problem.


Nein den Fall habe ich absichtlich nicht.
Wir bekommen diese Aufgaben automatisiert gestellt und dürfen dann eigentlich nur die Funktionen vervollständigen die undifined gesetzt wurden.

Inzwischen ist mir das klar, darum durfte ich auch die Or Funktion nicht mehr hinzufügen (Das Abgabemodul der HS erlaubt die Abgabe nicht sollte man den Quelltext dann verändern und Methoden/Konstruktoren hinzufügen)
Ich habe es dann wie folgt gelöst:

module Blueprint where

data Colour = Blue | Green | Red
deriving ( Eq, Show )

data Car = Car { wheels :: Integer
, colour :: Colour
}
deriving ( Eq, Show )

data Property = Colour_Is Colour
| Wheels Ordering Integer
| And Property Property
| Not Property
deriving Show

check :: Property -> Car -> Bool
check prop car = case prop of
Colour_Is col -> col == colour car
Wheels ord num -> case ord of
LT -> num > wheels car
EQ -> num == wheels car
And l r -> check l car && check r car
Not p -> not (check p car)

cars = [ Car { wheels = 4, colour = Red }
, Car { wheels = 2, colour = Blue }
, Car { wheels = 14, colour = Green }
, Car { wheels = 4, colour = Green }
, Car { wheels = 2, colour = Red }
]

prop1 :: Property
prop1 = Not (And (And ( Wheels LT 5 ) ( Not ( Colour_Is Blue ) )) ( Not ( And ( Colour_Is Red ) ( Wheels EQ 4 ) ) ))


test :: Bool
test = and
[ check ( Wheels EQ 4 ) ( cars !! 0 )
, check ( Wheels LT 3 ) ( cars !! 1 )
, check ( And ( Wheels EQ 14 ) ( Colour_Is Green )) ( cars !! 2 )
, check ( Not ( Colour_Is Red ) ) ( cars !! 3 )
, filter ( check prop1 ) cars == take 3 cars
]


Danke schonmal für eure Hilfe. =)
Zum Seitenanfang    
 
Landei

Gepostet:
23.05.2011 20:26

   
Na ja, Haskell kannst du auch mit geschweiften Klammern und Semikolons schreiben, wenn du willst (was z.B. für programm-generierten Code viel bequemer ist, als Leerzeichen zu zählen), und das ist auch die Standardform, die in der Sprachdefinition beschrieben wird. Die Layout-Regeln sind nur dazu da, um Tipparbeit zu sparen, und übersichtlicher sieht es normalerweise auch aus. Dumm ist nur, dass die Fehlermeldungen bei falschem Layout ziemlich verwirrend sein können.

Not und And reichen natürlich aus, um die restlichen Logik-Operationen nachzubilden, z.B. nach Herrn de Morgan: a or b = not ((not a) and (not b))

Wenn das vorgegebener Code ist, finde ich ihn schlecht geschrieben. Oder hat das case of einen besonderer pädagogischen Wert? In freier Wildbahn begegnet es einem jedenfalls so gut wie nie. Das Pattern-Matching über Argument-Listen ist zwar auch nur syntaktischer Zucker für ein case of, aber trotzdem deutlich häufiger anzutreffen, und neben Guards eigentlich die Standardform.
Zum Seitenanfang