Icelandjack

Interesting https://www.reddit.com/r/haskell/comments/1u8rp1/with_two_different_functors/

Description of monoidal natural transformations https://gist.github.com/Icelandjack/9e6902690a244286843164e554a8c3db

https://github.com/phadej/metametapost/tree/34eb0d757655d15317d58f549e9cf4c794cff79e/src/MetaMetaPost

https://github.com/phadej/metametapost/blob/34eb0d757655d15317d58f549e9cf4c794cff79e/src/MetaMetaPost/Simplifier.hs

simplify :: Expr SomePrim (Type s) a -> Either String (MP s a)
simplify (Var a)                = pure (MPApp (MPVar a))
simplify (Prim (SomePrim p))    = simplifyPrim0 p
simplify (Lam _ _)              = throwError "Non-applied lambda abstraction"

Free category is ubiquitous

https://github.com/kylcarte/derivation/blob/21776455a80c57db14276a6477486fc78cf9018f/src/Data/Evaluation.hs#L26

http://www.cs.ox.ac.uk/people/bob.coecke/AbrNikos.pdf

Why study categories—what are they good for? We can offer a range of answers for readers coming from different backgrounds:

For mathematicians: category theory organises your previous mathematical experience in a new and powerful way, revealing new connections and structure, and allows you to “think bigger thoughts”.
For computer scientists: category theory gives a precise handle on important notions such as compositionality, abstraction, representationindependence, genericity and more. Otherwise put, it provides the fundamental mathematical structures underpinning many key programming concepts.
For logicians: category theory gives a syntax-independent view of the fundamental structures of logic, and opens up new kinds of models and interpretations.
For philosophers: category theory opens up a fresh approach to structuralist foundations of mathematics and science; and an alternative to the traditional focus on set theory
For **p

Motivating examples for https://ghc.haskell.org/trac/ghc/ticket/10843, https://ghc.haskell.org/trac/ghc/wiki/ArgumentDo

This should allow

curry $ \case

without the dollar giving us weird code

To allow hask

type Cat k = k -> k -> Type

type Fun i j = i -> j

data Nat :: Cat i -> Cat j -> Cat (Fun i j) where
  Nat :: (FunctorOf cat cat' f, FunctorOf cat cat' f') => (forall a. Ob cat a => cat' (f a) (f' a)) -> Cat cat cat' f f'

https://www.reddit.com/r/haskell/comments/6i7nil/kinderfunctor_using_typeintype_with_a_polykinded/

Getting `Num`, `Floating`, `Fractional` from `Applicative`

newtype WrappedApplicative f a = WrapApplicative (f a)
  deriving 
    (Functor, Show)
  deriving newtype 
    Applicative

instance (Applicative f, Num a) => Num (WrappedApplicative f a) where

Reddit discusson thread.

I made a way to get more free stuff and free stuff is good.

The current implementation of deriveVia is here, it works with all the examples here. Needs GHC 8.2 and th-desugar.

It doesn't take long

for new Haskellers to get pampered by their compiler. For the price of a line or two the compiler offers to do your job, to write uninteresting code for you (in the form of type classes) such as equality, comparison, serialization, ... in the case of 3-D vectors

	mniip
	edwardk, I think I just came up with the most complicated solution to the Show1 problem
	phadej
	Show1 problem?
	mniip
	instance Show (IdentityT m a) where ???
	phadej
	and your solution is?
	mniip
	coming up

Icelandjack

Free category is ubiquitous

Getting Num, Floating, Fractional from Applicative

It doesn't take long

Getting `Num`, `Floating`, `Fractional` from `Applicative`