Constraint implication

[David Feuer]

For whatever it's worth, it seems to me that the two next steps, in no
particular order, should likely be

1. Add quantified contexts. These should obsolete Data.Constraint.Forall by
offering a much nicer API (without needing to use `inst`, etc., manually).

2. Add the ability to at least express constraint implication at the
constraint level, and propagate some of that information automatically.
Trying to be too clever seems to run into backtracking, so it's not clear
that we should try to jump straight to a full constraint implication
system. If we could even get a version that requires manual guidance to use
(like Data.Constraint.Forall does today), we'd surely be making some
progress.

On Jan 2, 2018 5:08 AM, "Simon Peyton Jones via Libraries" <
libraries at haskell.org> wrote:

> Getting this stuff into GHC is the tricky part!
>
> Indeed… but step 1 is to articulate a well-formed specification.  I’m not
> close enough to this conversation to understand all the details, let alone
> form a specification.  But perhaps some of you are.
>
>
>
> I think (2) is described here: https://ghc.haskell.org/trac/
> ghc/wiki/QuantifiedContexts.  I have been keen on this proposal for
> years, just lacking time to execute on it.
>
>
>
> Simon
>
>
>
> *From:* Libraries [mailto:libraries-bounces at haskell.org] *On Behalf Of *Edward
> Kmett
> *Sent:* 27 December 2017 19:18
> *To:* Ryan Reich <ryan.reich at gmail.com>
> *Cc:* Haskell Libraries <libraries at haskell.org>
> *Subject:* Re: Constraint implication
>
>
>
> Just a few old observations I've made from implementing these things into
> type systems of my own:
>
>
>
> 1.) An internal hom for the category of constraints is admissible:
>
>
>
> (|-) :: Constraint -> Constraint -> Constraint
>
>
>
> models entailment, and effectively brings into scope a local rule, but
> global instance resolution isn't lost if this is only produced from
> existing instances.
>
>
>
> To your point, this is analogous to the (:-) :: Constraint -> Constraint
> -> * external hom for the category of constraints provided by my
> constraints package, but it is internal, with all of the appropriate CCC
> operations.
>
>
>
> 2.) Quantification over constraints is also admissible.
>
>
>
> Neither one compromises the "thinness" of the category of constraints that
> provides us global coherence of instance resolution
>
>
>
> In this case the property that if D is thin, so is [C,D]. forall here can
> quantify over any other kind you want.
>
>
>
> Unfortunately, neither implemented in Haskell.
>
>
>
> You'd need both of them to be able to talk about constraints like (forall
> a. Eq a |- Eq (f a)).
>
>
>
> Together could eliminate, morally, the entire Data.Functor.Classes mess.
> (That said, as implemented those classes are a bit stronger than the
> quantified form)
>
>
>
> 3.) Constraint also admits a sum type, (\/) but it acts more like a least
> upper bound than an either.
>
>
>
> It is much easier to talk about in the category of constraints using the
> first part above.
>
>
>
> Given (p |- r, q |- r), (p \/ q) |- r and vice versa.
>
>
>
> The key to keeping the category of constraints thin is that you can't case
> analyze on it, its more like if you look at, say, Ord [a] \/ Eq a you can
> get to any constraint that you could get to given the intersection of both,
> not using the particulars of either. e.g. its morally as powerful as Eq [a]
> in this case.
>
>
>
> Getting this stuff into GHC is the tricky part!
>
>
>
> -Edward
>
>
>
> On Wed, Dec 27, 2017 at 2:50 AM, Ryan Reich <ryan.reich at gmail.com> wrote:
>
> The Constraint kind appears to lack an interface to an important
> capability that is already part of the type checker: constraint
> implication.  Namely, the ability to provide a witness for the statement
> "constraint c1 implies constraint c2" or, more importantly, "for all a,
> constraint (c1 a) implies constraint (c2 a)", where c1 and c2 are now
> constraint-valued type functions (and possibly even for constraint
> functions with multiple parameters).  It seems to me that this can follow
> the pattern of the "magic" Coercible type class and the (non-magic)
> Coercion data type; it provides the programmer with an analogous value to
> this example that can be obtained in apparently no other way.
>
>
> _______________________________________________
> Libraries mailing list
> Libraries at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries
> <https://na01.safelinks.protection.outlook.com/?url=http%3A%2F%2Fmail.haskell.org%2Fcgi-bin%2Fmailman%2Flistinfo%2Flibraries&data=04%7C01%7Csimonpj%40microsoft.com%7C8f41822fa9ff4b253ea808d54d5e9adc%7C72f988bf86f141af91ab2d7cd011db47%7C1%7C0%7C636499991092450873%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwifQ%3D%3D%7C-1&sdata=QquaudC3jd%2FHr33l6N3e0OCRRK8%2F2qhYX7p5m3uSyAc%3D&reserved=0>
>
>
>
> _______________________________________________
> Libraries mailing list
> Libraries at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/libraries
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/libraries/attachments/20180102/77b24ec9/attachment-0001.html>