Herramientas de usuario

Herramientas del sitio


wiki2:elm

Diferencias

Muestra las diferencias entre dos versiones de la página.

Enlace a la vista de comparación

Ambos lados, revisión anterior Revisión previa
Próxima revisión
Revisión previa
wiki2:elm [2020/05/09 18:44]
root [Types]
wiki2:elm [2020/05/16 11:53] (actual)
Línea 86: Línea 86:
 "​aaaaaaaaaaaaaaaaaaaa" ​ "​aaaaaaaaaaaaaaaaaaaa" ​
 </​code>​ </​code>​
 +
 +==== Destructuring ====
 +
 +<​code>​
 +let
 +(firstName, lastName) = ("​John",​ "​Doe"​)
 +in
 +lastName -- Result: Doe
 +
 +-- ... or ... 
 +second (_, snd) = snd
 +second (0, 1) -- Result: 1
 +
 +-- ... or..
 +userName : User -> String
 +userName user =
 +let
 +(User name) = user
 +in
 +String.toLower name
 +
 +-- ... or... 
 +type alias Vector = { x : Int, y : Int }
 +length : Vector -> Float
 +length { x, y } = sqrt <| toFloat <| x^2 + y^2
 +length { x = 1, y = 2 } -- Result: 2.2360
 +length { x = 1, y = 2, z = 3 } -- Error
 +-- To do this:
 +length : { r | x : Int, y : Int } -> Float
 +length { x, y } = sqrt <| toFloat <| x^2 + y^2
 +length { x = 1, y = 2, z = 3 } -- OK
 +-- or
 +type alias Vector r = { r | x : Int, y : Int }
 +length : Vector r -> Float
 +length { x, y } = sqrt <| toFloat <| x^2 + y^2
 +</​code>​
 +
 +==== Pattern matching ====
 +Pattern matching is a mechanism for choosing the branch of code to execute based on the type or value of a given expression.
 +
 +==== Functors, monads and applicatives ====
 +
 +  * Functors are things you can map on
 +  * Monads things you can andThen on 
 +  * Applicatives things you can andMap on
 ===== Basic ===== ===== Basic =====
  
Línea 115: Línea 160:
 </​code>​ </​code>​
  
 +=== Constructing records from another === 
 +<​code>​ 
 +> type alias A = { a: String, b: Int } 
 +> type alias B = { a: String, b: Int } 
 +> a : A 
 +| a = A "​prueba"​ 666 
 +{ a = "​prueba",​ b = 666 } : A 
 +> b : B 
 +| b = a 
 +{ a = "​prueba",​ b = 666 } : B 
 +</​code>​
 ==== Type annotation ==== ==== Type annotation ====
  
Línea 190: Línea 245:
 Visitor "​kate95"​ Visitor "​kate95"​
 -- Visitor "​kate95"​ : User -- Visitor "​kate95"​ : User
 +</​code>​
 +
 +=== Types variable ===
 +
 +When you do not care about the type that is passed. In the next example the ''​List''​ passed to ''​List.length''​ can be a ''​List String'',​ ''​List Int''​...
 +<​code>​
 +> List.length
 +<​function>​ : List a -> Int
 +</​code>​
 +
 +However it can restrict the output. With ''​List.reverse''​ we know that we are going to obtain a ''​List''​ with the same type as it was passed on the first instance.
 +<​code>​
 +> List.reverse
 +<​function>​ : List a -> List a
 +> List.reverse [ "​a",​ "​b",​ "​c"​ ]
 +["​c","​b","​a"​] : List String
 +> List.reverse [ True, False ]
 +[False,​True] : List Bool
 </​code>​ </​code>​
  
Línea 236: Línea 309:
 s = showKm distance -- this raises an error s = showKm distance -- this raises an error
 </​code>​ </​code>​
 +
 +Use cases:
 +  * When you want to distinguish between values which have the same runtime representation,​ and you have a shared set of operations you want to perform on all the different types of these values.
 +  * "hen you want to use a particular runtime representation for reasons of performance or memory use, but still want compile-time enforcement of the semantics of different types.
 +
  
 ==== Type Aliases ==== ==== Type Aliases ====
wiki2/elm.1589049897.txt.gz · Última modificación: 2020/05/09 19:44 (editor externo)