LSLeary

{-# LANGUAGE QuantifiedConstraints, BlockArguments, LambdaCase #-}

module Rec where

import Data.Functor.Product (Product(..))
import Data.Functor.Sum (Sum(..))
import Data.Kind (Type, Constraint)
import Control.Arrow ((&&&), (|||))

mpickering

{-# LANGUAGE TemplateHaskellQuotes #-}
{-# LANGUAGE GADTs #-}
module Pat3 where

import qualified Language.Haskell.TH as TH (Code, Q,)
import qualified Language.Haskell.TH.Syntax as TH (Lift(..))
import Data.Functor.Identity

type Code = TH.Code TH.Q

LSLeary

{-# LANGUAGE BlockArguments #-}

module InlineFix (
  Rec,
  inlineFix,
  Church, (|&), _0, _1, _2, _3, _4, _5, _6, _7, _8, _9,
) where

import GHC.Exts (inline)
import Data.Function (fix)

VictorTaelin

Company:

• HOC: Towards an Optimal Computer: why interaction paradigm can improve computers.
• HOC: Can we build an optimal processor?: like above, but as a tweet.
• HOC: Complete Historical Overview: the lore behind HOC's creation.

Theory:

• Interaction Combinators - Y.Lafont 1997: a concurrent model of computation
• Symmetric Interaction Combinators - Damiano Mazza 2009: a symmetric variant (used by HVM)
• The Optimal Implementation of Functional Programming Languages - best book to learn
• [BOHM](https://www.cambridge.org/core/services/aop-cambridge-core/content/

LSLeary

GADTs That Can Be Newtypes and How to Roll 'Em

I think many people know about Data.Some.Newtype⁠—⁠it uses quite a cute (and cursed) trick to encode a simple existential wrapper as a newtype, hence avoiding an unwanted indirection in the runtime representation.

But there's more to data than existentials⁠—⁠so how far do these tricks go? The answer is: surprisingly far! Let's see what other GADTs we can slim down.

Preliminaries