Diferencias

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

--- wiki2:elm [2020/05/09 11:10]
root [Types]
+++ wiki2:elm [2020/05/16 11:53] (actual)
@@ Línea 86: / Línea 86: @@
 "aaaaaaaaaaaaaaaaaaaa"
 </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 =====
@@ Línea 115: / Línea 160: @@
 </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 ====
@@ Línea 190: / Línea 245: @@
 Visitor "kate95"
 -- 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>
@@ Línea 212: / Línea 285: @@
 However, the input and output types are not necessarily the same, so it doesn’t make sense to write ''(comparable -> comparable)''.  In order to allow these sorts of functions, number, appendable and comparable can be suffixed with an alphanumeric sequence without changing their meaning.
+=== Phantom types ===
+Those types that contain variables that are not used on their constructors:
+<code>
+type Unit tag value = Unit value
+</code>
+It can be used like this:
+<code>
+type KmTag = KmTag
+type MileTag = MileTag
+km : number -> Unit KmTag number
+km = Unit
+mile : number -> Unit MileTag number
+mile = Unit
+</code>
+These types use different tags. Now we can restrict value types; for example, when a function expects a KmTag and we pass a mile to it, then an error will raise.
+<code>
+showKm : Unit KmTag Float -> String
+showKm (Unit d) = String.fromFloat d
+distance = mile 12.34
+s = showKm distance -- this raises an error
+</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 ====

Programming

Herramientas de usuario

Herramientas del sitio

Diferencias

Herramientas de la página