Row Types for Type Classes

Row_types.markdown

Type classes in terms of row types

type Semigroup s = { Monoid s with mappend :: s -> s -> s | _ }

type Pointed f = { Applicative f with pure  :: forall a. a -> f a | _ }
type Apply   f = { Applicative f with (<*>) :: forall a b. f (a -> b) -> f a -> f b | _ }
type Bind    m = { Monad       m with (>>=) :: forall a b. m a -> (a -> m b) -> m b | _ }

https://youtu.be/YTaNkWjd-ac?t=3604 Edward wants to split MonadReader and MonadWriter up into algebraic (ask + tell) and non-algebraic.. Edward describes a painful change he's putting off, this on the other hand is fine

type AlgMonadReader r m = { MonadReader r m with ask :: m r | _ }

type AlgMonadWriter w m = { MonadWriter r m with tell :: w -> m () | _ }

Here is a PureScript ticket created by Kmett (purescript/purescript-transformers#63) that proposes this

More info: http://comonad.com/reader/2011/monads-from-comonads/

Sadly this breaks down a little for Writer and Reader as the mtl unfortunately has historically included a bunch of extra baggage in these classes. In particular, in reader, the notion of local isn't always available, blocking some otherwise perfectly good MonadReader instances, and I've chosen not to repeat this mistake in comonad-transformers.

http://openaccess.city.ac.uk/1141/1/Constructors.pdf

data FoldL b a = FoldL (a -> b -> a) a

Although FoldL is not a functor, it nevertheless has operations similar to unit and mult. These can be described using a type class similar to Monoidal, but without the Functor superclass:

class Zip z where 
  zunit :: z ()
  zmult :: z a -> z b -> z (a, b)

consider removing super classes

Type Inference for GADTs and Anti-unification

(==) :: forall a. {(==) : a -> a -> Bool}. a -> a -> Bool

https://twitter.com/nomeata/status/979823045471866881

I believe this could be solved the same way

This is an interesting idea, several ways of expressing this: what is the relationship between Arbitrary and EquivArbitrary

class EquivArbitrary a where
  arbitraryFrom :: Gen (Gen a)
  default
   arbitraryFrom :: Arbitrary a => Gen (Gen a)
  arbitraryFrom = pure arbitrary

class EquivArbitrary a => Arbitrary a where
  arbitrary :: Gen a
  arbitrary = join arbitraryFrom

class Arbitrary a where
  {-# Minimal arbitrary | arbitraryFrom #-}
  arbitrary :: Gen a
  arbitrary = join arbitraryFrom

  arbitraryFrom :: Gen (Gen a)
  arbitraryFrom = pure arbitrary

type NoMult a = Num a - (*) https://twitter.com/bitemyapp/status/986115468133052417

System CT https://ac.els-cdn.com/S1571066105804554/1-s2.0-S1571066105804554-main.pdf?_tid=bbd12dcf-7585-4054-99a5-b65414a04ad4&acdnat=1552447164_798983bc9e0b2f9ac1f6050223781552