<div dir="ltr">The backtracking approach would be useful. It would be nice to say:<br><br>instance (A t) => C t where ...<div><br></div><div>instance (B t) => C t where ...<br><br>in the case where you can define a C instance if you've already got a B instance or an A instance. Indeed (aside from efficiency) you don't really care which one. <br><br>Yes, this means if someone else defines and instance of A somewhere else in the program then suddenly you're silently calling a different instance. Indeed you could be using different instances in different parts of the program. But as long as they have the same effect that shouldn't be an issue. If they have different effects it's likely one is wrong anyway. <br><br>For (perhaps a silly) example:<br><br>class DrawRhombus drawerT where</div><div>  drawRhombus :: drawerT -> Sidelength -> Angle -> Shape<br><br><div>class DrawRectangle drawerT where</div><div>  drawRectangle :: drawerT -> Sidelength -> Sidelength -> Shape<br><br>class DrawSquare t where<br>  drawSquare :: drawerT -> Sidelength -> Shape<br><br>instance (DrawRhombus drawerT) => DrawSquare drawerT where<br>  drawSquare d l = drawRhombus d l (Angle 0)<br><br>instance (DrawRectangle drawerT) => DrawSquare drawerT where<br>  drawSquare d l = drawRectangle d l l<br><br></div></div></div><div class="gmail_extra"><br><div class="gmail_quote">On Thu, Feb 18, 2016 at 9:21 AM, David Feuer <span dir="ltr"><<a href="mailto:david.feuer@gmail.com" target="_blank">david.feuer@gmail.com</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><p dir="ltr">I was thinking about ~two notions of "closed class" yesterday, and I'm curious if anyone's done any work on either concept. In each case, the class definition is followed by *all* of its instances, and the instances are checked *in order* (rather than based on specificity and OVERLAPS/OVERLAPPABLE pragmas).</p>
<p dir="ltr">No backtracking:</p>
<p dir="ltr">If the instance head matches, GHC commits to it. Associated types are treated as closed type families, and would work just the same (I don't think any significant extension to the closed type family mechanism would be required). This seems to make a very nice parallel to the usual open classes with open associated types. And it lets you combine overlapping instances with associated types without (I believe) risking type safety.</p>
<p dir="ltr">Backtracking:</p>
<p dir="ltr">GHC does not commit to the instance until it has satisfied the instance constraints. This lets instance writers offer multiple alternative instance constraints. Associated types would be a good bit trickier. One option would be to require all instances with the same head to share a type/data instance. The other (much more invasive) option would be to allow the instance chosen to guide the type selection, which would push the backtracking into the type checker.</p>
<br>_______________________________________________<br>
Haskell-Cafe mailing list<br>
<a href="mailto:Haskell-Cafe@haskell.org">Haskell-Cafe@haskell.org</a><br>
<a href="http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe" rel="noreferrer" target="_blank">http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe</a><br>
<br></blockquote></div><br></div>