<div dir="ltr">at the risk of contributing to this bike shedding discussion, I&#39;d like to chime in:<div><br></div><div style>Lets not break compose. </div><div style><br></div><div style>Also: why not something nearly as simple that ISN&#39;T used already, eg (.$) operator or something? (.) has enough overloading of what it can mean already!  Now we have that (.) means 3 *completely* different things when we do &quot;A.f&quot; ,  &quot;A . f&quot; , and  &quot;a.f&quot; !  So we have an unprincipled conflation of *different* syntactic and semantic things, and no deep reason for this aside from &quot;cause its what everyone else does&quot;. </div>

<div style><br></div><div style>Also unaddressed is how error messages for type and syntax will need to be changed to handle any ambiguities that arise! Such engineering is beyond the scope of whats feasible in a single summer I think... would it not be better to choose an operator that *does not* create a potential conflation with extant standard infix operators and qualified names?</div>

<div style><br></div><div style>Consider a strawman of (.$), which also doesn&#39;t not result in any syntactic ambiguity, AND reuses familiar notational conventions of &quot;compose apply&quot; AND resembles the conventional field accessor, AND to the best of my knowledge isn&#39;t used in any current major libraries on hackage. (a quick search with hayoo/holumbus indicates only one package on hackage, that hasn&#39;t been touched in 5+ years has that infix operation) </div>

<div style><br></div><div style>Lets just give the darn field application its own function! &quot;$&quot; reads as apply, why not &quot;.$&quot; for &quot;field apply&quot;?  Lets just make this </div><div style>a first class operation that has highest precedence! </div>

<div style><br></div><div style>eg </div><div style>(.$):: <span style="color:rgb(80,0,80);font-family:arial,sans-serif;font-size:13px"> </span><span style="color:rgb(80,0,80);font-family:arial,sans-serif;font-size:13px"> r -&gt;(</span><span style="color:rgb(80,0,80);font-family:arial,sans-serif;font-size:13px">r { fieldName ::b } =&gt; </span><span style="color:rgb(80,0,80);font-family:arial,sans-serif;font-size:13px">r-&gt;b)-&gt;b</span></div>

<div style><span style="color:rgb(80,0,80);font-family:arial,sans-serif;font-size:13px">(.$) rec fun = --- stuff here</span></div><div style><br></div><div style>Summary:</div><div style>Lets not make a wide spread syntactic element MORE Confusing. Please. Also as explained by others, it will break Lens which is now a *very* widely used library by many in the community. Theres no good reason. At all. </div>

<div style><br></div><div style>I welcome an explanation that motivates the . dot syntax and all the extra ghc flag hoops people are bikeshedding around that are necessitated by the syntactic tomfoolery, but I can not imagine any good reason aside from people&#39;s feelings and the inertia of opinions already developed.</div>

<div style><br></div><div style><br></div><div style>cheers, either way, i&#39;m excited about the prospect of making it easier to write Symbol Singletons more easily as a result of the more *important* elements of this work.</div>

<div style><br></div><div style>-Carter</div><div style><br></div><div style><br></div></div><div class="gmail_extra"><br><br><div class="gmail_quote">On Fri, Jun 28, 2013 at 11:48 AM, Dominique Devriese <span dir="ltr">&lt;<a href="mailto:dominique.devriese@cs.kuleuven.be" target="_blank">dominique.devriese@cs.kuleuven.be</a>&gt;</span> wrote:<br>

<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Simon,<br>
<br>
I see your point.  Essentially, the original proposal keeps the<br>
namespace for field names syntactically distinguishable from that of<br>
functions, so that the type given to &quot;r.foo&quot; doesn&#39;t depend on what is<br>
in scope.  (.foo) is always defined and it is always a function of<br>
type &quot;(r { foo::t }) =&gt; r -&gt; t&quot;. With the &quot;orthogonal proposal&quot;, it<br>
would only be defined if there is a record with a foo field in scope,<br>
although its definition or type does not actually depend on the<br>
record.   One would then need to define an Unused record with a field<br>
foo, or declare the following<br>
  foo :: r { foo ::t} =&gt; r -&gt; t<br>
  foo = getFld<br>
to essentially declare that foo should be treated as a field selector<br>
and I&#39;m not even sure if type inference would work for this<br>
definition... Maybe we could provide syntax like a declaration &quot;field<br>
foo;&quot; as equivalent to the latter, but I have to acknowledge that this<br>
is a downside for the &quot;orthogonal proposal&quot;.<br>
<br>
Regards,<br>
Dominique<br>
<br>
2013/6/28 Simon Peyton-Jones &lt;<a href="mailto:simonpj@microsoft.com">simonpj@microsoft.com</a>&gt;:<br>
<div class="HOEnZb"><div class="h5">&gt; | Folks, I&#39;m keenly aware that GSoC has a limited timespan; and that there<br>
&gt; | has already been much heat generated on the records debate.<br>
&gt;<br>
&gt; I am also keenly aware of this.  I think the plan Ant outlines below makes sense; I&#39;ll work on it with Adam.<br>
&gt;<br>
&gt; I have, however, realised why I liked the dot idea.  Consider<br>
&gt;<br>
&gt;         f r b = r.foo &amp;&amp; b<br>
&gt;<br>
&gt; With dot-notation baked in (non-orthogonally), f would get the type<br>
&gt;<br>
&gt;         f :: (r { foo::Bool }) =&gt; r -&gt; Bool -&gt; Bool<br>
&gt;<br>
&gt; With the orthogonal proposal, f is equivalent to<br>
&gt;         f r b = foo r &amp;&amp; b<br>
&gt;<br>
&gt; Now it depends.<br>
&gt;<br>
&gt; * If there is at least one record in scope with a field &quot;foo&quot;<br>
&gt;   and no other foo&#39;s, then you get the above type<br>
&gt;<br>
&gt; * If there are no records in scope with field &quot;foo&quot;<br>
&gt;   and no other foo&#39;s, the program is rejected<br>
&gt;<br>
&gt; * If there are no records in scope with field &quot;foo&quot;<br>
&gt;   but there is a function &quot;foo&quot;, then the usual thing happens.<br>
&gt;<br>
&gt; This raises the funny possibility that you might have to define a local type<br>
&gt;         data Unused = U { foo :: Int }<br>
&gt; simply so that there *is* at least on &quot;foo&quot; field in scope.<br>
&gt;<br>
&gt; I wanted to jot this point down, but I think it&#39;s a lesser evil than falling into the dot-notation swamp.  After all, it must be vanishingly rare to write a function manipulating &quot;foo&quot; fields when there are no such records around. It&#39;s just a point to note (NB Adam: design document).<br>


&gt;<br>
&gt; Simon<br>
&gt;<br>
&gt; | -----Original Message-----<br>
&gt; | From: <a href="mailto:glasgow-haskell-users-bounces@haskell.org">glasgow-haskell-users-bounces@haskell.org</a> [mailto:<a href="mailto:glasgow-haskell-">glasgow-haskell-</a><br>
&gt; | <a href="mailto:users-bounces@haskell.org">users-bounces@haskell.org</a>] On Behalf Of AntC<br>
&gt; | Sent: 27 June 2013 13:37<br>
&gt; | To: <a href="mailto:glasgow-haskell-users@haskell.org">glasgow-haskell-users@haskell.org</a><br>
&gt; | Subject: Re: Overloaded record fields<br>
&gt; |<br>
&gt; | &gt;<br>
&gt; | &gt; ... the orthogonality is also an important benefit.<br>
&gt; | &gt;  It could allow people like Edward and others who dislike ...<br>
&gt; | &gt;  to still use ...<br>
&gt; | &gt;<br>
&gt; |<br>
&gt; | Folks, I&#39;m keenly aware that GSoC has a limited timespan; and that there<br>
&gt; | has already been much heat generated on the records debate.<br>
&gt; |<br>
&gt; | Perhaps we could concentrate on giving Adam a &#39;plan of attack&#39;, and help<br>
&gt; | resolving any difficulties he runs into. I suggest:<br>
&gt; |<br>
&gt; | 1. We postpone trying to use postfix dot:<br>
&gt; |    It&#39;s controversial.<br>
&gt; |    The syntax looks weird whichever way you cut it.<br>
&gt; |    It&#39;s sugar, whereas we&#39;d rather get going on functionality.<br>
&gt; |    (This does mean I&#39;m suggesting &#39;parking&#39; Adam&#39;s/Simon&#39;s syntax, too.)<br>
&gt; |<br>
&gt; | 2. Implement class Has with method getFld, as per Plan.<br>
&gt; |<br>
&gt; | 3. Implement the Record field constraints new syntax, per Plan.<br>
&gt; |<br>
&gt; | 4. Implicitly generate Has instances for record decls, per Plan.<br>
&gt; |    Including generating for imported records,<br>
&gt; |    even if they weren&#39;t declared with the extension.<br>
&gt; |    (Option (2) on-the-fly.)<br>
&gt; |<br>
&gt; | 5. Implement Record update, per Plan.<br>
&gt; |<br>
&gt; | 6. Support an extension to suppress generating field selector functions.<br>
&gt; |    This frees the namespace.<br>
&gt; |    (This is -XNoMonoRecordFields in the Plan,<br>
&gt; |     but Simon M said he didn&#39;t like the &#39;Mono&#39; in that name.)<br>
&gt; |    Then lenses could do stuff (via TH?) with the name.<br>
&gt; |<br>
&gt; |    [Those who&#39;ve followed so far, will notice that<br>
&gt; |     I&#39;ve not yet offered a way to select fields.<br>
&gt; |     Except with explicit getFld method.<br>
&gt; |     So this &#39;extension&#39; is actually &#39;do nothing&#39;.]<br>
&gt; |<br>
&gt; | 7. Implement -XPolyRecordFields, not quite per Plan.<br>
&gt; |    This generates a poly-record field selector function:<br>
&gt; |<br>
&gt; |        x :: r {x :: t} =&gt; r -&gt; t    -- Has r &quot;x&quot; t =&gt; ...<br>
&gt; |        x = getFld<br>
&gt; |<br>
&gt; |     And means that H98 syntax still works:<br>
&gt; |<br>
&gt; |        x e     -- we must know e&#39;s type to pick which instance<br>
&gt; |<br>
&gt; |     But note that it must generate only one definition<br>
&gt; |     for the whole module, even if x is declared in multiple data types.<br>
&gt; |     (Or in both a declared and an imported.)<br>
&gt; |<br>
&gt; |     But not per the Plan:<br>
&gt; |     Do _not_ export the generated field selector functions.<br>
&gt; |     (If an importing module wants field selectors,<br>
&gt; |      it must set the extension, and generate them for imported data<br>
&gt; | types.<br>
&gt; |      Otherwise we risk name clash on the import.<br>
&gt; |      This effectively blocks H98-style modules<br>
&gt; |      from using the &#39;new&#39; record selectors, I fear.)<br>
&gt; |     Or perhaps I mean that the importing module could choose<br>
&gt; |     whether to bring in the field selector function??<br>
&gt; |     Or perhaps we export/import-control the selector function<br>
&gt; |     separately to the record and field name???<br>
&gt; |<br>
&gt; |     Taking 6. and 7. together means that for the same record decl:<br>
&gt; |     * one importing module could access it as a lens<br>
&gt; |     * another could use field selector functions<br>
&gt; |<br>
&gt; | 8. (If GSoC hasn&#39;t expired yet!)<br>
&gt; |    Implement -XDotPostfixFuncApply as an orthogonal extension ;-).<br>
&gt; |<br>
&gt; | AntC<br>
&gt; |<br>
&gt; |<br>
&gt; |<br>
&gt; |<br>
&gt; | _______________________________________________<br>
&gt; | Glasgow-haskell-users mailing list<br>
&gt; | <a href="mailto:Glasgow-haskell-users@haskell.org">Glasgow-haskell-users@haskell.org</a><br>
&gt; | <a href="http://www.haskell.org/mailman/listinfo/glasgow-haskell-users" target="_blank">http://www.haskell.org/mailman/listinfo/glasgow-haskell-users</a><br>
&gt; _______________________________________________<br>
&gt; Glasgow-haskell-users mailing list<br>
&gt; <a href="mailto:Glasgow-haskell-users@haskell.org">Glasgow-haskell-users@haskell.org</a><br>
&gt; <a href="http://www.haskell.org/mailman/listinfo/glasgow-haskell-users" target="_blank">http://www.haskell.org/mailman/listinfo/glasgow-haskell-users</a><br>
<br>
_______________________________________________<br>
Glasgow-haskell-users mailing list<br>
<a href="mailto:Glasgow-haskell-users@haskell.org">Glasgow-haskell-users@haskell.org</a><br>
<a href="http://www.haskell.org/mailman/listinfo/glasgow-haskell-users" target="_blank">http://www.haskell.org/mailman/listinfo/glasgow-haskell-users</a><br>
</div></div></blockquote></div><br></div>