El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Unions Discriminades

Següent ►
►

Les unions discriminades són una característica poderosa de F# que permet definir tipus que poden tenir diverses formes. Aquestes formes es defineixen com a constructors de tipus, i cada constructor pot tenir els seus propis valors associats. Les unions discriminades són molt útils per representar dades que poden tenir diferents variants, com ara resultats d'operacions que poden ser èxits o errors, o formes geomètriques que poden ser cercles, quadrats, etc.

Conceptes Clau

  1. Definició d'Unions Discriminades: Com es defineixen i utilitzen les unions discriminades.
  2. Coincidència de Patrons: Com utilitzar la coincidència de patrons per treballar amb unions discriminades.
  3. Exemples Pràctics: Exemples d'ús d'unions discriminades en diferents contextos.
  4. Errors Comuns: Errors comuns en l'ús d'unions discriminades i com evitar-los.

Definició d'Unions Discriminades

Per definir una unió discriminada en F#, utilitzem la paraula clau type seguida del nom del tipus i els constructors de tipus. Aquí teniu un exemple bàsic:

type Shape =
    | Circle of radius: float
    | Rectangle of width: float * height: float
    | Triangle of base: float * height: float

En aquest exemple, Shape és una unió discriminada amb tres constructors: Circle, Rectangle i Triangle. Cada constructor té els seus propis valors associats.

Coincidència de Patrons

La coincidència de patrons és una tècnica poderosa per treballar amb unions discriminades. Permet descompondre i processar els valors de les unions discriminades de manera clara i concisa. Aquí teniu un exemple de com utilitzar la coincidència de patrons amb la unió discriminada Shape:

let area shape =
    match shape with
    | Circle radius -> Math.PI * radius * radius
    | Rectangle (width, height) -> width * height
    | Triangle (base, height) -> 0.5 * base * height

En aquest exemple, la funció area calcula l'àrea d'una forma donada. Utilitza la coincidència de patrons per descompondre el valor de shape i aplicar la fórmula adequada per a cada tipus de forma.

Exemples Pràctics

Exemple 1: Resultat d'Operació

Les unions discriminades són útils per representar resultats d'operacions que poden ser èxits o errors. Aquí teniu un exemple:

type Result<'T> =
    | Success of value: 'T
    | Error of message: string

let divide x y =
    if y = 0.0 then
        Error "Cannot divide by zero"
    else
        Success (x / y)

let result = divide 10.0 2.0

match result with
| Success value -> printfn "Result: %f" value
| Error message -> printfn "Error: %s" message

Exemple 2: Representació de Missatges

Les unions discriminades també es poden utilitzar per representar diferents tipus de missatges en un sistema de missatgeria:

type Message =
    | Text of content: string
    | Image of url: string
    | Video of url: string * duration: int

let processMessage message =
    match message with
    | Text content -> printfn "Text message: %s" content
    | Image url -> printfn "Image message: %s" url
    | Video (url, duration) -> printfn "Video message: %s, duration: %d seconds" url duration

let msg = Video ("http://example.com/video", 120)
processMessage msg

Errors Comuns

  1. No Cobrir Tots els Constructors: Quan utilitzeu la coincidència de patrons, assegureu-vos de cobrir tots els constructors de la unió discriminada. Si no ho feu, el compilador generarà un advertiment.
  2. No Utilitzar Valors Associats: Quan definiu constructors amb valors associats, assegureu-vos d'utilitzar aquests valors en la coincidència de patrons.

Exercicis Pràctics

Exercici 1: Definir una Unió Discriminada

Defineix una unió discriminada TrafficLight que representi els tres estats d'un semàfor: Red, Yellow i Green.

Exercici 2: Coincidència de Patrons amb TrafficLight

Escriu una funció nextLight que prengui un valor de TrafficLight i retorni el següent estat del semàfor.

Solucions

Solució 1

type TrafficLight =
    | Red
    | Yellow
    | Green

Solució 2

let nextLight light =
    match light with
    | Red -> Green
    | Yellow -> Red
    | Green -> Yellow

let currentLight = Red
let next = nextLight currentLight
printfn "Next light: %A" next

Conclusió

Les unions discriminades són una característica fonamental de F# que permeten definir tipus amb múltiples formes. La coincidència de patrons facilita el treball amb aquests tipus de manera clara i concisa. Amb la pràctica, les unions discriminades es convertiran en una eina poderosa en el vostre arsenal de programació en F#.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats