Mehrere Bedingungen bei der Verwendung von Wachen in Haskell

Question

Ich versuche, eine gültige Bewegung zu bestimmen. Ein Zug muss zwei Bedingungen erfüllen, um einen gültigen Zug zu ermöglichen. Die erste Bedingung ist sicherzustellen, dass sich kein bereits vorhandenes Stück in der Position befindet, in die ich mich bewegen möchte. Die zweite Bedingung besteht darin, sicherzustellen, dass ich einen Punkt erziele, wenn ich diesen Zug mache.

Ich habe den Code für die erste Bedingung abgeschlossen, aber ich weiß nicht, wie man das mit der zweiten Bedingung weiter verfolgt. Vielleicht ist der Grund, warum es schwierig ist, weil es einen Bool zurückgibt, der auf Wahr oder Falsch gesetzt werden muss, wenn eine der anderen Bedingungen erfüllt ist. Zum Beispiel

valid :: Piece -> Pieces -> Bool 
valid p [] = True 
valid p (x:xs) | getPos(p) == getPos(x) = False 
         | otherwise = valid p xs 

So wie Sie sehen können, habe ich den Code für die erste Bedingung gemacht, jetzt, wie ich in der zweiten Bedingung hinzu?

So etwas wie

valid :: Piece -> Pieces -> Bool 
valid p [] = True 
valid p (x:xs) | getPos(p) == getPos(x) = False 
         | otherwise = valid p xs 
         && ... 

Aber dann wieder, wird diese Funktion nicht mehr, wenn die erste Bedingung entweder ausfällt oder übergibt. Was ist die Arbeit dafür?

EDIT: Erklärungen

data Piece = Piece Position Player 
type Pieces = [Piece] 

EDIT: getPos

getPos ist eine Funktion, die die Position eines Stückes

Answer 1

Sie ruft konnte den Test für eine vakante Stelle zu einer Hilfsfunktion bewegen (vacant, sagen Sie) und schreiben Sie Ihre anderen Bedingungen in valid, wie mit einer zusätzlichen score Funktion:

valid :: Piece -> Pieces -> Bool 
valid p xs = vacant p xs && score p xs > 0 

vacant :: Piece -> Pieces -> Bool 
vacant p [] = True 
vacant p (x:xs) 
    | getPos p == getPos x = False 
    | otherwise = vacant p xs 

score :: Piece -> Pieces -> Int 
score p xs = error "TODO" 

Sie auch einfacher vacant zum Ausdruck bringen können, zu vermeiden explizite Rekursion:

import Data.List (notElem) 

vacant p xs = getPos p `notElem` map getPos xs 

Allerdings würde ich vermuten, dass die Partitur Berechnung beruht auf der Tatsache, dass der Umzug möglich war. So können Sie feststellen, dass es eine Verbesserung ist das in eine einzige Funktion zu rollen, die für einen gültigen Zug mit einem positiven Score testet und geben ein Maybe:

score :: Piece -> Pieces -> Maybe Int 
score p xs 
    | getPos p `notElem` map getPos xs = let 
    computedScore = error "TODO" 
    in if computedScore > 0 
     then Just computedScore 
     else Nothing 

    | otherwise = Nothing 

Jetzt können Sie Muster-Spiel auf dem Ergebnis der score: if Sie erhalten Nothing, dann war der Umzug ungültig oder führte nicht zu einem positiven Ergebnis; Wenn Sie Just s erhalten, dann war der Zug gültig und führte zum Ergebnis s.