anchor.diff:  
   *)
   
  -    type UnverifizierterKontakt = { Name: PersonenName; Email:Email; }
  -
  -    type VerifizierterKontakt = { Name: PersonenName; Email:VerifizierteEmail; }
  +    type UnverifiedContact = { Name: PersonalName; Email:Email; }
  +
  +    type VerifiedContact = { Name: PersonalName; Email:VerifiedEmail; }
   
       type Kontakt' = 
  -        | UnverifizierterKontakt of UnverifizierterKontakt
  -        | VerifizierterKontakt of VerifizierterKontakt
  -
  -    let ``Funktion gilt nur für verifizierte ohne Prüfung`` verifizierterKontakt = 
  -        verifizierterKontakt.Email.Email
  -
  -(**
  -
  ----
  -### DDD und F#
  -#### Model für einen Kunden mit Adressen
  +        | UnverifiedContact of UnverifiedContact
  +        | VerifiedContact of VerifiedContact
  +
  +    let ``Funktion only applies to verified contacts`` verifiedContact = 
  +        // I can access Email without further ado
  +        verifiedContact.Email.Email
  +
  +(**
  +
  +---
  +### DDD und F#
  +#### Model for a customer with an adress
   
   
   ' Das Pattern matching schränkt die Auswahl auf konkrete Typen und nicht mehr auf das Abfragen von einzelnen Werten
  
positive.code: 
  (**
  
  ---
  ### DDD und F#
  #### Mehr Zustände
  
  *)
  
  
negative.code: 
  ---
  ### DDD und F#
  #### Advantages of the F# type system
  
  - Type system embraces composition
  - DU allow a comprehensive representation of states
  
  ' - In C# oder in Java ist die Hemmschwelle relativ hoch neue Types zu erstellen. Es gibt sogar das code smell "Primitive Obsession", kein Scherz
  ' - Komposition erlaubt es einfache Typen zu immer komplexeren zusammenzufassen.  Es ist erstaunlich wie viel dann auf eine Seite passt
  