Pourquoi l'expression de casse ne fonctionne-t-elle pas dans ce code Elm?

Question

J'ai écrit un extrait de code Elm qui dessinerait un carré et changerait la couleur carrée entre le rouge et le noir à chaque fois que l'on clique sur la souris.

Toutefois, la structure de cas dans la fonction changeColor ne fonctionne pas comme prévu, alors que le changeColor mis en œuvre avec si la structure fonctionnera.

Que dois-je faire pour comprendre ce qui ne va pas? Je vous remercie.

import Color exposing (red, black, blue, Color) 
import Signal exposing ((<~)) 
import Graphics.Element exposing (Element, show) 
import Graphics.Collage exposing (collage, square, filled, Form) 
import Mouse 
import Window 

main : Signal Element 
main = 
    scene <~ (Signal.foldp changeColor black Mouse.clicks) 

scene : Color -> Element 
scene color = 
    collage 600 600 [ filled_square color ] 

changeColor :() -> Color -> Color 
changeColor _ color = 
    case color of 
    black -> red 
    red -> black 

--changeColor _ color = 
-- if | color == black -> red 
--  | color == red -> black 

filled_square : Color -> Form 
filled_square color = square 100 |> filled color 

Answer 1

variables motif (la réponse courte)

noms Minuscules dans les modèles de cas sont des variables toujours considérées, jamais constantes. Ainsi, votre instruction case correspondra à la couleur d'une variable de modèle black, qui réussit, et lie le nom black à la valeur color dans la branche case (-> red).

Dans ce cas, le if multi-voies que vous avez dans les commentaires est la manière appropriée de distinguer les cas.

En utilisant des expressions cas

expressions de cas sont utilisées pour distinguer les cas union types. Vous pouvez par exemple modéliser explicitement vos états de programme avec un type d'union comme ceci:

import Color exposing (red, black, blue, Color) 
import Signal exposing ((<~)) 
import Graphics.Element exposing (Element, show) 
import Graphics.Collage exposing (collage, square, filled, Form) 
import Mouse 
import Window 

type Model = Red | Black 

main : Signal Element 
main = 
    scene <~ (Signal.foldp changeColor Black Mouse.clicks) 

scene : Model -> Element 
scene model = 
    collage 600 600 [ filled_square (toColor model) ] 

toColor : Model -> Color 
toColor model = 
    case model of 
    Black -> black 
    Red -> red 

changeColor :() -> Model -> Model 
changeColor _ model = 
    case model of 
    Black -> Red 
    Red -> Black 

filled_square : Color -> Form 
filled_square color = square 100 |> filled color 

La raison de faire cela pourrait être que vous avez maintenant un états finis, dénombrables pour votre programme dans un endroit facile à trouver. Si vous n'utilisez que les couleurs, vous le saurez à coup sûr en parcourant tout le programme. L'expression de la casse est exhaustive, elle gère tous les états dans lesquels votre programme peut être. Alors qu'avec une couleur multi-couleurs, qui sait si ce sont les seules couleurs possibles dans votre programme, surtout une fois qu'il devient plus grand que jouet-exemple -Taille. Si vous ne correspondez pas à toutes les couleurs possibles, vous pourriez rencontrer un crash de votre application. (Ceci est l'un des rares moyens possibles qui pourraient arriver à Elm)