(p \/ q) :- r given p :- r and q :- r

But because of the thinness of the category, the ‘r’ dictionary that results will be the same result given either path.

e.g. (Ord [a]\/ Eq a) :- Eq [[[a]]]

would let you produce Eq [[[a]]] given either Eq a or an Ord [a]

Giving you the ability to do true general ‘Either’ constraints would compromise the thinness of the category and the safety of global instance resolution. (Mind you, incoherent instances also do that.)

]]>{-# LANGUAGE RankNTypes, PolyKinds, TupleSections, TypeFamilies, TypeFamilyDependencies #-}

import Data.Kind (Type)

type LensFamily (outer :: t -> Type) (inner :: t -> Type) =

forall a b f. Functor f => (inner a -> f (inner b)) -> (outer a -> f (outer b))

type family Snd b a :: Type where

Snd b a = (a, b)

type family Fst a b :: Type where

Fst a b = (a, b)

type family Id t = r | r -> t where

Id x = x

fstLens :: LensFamily (Snd b) Id

fstLens f (a, b) = (, b) f a

sndLens :: LensFamily (Fst a) Id

sndLens f (a, b) = (a, ) f b

To borrow Haskell notation:

None =>> f = None

l : r =>> f = ???

x =>> f = Single $ f x

I seem to have hit a BST branch without a root node; is there any way to implement `Extend` for the `:` case? The best attempt I’ve made leads to `(l =>> f) : (r =>> f)`, but this seems to be “skipping” a step.

]]>[...] What web host are you the usage of? Can I get affiliate hyperlink in your host? I wish web site loaded up as quickly as yours lol[...]…

]]>[...]I am now not sure where you are getting your info, however good topic.[...]…

]]>See the best click the next website currently now in stock and reasonably priced today!…

]]>Click here for the best facility construction currently available anywhere and reasonably priced….

]]>