Changes between Version 22 and Version 23 of Records/DeclaredOverloadedRecordFields

Timestamp:

03/07/12 23:43:58 (15 months ago)

Author:

AntC

Comment:

--

Records/DeclaredOverloadedRecordFields

@@ -6 +6 @@
  * Many record types can be declared in the same module to share the field name.
  * The field name can be exported so that records in other modules can share it.
+
 The export/import is under usual H98 namespace and module/qualification control, so that when exporting a record type:
  * Some fields can be both read and updated;
@@ -11 +12 @@
  * Some can be completely hidden.
 
-This proposal introduces several new elements of syntax, all of which desugar to use well-established extensions to ghc. The approach has been proptotyped in ghc v 7.2.1. In particular:
+This proposal introduces several new elements of syntax, all of which desugar to use well-established extensions to ghc. The approach has been prototyped in ghc v 7.2.1. In particular:
  * The field name overloading is implemented through usual class and instance mechanisms.
  * Field selectors are ordinary functions named for the field (but overloaded rather than H98's monomorphic), so field selection is regular function application.
@@ -17 +18 @@
 === Implementation: the `Has` class, and methods `get` and `set` ===
 
-Record declarations, instead of generating a (monomorphic) selector function named for the field, generate a `Has` instance for each record type/field combination. A data declaration, its `Has` instance, and examples of use:
-{{{
-    data Customer = Cust{ customer_id :: Int, ... }
-    instance (t ~ Int) => Has Customer Proxy_customer_id t        where
+Record declarations generate a `Has` instance for each record type/field combination. Example declaration, its `Has` instance, and examples of use:
+{{{
+    data Customer = Cust{ customer_id :: Int, ... }                     -- declaration syntax same as H98
+    instance (t ~ Int) => Has Customer Proxy_customer_id t        where -- Has instance generated
         get Cust{ customer_id } _ = customer_id                         -- DisambiguateRecordFields style
         set _ x Cust{ .. }        = Cust{ customer_id = x, .. }         -- RecordWildCards and NamedFieldPuns
 
-    myCust :: Customer
+    myCust :: Customer                                                  -- example record decl
+    ... myCust{ customer_id = 27 }                                      -- polymorphic record update
     ... (customer_id myCust) ...                                        -- field selection is func apply
-    ... myCust{ customer_id = 27 }                                      -- polymorphic record update
-}}}
-
-Note that the mechanism uses a Proxy as the type 'peg' for a field (this is the wildcard argument to `get` and `set`):
+    ... myCust.customer_id ...                                          -- dot notation is sugar for reverse func apply
+}}}
+
+Note that the''' `Has` mechanism''' uses a Proxy as the type 'peg' for a field (this is the wildcard argument to `get` and `set`):
  * The Proxy must be declared once, and is then under regular name control.
  * The field selector function also must be declared once, using the Proxy.
 
 {{{
+    -- fieldLabel customer_id :: r -> Int                               -- new declaration, desugars to Proxy and func
     data Proxy_customer_id                                              -- phantom
-    customer_id :: r{ customer_id :: Int }
+    customer_id :: r{ customer_id :: Int } => r -> Int                  -- r{ ... } is sugar for Has constraint
     customer_id r = get r (undefined :: Proxy_customer_id)
 
-    set Proxy_customer_id 27 myCust
-}}}
- * The field selector function is an (overloaded) call to the `get` function, it's type is a function from a record to 
-
-
-
+    set (undefined :: Proxy_customer_id) 27 myCust                      -- record update desugarred from above
+}}}
+
+'''Virtual''' or '''pseudo-''' fields are easy to create, because field selection is merely function application. Virtual fields can be applied like ordinary fields (but can't be updated, because there is no `Has` instance):
+{{{
+    fullName r = r.firstName ++ " " ++ map toUpper r.lastName           -- example addapted from SPJ
+                                                                        -- note dot notation binds tighter than func apply
+    fullName :: r{ firstName :: String, lastName :: String} => r -> String     -- type inferred for fullName
+}}}
+
+(Note the `Has` constraints for fullName using elided syntax.)
+
+
+== DORF Full motivation and examples ==
 
 Explained in 5 wiki pages (these proposals are linked but somewhat orthogonal):