Vermeiden von primitiver Besessenheit in Haskell

Question

Von http://learnyouahaskell.com/making-our-own-types-and-typeclasses

data Person = Person { name :: String 
        , age :: Int 
        } deriving (Show) 

In einer realen Anwendung unter Verwendung von Primitiven wie String und Int für Namen und das Alter würden primitive Besessenheit Constitué, einen Code Geruch. (Auch offensichtlich geboren Datum ist vorzuziehen, Alter Int aber lassen wir das ignorieren) Stattdessen würde man so etwas wie

newtype Person = Person { name :: Name 
         , age :: Age 
         } deriving (Show) 

In einer OO-Sprache bevorzugen diese etwas aussehen würde wie

class Person { 
    Name name; 
    Age age; 
    Person(Name name, Age age){ 
    if (name == null || age == null) 
     throw IllegalArgumentException(); 
    this.name = name; 
    this.age = age; 
    } 
} 

class Name extends String { 
    Name(String name){ 
    if (name == null || name.isEmpty() || name.length() > 100) 
     throw IllegalArgumentException(); 
    super(name); 
    } 
} 

class Age extends Integer { 
    Age(Integer age){ 
    if (age == null || age < 0) 
     throw IllegalArgumentException(); 
    super(age); 
    } 
} 

Aber wie ist das gleiche in idiomatischen, Best Practice Haskell erreicht?

Answer 1

Make Name abstract und bieten einen intelligenten Konstruktor. Das bedeutet, dass Sie das Name Daten Konstruktor nicht exportieren, und bieten einen Maybe -returning Konstruktor statt:

module Data.Name 
(Name -- note: only export type, not data constructor 
, fromString 
, toString 
) where 

newtype Name = Name String 

fromString :: String -> Maybe Name 
fromString n | null n   = Nothing 
      | length n > 100 = Nothing 
      | otherwise  = Just (Name n) 

toString :: Name -> String 
toString (Name n) = n 

Es ist nun unmöglich, einen Name Wert der falschen Länge außerhalb des Moduls zu konstruieren.

Für Age, könnten Sie das gleiche tun, oder eine Art von Data.Word verwenden, oder verwenden Sie die folgende ineffizient, aber garantiert nicht negative Darstellung:

data Age = Zero | PlusOne Age 

Answer 2

Dieser Code Geruch in einigen Sprachen sein kann, aber In Haskell wird das normalerweise nicht berücksichtigt. Sie müssen eine konkrete Darstellung eines Namens und Geburtsdatums irgendwo wählen, und die Datentypen Erklärung von Person ist wahrscheinlich der beste Ort, um es zu tun. In Haskell würde der übliche Weg, um anderen Code von der Namensdarstellung abhängig zu machen, Person abstract sein. Anstatt den Person Konstruktor freizulegen, stellen Sie Funktionen zum Erstellen, Ändern und Überprüfen von Person Werten zur Verfügung.