Tipi opachi in

Informazioni su Tipi opachi

Introduzione

I tipi opachi sono una tecnica di incapsulamento in Elm. Alcuni la chiamano anche information hiding, ossia nascondere i dettagli implementativi. Vengono anche usati comunemente per applicare la validazione, usando il pattern Parse, dont validate. Ad esempio, potresti avere un tipo opaco EmailAddress, che può contenere solo indirizzi email validi (al contrario di una String, che può contenere qualsiasi cosa).

Creare un tipo opaco

I tipi personalizzati hanno una o più varianti, e il compilatore genera automaticamente una funzione per creare ogni variante, usando il nome della variante. Questi sono l'unico modo in cui i tipi personalizzati possono essere creati. Il compilatore consente anche la destrutturazione di queste varianti.

type Maybe a
    = Nothing --> Variant implies a 'Nothing' function, with type 'Maybe a', and destructuring of 'Nothing'
    | Just a  --> Variant implies a 'Just' function, with type 'a -> Maybe a', and destructuring of 'Just _'

Per impostazione predefinita, tutto questo è interno al file / modulo, e usiamo la parola chiave exposing per scegliere cosa esportare. Il modulo Maybe espone il tipo Maybe (in modo che altri moduli possano usare valori Maybe esistenti), ed espone anche le varianti Nothing e Just (in modo che altri moduli possano creare e destrutturare valori Maybe). Usa la seguente sintassi per farlo. La parte Maybe(..) dice a Elm di esporre tutte le varianti, oltre alla definizione del tipo personalizzato.

module Maybe exposing
  ( Maybe(..)
  -- ...
  )

Per creare un tipo opaco, scegli semplicemente di non esportare le varianti. Per farlo con il tipo Maybe, useresti la seguente sintassi:

module Maybe exposing
  ( Maybe
  -- ...
  )

Quando lo fai, quasi sempre devi fornire un altro modo per creare e ottenere le varianti, esponendo funzioni personalizzate. Queste funzioni personalizzate ti permettono di applicare una logica quando crei e ottieni le varianti. Questo nasconde i dettagli implementativi interni del modulo, e significa che puoi cambiare i dettagli implementativi quanto vuoi, finché le funzioni esposte rimangono le stesse. Ti permette anche di mantenere le invarianti quando crei e usi il tipo.

Parse, don't validate

Probabilmente l'uso più comune dei tipi opachi è applicare la validazione, usando il pattern Parse, dont validate. In questo pattern, esponi una funzione che accetta un input con meno struttura / sicurezza dei tipi di quanto desideri, come una String, e poi lo analizzi in un tipo più strutturato, come EmailAddress, restituendo il tipo oppure un errore (di solito Maybe o Result).

Ad esempio, nel codice qui sotto, è possibile per i moduli esterni creare un tipo EmailAddress solo usando la funzione parseEmailAddress, quindi quando lavori con il tipo EmailAddress, hai la certezza che sia valido.

module EmailAddress exposing ( EmailAddress, parseEmailAddress, getEmailAddress )

-- The `EmailAddress` custom type has one variant, also called `EmailAddress`
-- When a custom type has one variant, it is idiomatic to use the same name for both.
type EmailAddress = 
  EmailAddress String

-- create an EmailAddress variant
parseEmailAddress: String -> Maybe EmailAddress
parseEmailAddress candidateEmailAddress =   
  if isValidEmailAddress candidateEmailAddress then
    Just (EmailAddress candidateEmailAddress)
  else
    Nothing

-- get an EmailAddress variant
getEmailAddress: EmailAddress -> String
getEmailAddress ( EmailAddress  emailAdress ) =
  emailAdress

isValidEmailAddress: String -> bool
-- ...