Changes between Initial Version and Version 1 of Language/Overview/FieldProjections

Timestamp:

06/17/10 02:13:14 (3 years ago)

Author:

benl (IP: 129.94.242.38)

Comment:

--

Language/Overview/FieldProjections

@@ +1 @@
+= Field Projections =
+[http://trac.haskell.org/ddc/wiki/Language/Overview < Overview]
+
+When data types are defined using field names, we can use the projection operator `(.)` to select the fields.
+
+{{{
+data Vector
+         = Vector { x :: Float; y :: Float; }
+
+main ()
+ = do   vec = Vector 3.0 4.0
+        putStrLn $ show vec.x          -- prints '3.0'
+        putStrLn $ show vec.y          -- prints '4.0'
+}}}
+
+== Custom projections ==
+We can also define our own, custom projections and use `(.)` to select them. A `project` definition is similar to Haskell style `instance` definition in that it defines a set of functions associated with a particular type (in this case, `Vector`). When we use `(.)`, its first argument is passed as the first argument to our projection function - and so on.
+
+{{{
+project Vector where
+        magnitude :: Vector -> Float
+        magnitude (Vector x y) 
+         = sqrt (x * x + y * y)
+
+        dot :: Vector -> Vector -> Float
+        dot (Vector x1 y1) (Vector x2 y2)
+         = x1 * x2 + y1 * y2
+
+main ()
+ = do   ...
+        putStrLn $ show vec.magnitude               -- prints '5.0'
+        putStrLn vec.dot (Vector 5.0 6.0)    -- prints '39.0'
+}}}
+
+== Projections are type directed ==
+In Disciple we can re-use the same field names in multiple data types, each with different field types. The type system uses the type of the first argument of `(.)` to determine what projection function to use. Alternatively, we can use the `(&)` operator to specify the projection type manually.
+
+{{{
+data Location 
+        = Location { x :: String; y :: String; }
+
+main ()
+ = do   ...
+        loc = Location "over" "there"
+        putStr $ show loc.x                      -- prints 'over'
+
+        putStr $ show $ magnitude&{Vector} vec   -- prints '5.0'
+}}}
+
+Using `(&)`, we can also define "projection" functions who's first argument is not of the projection type.
+
+{{{
+project Vector where
+        ...
+        new :: Float -> Float -> Vector
+        new posX posY = Vector posX posY
+
+main ()
+ = do   ...
+        vec2  = new&{Vector} 5.0 6.0
+        ...
+}}}
+
+== Ambiguous projections ==
+As Disciple uses the type of the first argument of `(.)` to decide what projection to use, it needs to be constrained to a data type (not just a type variable). Usually a top level type signature is enough.
+
+Compilation of this function:
+{{{
+getX thing = thing.x
+}}}
+
+will fail with
+{{{
+    ./Main.ds: ...
+        Ambiguous projection: .x
+}}}
+
+as there is no way of knowing what version of `.x` to use, are we talking about the `.x` from `Vector` or `Location`?
+
+Providing a type signature adds the required constraint.
+
+{{{
+getx :: Vector -> Float
+getX thing = thing.x
+}}}