GHC monomorphization benchmark: ~21x compile speedup by binding a large All constraint once

README.md

GHC Monomorphization Benchmark

Demonstrates how monomorphizing a function that carries a large All constraint can dramatically speed up GHC compilation (~20x).

The Problem

When a multi-param class function like:

toFormula :: (ToFormula sig l, All (ToFormula sig) sig) => Node sig l -> Maybe String

is called at many sites (each with a different concrete l), GHC must re-solve All (ToFormula sig) sig at every call site. With a 130-element type-level list, this means enumerating and verifying 130 multi-param-class instances each time. With 130 call sites, that's 130 x 130 = 16,900 instance resolutions — and GHC's constraint solver does not cache these across call sites within a module.

The Fix

A monomorphic wrapper fixes sig and discharges the All constraint once:

monoToFormula :: ToFormula BigSig l => Node BigSig l -> Maybe String
monoToFormula = toFormula

Now callers only need ToFormula BigSig l — a single instance lookup. GHC solves the expensive 130-element All constraint exactly once at monoToFormula's definition site.

CPP Toggle

Caller.hs uses a CPP macro for easy benchmarking:

#ifdef MONOMORPHIZE
#define FOO monoToFormula
#else
#define FOO toFormula
#endif

Compile with -DMONOMORPHIZE for the fast version, without for the slow version.

Results (GHC 9.8.4, -O0, aarch64-darwin)

Version	Total time	GC bytes copied	Speedup
Polymorphic	2.61s	2,571 MB	1x
Monomorphized	0.12s	89 MB	~21x

Running

# From a devenv shell (or any env with GHC 9.8+):
./bench.sh

bench.sh

#!/usr/bin/env nix-shell
#!nix-shell -i bash -p "haskell.compiler.ghc98"

set -euo pipefail

# Benchmark: compile Caller.hs with and without -DMONOMORPHIZE.
#
# WITHOUT: every call site demands @All (ToFormula BigSig) BigSig@,
#   forcing GHC to re-solve a 130-element multi-param constraint each time.
#
# WITH: a monomorphic wrapper discharges the @All@ constraint once;
#   call sites only need @ToFormula BigSig l@ (1 lookup).

cd "$(dirname "$0")"

echo "Pre-compiling BigClass.hs..."
ghc -O0 -isrc -c src/BigClass.hs

echo ""
echo "================================================================="
echo " WITHOUT -DMONOMORPHIZE (slow: constraint re-solved 130 times)"
echo "================================================================="
ghc -fforce-recomp -O0 -isrc -no-link -c src/Caller.hs +RTS -s 2>&1 \
  | grep -E "(MUT|GC|Total|Alloc rate|bytes copied)"

echo ""
echo "================================================================="
echo " WITH -DMONOMORPHIZE (fast: constraint solved once)"
echo "================================================================="
ghc -fforce-recomp -O0 -isrc -no-link -c -DMONOMORPHIZE src/Caller.hs +RTS -s 2>&1 \
  | grep -E "(MUT|GC|Total|Alloc rate|bytes copied)"

echo ""
echo "Compare 'Total time' above. Expect ~20x speedup."

BigClass.hs

{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE AllowAmbiguousTypes #-}

-- | Demonstrates how GHC constraint-solving over a large type-level list
--   becomes very expensive when a multi-param class is involved.
--
--   Key pattern:
--     @ToFormula sig l@ — "convert a node labelled @l@ in the context of
--     signature @sig@".  The polymorphic function demands
--     @All (ToFormula sig) sig@ — GHC must verify that every type in @sig@
--     has a @ToFormula sig@ instance, for the *specific* @sig@.
--     This is harder to cache than a single-param class because the
--     signature type is part of the constraint.

module BigClass
  ( BigSig
  , ToFormula(..)
  , All
  , toFormula
  , Node(..)
  , L001, L002, L003, L004, L005, L006, L007, L008, L009, L010
  , L011, L012, L013, L014, L015, L016, L017, L018, L019, L020
  , L021, L022, L023, L024, L025, L026, L027, L028, L029, L030
  , L031, L032, L033, L034, L035, L036, L037, L038, L039, L040
  , L041, L042, L043, L044, L045, L046, L047, L048, L049, L050
  , L051, L052, L053, L054, L055, L056, L057, L058, L059, L060
  , L061, L062, L063, L064, L065, L066, L067, L068, L069, L070
  , L071, L072, L073, L074, L075, L076, L077, L078, L079, L080
  , L081, L082, L083, L084, L085, L086, L087, L088, L089, L090
  , L091, L092, L093, L094, L095, L096, L097, L098, L099, L100
  , L101, L102, L103, L104, L105, L106, L107, L108, L109, L110
  , L111, L112, L113, L114, L115, L116, L117, L118, L119, L120
  , L121, L122, L123, L124, L125, L126, L127, L128, L129, L130
  ) where

import Data.Kind (Type, Constraint)

------------------------------------------------------------------------
-- Type-level machinery
------------------------------------------------------------------------

-- | @All c xs@ holds when @c x@ holds for every @x@ in @xs@.
type family All (c :: Type -> Constraint) (xs :: [Type]) :: Constraint where
  All _ '[]       = ()
  All c (x ': xs) = (c x, All c xs)

------------------------------------------------------------------------
-- 130 label types
------------------------------------------------------------------------

data L001; data L002; data L003; data L004; data L005
data L006; data L007; data L008; data L009; data L010
data L011; data L012; data L013; data L014; data L015
data L016; data L017; data L018; data L019; data L020
data L021; data L022; data L023; data L024; data L025
data L026; data L027; data L028; data L029; data L030
data L031; data L032; data L033; data L034; data L035
data L036; data L037; data L038; data L039; data L040
data L041; data L042; data L043; data L044; data L045
data L046; data L047; data L048; data L049; data L050
data L051; data L052; data L053; data L054; data L055
data L056; data L057; data L058; data L059; data L060
data L061; data L062; data L063; data L064; data L065
data L066; data L067; data L068; data L069; data L070
data L071; data L072; data L073; data L074; data L075
data L076; data L077; data L078; data L079; data L080
data L081; data L082; data L083; data L084; data L085
data L086; data L087; data L088; data L089; data L090
data L091; data L092; data L093; data L094; data L095
data L096; data L097; data L098; data L099; data L100
data L101; data L102; data L103; data L104; data L105
data L106; data L107; data L108; data L109; data L110
data L111; data L112; data L113; data L114; data L115
data L116; data L117; data L118; data L119; data L120
data L121; data L122; data L123; data L124; data L125
data L126; data L127; data L128; data L129; data L130

type BigSig =
  '[ L001, L002, L003, L004, L005, L006, L007, L008, L009, L010
   , L011, L012, L013, L014, L015, L016, L017, L018, L019, L020
   , L021, L022, L023, L024, L025, L026, L027, L028, L029, L030
   , L031, L032, L033, L034, L035, L036, L037, L038, L039, L040
   , L041, L042, L043, L044, L045, L046, L047, L048, L049, L050
   , L051, L052, L053, L054, L055, L056, L057, L058, L059, L060
   , L061, L062, L063, L064, L065, L066, L067, L068, L069, L070
   , L071, L072, L073, L074, L075, L076, L077, L078, L079, L080
   , L081, L082, L083, L084, L085, L086, L087, L088, L089, L090
   , L091, L092, L093, L094, L095, L096, L097, L098, L099, L100
   , L101, L102, L103, L104, L105, L106, L107, L108, L109, L110
   , L111, L112, L113, L114, L115, L116, L117, L118, L119, L120
   , L121, L122, L123, L124, L125, L126, L127, L128, L129, L130
   ]

------------------------------------------------------------------------
-- Node type and multi-param class
------------------------------------------------------------------------

data Node (sig :: [Type]) (l :: Type) = Node String deriving (Show)

-- | Multi-param class: "convert node labelled @l@ in the context of
--   signature @sig@".  The @sig@ parameter means the constraint
--   @All (ToFormula sig) sig@ is parameterised and harder for GHC
--   to share/cache across different occurrences.
class ToFormula (sig :: [Type]) l where
  toFormulaImpl :: Node sig l -> Maybe String

-- | The polymorphic traversal function.
--   The constraint @All (ToFormula sig) sig@ must be solved at every call site.
toFormula :: (ToFormula sig l, All (ToFormula sig) sig) => Node sig l -> Maybe String
toFormula = toFormulaImpl

------------------------------------------------------------------------
-- 130 instances (parameterised by sig — expensive to enumerate)
------------------------------------------------------------------------

instance ToFormula sig L001 where toFormulaImpl (Node s) = Just $ "L001(" ++ s ++ ")"
instance ToFormula sig L002 where toFormulaImpl (Node s) = Just $ "L002(" ++ s ++ ")"
instance ToFormula sig L003 where toFormulaImpl (Node s) = Just $ "L003(" ++ s ++ ")"
instance ToFormula sig L004 where toFormulaImpl (Node s) = Just $ "L004(" ++ s ++ ")"
instance ToFormula sig L005 where toFormulaImpl (Node s) = Just $ "L005(" ++ s ++ ")"
instance ToFormula sig L006 where toFormulaImpl (Node s) = Just $ "L006(" ++ s ++ ")"
instance ToFormula sig L007 where toFormulaImpl (Node s) = Just $ "L007(" ++ s ++ ")"
instance ToFormula sig L008 where toFormulaImpl (Node s) = Just $ "L008(" ++ s ++ ")"
instance ToFormula sig L009 where toFormulaImpl (Node s) = Just $ "L009(" ++ s ++ ")"
instance ToFormula sig L010 where toFormulaImpl (Node s) = Just $ "L010(" ++ s ++ ")"
instance ToFormula sig L011 where toFormulaImpl (Node s) = Just $ "L011(" ++ s ++ ")"
instance ToFormula sig L012 where toFormulaImpl (Node s) = Just $ "L012(" ++ s ++ ")"
instance ToFormula sig L013 where toFormulaImpl (Node s) = Just $ "L013(" ++ s ++ ")"
instance ToFormula sig L014 where toFormulaImpl (Node s) = Just $ "L014(" ++ s ++ ")"
instance ToFormula sig L015 where toFormulaImpl (Node s) = Just $ "L015(" ++ s ++ ")"
instance ToFormula sig L016 where toFormulaImpl (Node s) = Just $ "L016(" ++ s ++ ")"
instance ToFormula sig L017 where toFormulaImpl (Node s) = Just $ "L017(" ++ s ++ ")"
instance ToFormula sig L018 where toFormulaImpl (Node s) = Just $ "L018(" ++ s ++ ")"
instance ToFormula sig L019 where toFormulaImpl (Node s) = Just $ "L019(" ++ s ++ ")"
instance ToFormula sig L020 where toFormulaImpl (Node s) = Just $ "L020(" ++ s ++ ")"
instance ToFormula sig L021 where toFormulaImpl (Node s) = Just $ "L021(" ++ s ++ ")"
instance ToFormula sig L022 where toFormulaImpl (Node s) = Just $ "L022(" ++ s ++ ")"
instance ToFormula sig L023 where toFormulaImpl (Node s) = Just $ "L023(" ++ s ++ ")"
instance ToFormula sig L024 where toFormulaImpl (Node s) = Just $ "L024(" ++ s ++ ")"
instance ToFormula sig L025 where toFormulaImpl (Node s) = Just $ "L025(" ++ s ++ ")"
instance ToFormula sig L026 where toFormulaImpl (Node s) = Just $ "L026(" ++ s ++ ")"
instance ToFormula sig L027 where toFormulaImpl (Node s) = Just $ "L027(" ++ s ++ ")"
instance ToFormula sig L028 where toFormulaImpl (Node s) = Just $ "L028(" ++ s ++ ")"
instance ToFormula sig L029 where toFormulaImpl (Node s) = Just $ "L029(" ++ s ++ ")"
instance ToFormula sig L030 where toFormulaImpl (Node s) = Just $ "L030(" ++ s ++ ")"
instance ToFormula sig L031 where toFormulaImpl (Node s) = Just $ "L031(" ++ s ++ ")"
instance ToFormula sig L032 where toFormulaImpl (Node s) = Just $ "L032(" ++ s ++ ")"
instance ToFormula sig L033 where toFormulaImpl (Node s) = Just $ "L033(" ++ s ++ ")"
instance ToFormula sig L034 where toFormulaImpl (Node s) = Just $ "L034(" ++ s ++ ")"
instance ToFormula sig L035 where toFormulaImpl (Node s) = Just $ "L035(" ++ s ++ ")"
instance ToFormula sig L036 where toFormulaImpl (Node s) = Just $ "L036(" ++ s ++ ")"
instance ToFormula sig L037 where toFormulaImpl (Node s) = Just $ "L037(" ++ s ++ ")"
instance ToFormula sig L038 where toFormulaImpl (Node s) = Just $ "L038(" ++ s ++ ")"
instance ToFormula sig L039 where toFormulaImpl (Node s) = Just $ "L039(" ++ s ++ ")"
instance ToFormula sig L040 where toFormulaImpl (Node s) = Just $ "L040(" ++ s ++ ")"
instance ToFormula sig L041 where toFormulaImpl (Node s) = Just $ "L041(" ++ s ++ ")"
instance ToFormula sig L042 where toFormulaImpl (Node s) = Just $ "L042(" ++ s ++ ")"
instance ToFormula sig L043 where toFormulaImpl (Node s) = Just $ "L043(" ++ s ++ ")"
instance ToFormula sig L044 where toFormulaImpl (Node s) = Just $ "L044(" ++ s ++ ")"
instance ToFormula sig L045 where toFormulaImpl (Node s) = Just $ "L045(" ++ s ++ ")"
instance ToFormula sig L046 where toFormulaImpl (Node s) = Just $ "L046(" ++ s ++ ")"
instance ToFormula sig L047 where toFormulaImpl (Node s) = Just $ "L047(" ++ s ++ ")"
instance ToFormula sig L048 where toFormulaImpl (Node s) = Just $ "L048(" ++ s ++ ")"
instance ToFormula sig L049 where toFormulaImpl (Node s) = Just $ "L049(" ++ s ++ ")"
instance ToFormula sig L050 where toFormulaImpl (Node s) = Just $ "L050(" ++ s ++ ")"
instance ToFormula sig L051 where toFormulaImpl (Node s) = Just $ "L051(" ++ s ++ ")"
instance ToFormula sig L052 where toFormulaImpl (Node s) = Just $ "L052(" ++ s ++ ")"
instance ToFormula sig L053 where toFormulaImpl (Node s) = Just $ "L053(" ++ s ++ ")"
instance ToFormula sig L054 where toFormulaImpl (Node s) = Just $ "L054(" ++ s ++ ")"
instance ToFormula sig L055 where toFormulaImpl (Node s) = Just $ "L055(" ++ s ++ ")"
instance ToFormula sig L056 where toFormulaImpl (Node s) = Just $ "L056(" ++ s ++ ")"
instance ToFormula sig L057 where toFormulaImpl (Node s) = Just $ "L057(" ++ s ++ ")"
instance ToFormula sig L058 where toFormulaImpl (Node s) = Just $ "L058(" ++ s ++ ")"
instance ToFormula sig L059 where toFormulaImpl (Node s) = Just $ "L059(" ++ s ++ ")"
instance ToFormula sig L060 where toFormulaImpl (Node s) = Just $ "L060(" ++ s ++ ")"
instance ToFormula sig L061 where toFormulaImpl (Node s) = Just $ "L061(" ++ s ++ ")"
instance ToFormula sig L062 where toFormulaImpl (Node s) = Just $ "L062(" ++ s ++ ")"
instance ToFormula sig L063 where toFormulaImpl (Node s) = Just $ "L063(" ++ s ++ ")"
instance ToFormula sig L064 where toFormulaImpl (Node s) = Just $ "L064(" ++ s ++ ")"
instance ToFormula sig L065 where toFormulaImpl (Node s) = Just $ "L065(" ++ s ++ ")"
instance ToFormula sig L066 where toFormulaImpl (Node s) = Just $ "L066(" ++ s ++ ")"
instance ToFormula sig L067 where toFormulaImpl (Node s) = Just $ "L067(" ++ s ++ ")"
instance ToFormula sig L068 where toFormulaImpl (Node s) = Just $ "L068(" ++ s ++ ")"
instance ToFormula sig L069 where toFormulaImpl (Node s) = Just $ "L069(" ++ s ++ ")"
instance ToFormula sig L070 where toFormulaImpl (Node s) = Just $ "L070(" ++ s ++ ")"
instance ToFormula sig L071 where toFormulaImpl (Node s) = Just $ "L071(" ++ s ++ ")"
instance ToFormula sig L072 where toFormulaImpl (Node s) = Just $ "L072(" ++ s ++ ")"
instance ToFormula sig L073 where toFormulaImpl (Node s) = Just $ "L073(" ++ s ++ ")"
instance ToFormula sig L074 where toFormulaImpl (Node s) = Just $ "L074(" ++ s ++ ")"
instance ToFormula sig L075 where toFormulaImpl (Node s) = Just $ "L075(" ++ s ++ ")"
instance ToFormula sig L076 where toFormulaImpl (Node s) = Just $ "L076(" ++ s ++ ")"
instance ToFormula sig L077 where toFormulaImpl (Node s) = Just $ "L077(" ++ s ++ ")"
instance ToFormula sig L078 where toFormulaImpl (Node s) = Just $ "L078(" ++ s ++ ")"
instance ToFormula sig L079 where toFormulaImpl (Node s) = Just $ "L079(" ++ s ++ ")"
instance ToFormula sig L080 where toFormulaImpl (Node s) = Just $ "L080(" ++ s ++ ")"
instance ToFormula sig L081 where toFormulaImpl (Node s) = Just $ "L081(" ++ s ++ ")"
instance ToFormula sig L082 where toFormulaImpl (Node s) = Just $ "L082(" ++ s ++ ")"
instance ToFormula sig L083 where toFormulaImpl (Node s) = Just $ "L083(" ++ s ++ ")"
instance ToFormula sig L084 where toFormulaImpl (Node s) = Just $ "L084(" ++ s ++ ")"
instance ToFormula sig L085 where toFormulaImpl (Node s) = Just $ "L085(" ++ s ++ ")"
instance ToFormula sig L086 where toFormulaImpl (Node s) = Just $ "L086(" ++ s ++ ")"
instance ToFormula sig L087 where toFormulaImpl (Node s) = Just $ "L087(" ++ s ++ ")"
instance ToFormula sig L088 where toFormulaImpl (Node s) = Just $ "L088(" ++ s ++ ")"
instance ToFormula sig L089 where toFormulaImpl (Node s) = Just $ "L089(" ++ s ++ ")"
instance ToFormula sig L090 where toFormulaImpl (Node s) = Just $ "L090(" ++ s ++ ")"
instance ToFormula sig L091 where toFormulaImpl (Node s) = Just $ "L091(" ++ s ++ ")"
instance ToFormula sig L092 where toFormulaImpl (Node s) = Just $ "L092(" ++ s ++ ")"
instance ToFormula sig L093 where toFormulaImpl (Node s) = Just $ "L093(" ++ s ++ ")"
instance ToFormula sig L094 where toFormulaImpl (Node s) = Just $ "L094(" ++ s ++ ")"
instance ToFormula sig L095 where toFormulaImpl (Node s) = Just $ "L095(" ++ s ++ ")"
instance ToFormula sig L096 where toFormulaImpl (Node s) = Just $ "L096(" ++ s ++ ")"
instance ToFormula sig L097 where toFormulaImpl (Node s) = Just $ "L097(" ++ s ++ ")"
instance ToFormula sig L098 where toFormulaImpl (Node s) = Just $ "L098(" ++ s ++ ")"
instance ToFormula sig L099 where toFormulaImpl (Node s) = Just $ "L099(" ++ s ++ ")"
instance ToFormula sig L100 where toFormulaImpl (Node s) = Just $ "L100(" ++ s ++ ")"
instance ToFormula sig L101 where toFormulaImpl (Node s) = Just $ "L101(" ++ s ++ ")"
instance ToFormula sig L102 where toFormulaImpl (Node s) = Just $ "L102(" ++ s ++ ")"
instance ToFormula sig L103 where toFormulaImpl (Node s) = Just $ "L103(" ++ s ++ ")"
instance ToFormula sig L104 where toFormulaImpl (Node s) = Just $ "L104(" ++ s ++ ")"
instance ToFormula sig L105 where toFormulaImpl (Node s) = Just $ "L105(" ++ s ++ ")"
instance ToFormula sig L106 where toFormulaImpl (Node s) = Just $ "L106(" ++ s ++ ")"
instance ToFormula sig L107 where toFormulaImpl (Node s) = Just $ "L107(" ++ s ++ ")"
instance ToFormula sig L108 where toFormulaImpl (Node s) = Just $ "L108(" ++ s ++ ")"
instance ToFormula sig L109 where toFormulaImpl (Node s) = Just $ "L109(" ++ s ++ ")"
instance ToFormula sig L110 where toFormulaImpl (Node s) = Just $ "L110(" ++ s ++ ")"
instance ToFormula sig L111 where toFormulaImpl (Node s) = Just $ "L111(" ++ s ++ ")"
instance ToFormula sig L112 where toFormulaImpl (Node s) = Just $ "L112(" ++ s ++ ")"
instance ToFormula sig L113 where toFormulaImpl (Node s) = Just $ "L113(" ++ s ++ ")"
instance ToFormula sig L114 where toFormulaImpl (Node s) = Just $ "L114(" ++ s ++ ")"
instance ToFormula sig L115 where toFormulaImpl (Node s) = Just $ "L115(" ++ s ++ ")"
instance ToFormula sig L116 where toFormulaImpl (Node s) = Just $ "L116(" ++ s ++ ")"
instance ToFormula sig L117 where toFormulaImpl (Node s) = Just $ "L117(" ++ s ++ ")"
instance ToFormula sig L118 where toFormulaImpl (Node s) = Just $ "L118(" ++ s ++ ")"
instance ToFormula sig L119 where toFormulaImpl (Node s) = Just $ "L119(" ++ s ++ ")"
instance ToFormula sig L120 where toFormulaImpl (Node s) = Just $ "L120(" ++ s ++ ")"
instance ToFormula sig L121 where toFormulaImpl (Node s) = Just $ "L121(" ++ s ++ ")"
instance ToFormula sig L122 where toFormulaImpl (Node s) = Just $ "L122(" ++ s ++ ")"
instance ToFormula sig L123 where toFormulaImpl (Node s) = Just $ "L123(" ++ s ++ ")"
instance ToFormula sig L124 where toFormulaImpl (Node s) = Just $ "L124(" ++ s ++ ")"
instance ToFormula sig L125 where toFormulaImpl (Node s) = Just $ "L125(" ++ s ++ ")"
instance ToFormula sig L126 where toFormulaImpl (Node s) = Just $ "L126(" ++ s ++ ")"
instance ToFormula sig L127 where toFormulaImpl (Node s) = Just $ "L127(" ++ s ++ ")"
instance ToFormula sig L128 where toFormulaImpl (Node s) = Just $ "L128(" ++ s ++ ")"
instance ToFormula sig L129 where toFormulaImpl (Node s) = Just $ "L129(" ++ s ++ ")"
instance ToFormula sig L130 where toFormulaImpl (Node s) = Just $ "L130(" ++ s ++ ")"

Caller.hs

{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}

-- | Single module that uses CPP to switch between the polymorphic
--   and monomorphized versions.
--
--   Compile with:
--     ghc -DMONOMORPHIZE ...   -- fast (constraint solved once)
--     ghc ...                  -- slow (constraint re-solved at every call site)

module Caller (runAll) where

import BigClass

-- | Monomorphic wrapper: discharges @All (ToFormula BigSig) BigSig@ once.
monoToFormula :: ToFormula BigSig l => Node BigSig l -> Maybe String
monoToFormula = toFormula

#ifdef MONOMORPHIZE
#define FOO monoToFormula
#else
#define FOO toFormula
#endif

go001 :: Maybe String; go001 = FOO (Node "x" :: Node BigSig L001)
go002 :: Maybe String; go002 = FOO (Node "x" :: Node BigSig L002)
go003 :: Maybe String; go003 = FOO (Node "x" :: Node BigSig L003)
go004 :: Maybe String; go004 = FOO (Node "x" :: Node BigSig L004)
go005 :: Maybe String; go005 = FOO (Node "x" :: Node BigSig L005)
go006 :: Maybe String; go006 = FOO (Node "x" :: Node BigSig L006)
go007 :: Maybe String; go007 = FOO (Node "x" :: Node BigSig L007)
go008 :: Maybe String; go008 = FOO (Node "x" :: Node BigSig L008)
go009 :: Maybe String; go009 = FOO (Node "x" :: Node BigSig L009)
go010 :: Maybe String; go010 = FOO (Node "x" :: Node BigSig L010)
go011 :: Maybe String; go011 = FOO (Node "x" :: Node BigSig L011)
go012 :: Maybe String; go012 = FOO (Node "x" :: Node BigSig L012)
go013 :: Maybe String; go013 = FOO (Node "x" :: Node BigSig L013)
go014 :: Maybe String; go014 = FOO (Node "x" :: Node BigSig L014)
go015 :: Maybe String; go015 = FOO (Node "x" :: Node BigSig L015)
go016 :: Maybe String; go016 = FOO (Node "x" :: Node BigSig L016)
go017 :: Maybe String; go017 = FOO (Node "x" :: Node BigSig L017)
go018 :: Maybe String; go018 = FOO (Node "x" :: Node BigSig L018)
go019 :: Maybe String; go019 = FOO (Node "x" :: Node BigSig L019)
go020 :: Maybe String; go020 = FOO (Node "x" :: Node BigSig L020)
go021 :: Maybe String; go021 = FOO (Node "x" :: Node BigSig L021)
go022 :: Maybe String; go022 = FOO (Node "x" :: Node BigSig L022)
go023 :: Maybe String; go023 = FOO (Node "x" :: Node BigSig L023)
go024 :: Maybe String; go024 = FOO (Node "x" :: Node BigSig L024)
go025 :: Maybe String; go025 = FOO (Node "x" :: Node BigSig L025)
go026 :: Maybe String; go026 = FOO (Node "x" :: Node BigSig L026)
go027 :: Maybe String; go027 = FOO (Node "x" :: Node BigSig L027)
go028 :: Maybe String; go028 = FOO (Node "x" :: Node BigSig L028)
go029 :: Maybe String; go029 = FOO (Node "x" :: Node BigSig L029)
go030 :: Maybe String; go030 = FOO (Node "x" :: Node BigSig L030)
go031 :: Maybe String; go031 = FOO (Node "x" :: Node BigSig L031)
go032 :: Maybe String; go032 = FOO (Node "x" :: Node BigSig L032)
go033 :: Maybe String; go033 = FOO (Node "x" :: Node BigSig L033)
go034 :: Maybe String; go034 = FOO (Node "x" :: Node BigSig L034)
go035 :: Maybe String; go035 = FOO (Node "x" :: Node BigSig L035)
go036 :: Maybe String; go036 = FOO (Node "x" :: Node BigSig L036)
go037 :: Maybe String; go037 = FOO (Node "x" :: Node BigSig L037)
go038 :: Maybe String; go038 = FOO (Node "x" :: Node BigSig L038)
go039 :: Maybe String; go039 = FOO (Node "x" :: Node BigSig L039)
go040 :: Maybe String; go040 = FOO (Node "x" :: Node BigSig L040)
go041 :: Maybe String; go041 = FOO (Node "x" :: Node BigSig L041)
go042 :: Maybe String; go042 = FOO (Node "x" :: Node BigSig L042)
go043 :: Maybe String; go043 = FOO (Node "x" :: Node BigSig L043)
go044 :: Maybe String; go044 = FOO (Node "x" :: Node BigSig L044)
go045 :: Maybe String; go045 = FOO (Node "x" :: Node BigSig L045)
go046 :: Maybe String; go046 = FOO (Node "x" :: Node BigSig L046)
go047 :: Maybe String; go047 = FOO (Node "x" :: Node BigSig L047)
go048 :: Maybe String; go048 = FOO (Node "x" :: Node BigSig L048)
go049 :: Maybe String; go049 = FOO (Node "x" :: Node BigSig L049)
go050 :: Maybe String; go050 = FOO (Node "x" :: Node BigSig L050)
go051 :: Maybe String; go051 = FOO (Node "x" :: Node BigSig L051)
go052 :: Maybe String; go052 = FOO (Node "x" :: Node BigSig L052)
go053 :: Maybe String; go053 = FOO (Node "x" :: Node BigSig L053)
go054 :: Maybe String; go054 = FOO (Node "x" :: Node BigSig L054)
go055 :: Maybe String; go055 = FOO (Node "x" :: Node BigSig L055)
go056 :: Maybe String; go056 = FOO (Node "x" :: Node BigSig L056)
go057 :: Maybe String; go057 = FOO (Node "x" :: Node BigSig L057)
go058 :: Maybe String; go058 = FOO (Node "x" :: Node BigSig L058)
go059 :: Maybe String; go059 = FOO (Node "x" :: Node BigSig L059)
go060 :: Maybe String; go060 = FOO (Node "x" :: Node BigSig L060)
go061 :: Maybe String; go061 = FOO (Node "x" :: Node BigSig L061)
go062 :: Maybe String; go062 = FOO (Node "x" :: Node BigSig L062)
go063 :: Maybe String; go063 = FOO (Node "x" :: Node BigSig L063)
go064 :: Maybe String; go064 = FOO (Node "x" :: Node BigSig L064)
go065 :: Maybe String; go065 = FOO (Node "x" :: Node BigSig L065)
go066 :: Maybe String; go066 = FOO (Node "x" :: Node BigSig L066)
go067 :: Maybe String; go067 = FOO (Node "x" :: Node BigSig L067)
go068 :: Maybe String; go068 = FOO (Node "x" :: Node BigSig L068)
go069 :: Maybe String; go069 = FOO (Node "x" :: Node BigSig L069)
go070 :: Maybe String; go070 = FOO (Node "x" :: Node BigSig L070)
go071 :: Maybe String; go071 = FOO (Node "x" :: Node BigSig L071)
go072 :: Maybe String; go072 = FOO (Node "x" :: Node BigSig L072)
go073 :: Maybe String; go073 = FOO (Node "x" :: Node BigSig L073)
go074 :: Maybe String; go074 = FOO (Node "x" :: Node BigSig L074)
go075 :: Maybe String; go075 = FOO (Node "x" :: Node BigSig L075)
go076 :: Maybe String; go076 = FOO (Node "x" :: Node BigSig L076)
go077 :: Maybe String; go077 = FOO (Node "x" :: Node BigSig L077)
go078 :: Maybe String; go078 = FOO (Node "x" :: Node BigSig L078)
go079 :: Maybe String; go079 = FOO (Node "x" :: Node BigSig L079)
go080 :: Maybe String; go080 = FOO (Node "x" :: Node BigSig L080)
go081 :: Maybe String; go081 = FOO (Node "x" :: Node BigSig L081)
go082 :: Maybe String; go082 = FOO (Node "x" :: Node BigSig L082)
go083 :: Maybe String; go083 = FOO (Node "x" :: Node BigSig L083)
go084 :: Maybe String; go084 = FOO (Node "x" :: Node BigSig L084)
go085 :: Maybe String; go085 = FOO (Node "x" :: Node BigSig L085)
go086 :: Maybe String; go086 = FOO (Node "x" :: Node BigSig L086)
go087 :: Maybe String; go087 = FOO (Node "x" :: Node BigSig L087)
go088 :: Maybe String; go088 = FOO (Node "x" :: Node BigSig L088)
go089 :: Maybe String; go089 = FOO (Node "x" :: Node BigSig L089)
go090 :: Maybe String; go090 = FOO (Node "x" :: Node BigSig L090)
go091 :: Maybe String; go091 = FOO (Node "x" :: Node BigSig L091)
go092 :: Maybe String; go092 = FOO (Node "x" :: Node BigSig L092)
go093 :: Maybe String; go093 = FOO (Node "x" :: Node BigSig L093)
go094 :: Maybe String; go094 = FOO (Node "x" :: Node BigSig L094)
go095 :: Maybe String; go095 = FOO (Node "x" :: Node BigSig L095)
go096 :: Maybe String; go096 = FOO (Node "x" :: Node BigSig L096)
go097 :: Maybe String; go097 = FOO (Node "x" :: Node BigSig L097)
go098 :: Maybe String; go098 = FOO (Node "x" :: Node BigSig L098)
go099 :: Maybe String; go099 = FOO (Node "x" :: Node BigSig L099)
go100 :: Maybe String; go100 = FOO (Node "x" :: Node BigSig L100)
go101 :: Maybe String; go101 = FOO (Node "x" :: Node BigSig L101)
go102 :: Maybe String; go102 = FOO (Node "x" :: Node BigSig L102)
go103 :: Maybe String; go103 = FOO (Node "x" :: Node BigSig L103)
go104 :: Maybe String; go104 = FOO (Node "x" :: Node BigSig L104)
go105 :: Maybe String; go105 = FOO (Node "x" :: Node BigSig L105)
go106 :: Maybe String; go106 = FOO (Node "x" :: Node BigSig L106)
go107 :: Maybe String; go107 = FOO (Node "x" :: Node BigSig L107)
go108 :: Maybe String; go108 = FOO (Node "x" :: Node BigSig L108)
go109 :: Maybe String; go109 = FOO (Node "x" :: Node BigSig L109)
go110 :: Maybe String; go110 = FOO (Node "x" :: Node BigSig L110)
go111 :: Maybe String; go111 = FOO (Node "x" :: Node BigSig L111)
go112 :: Maybe String; go112 = FOO (Node "x" :: Node BigSig L112)
go113 :: Maybe String; go113 = FOO (Node "x" :: Node BigSig L113)
go114 :: Maybe String; go114 = FOO (Node "x" :: Node BigSig L114)
go115 :: Maybe String; go115 = FOO (Node "x" :: Node BigSig L115)
go116 :: Maybe String; go116 = FOO (Node "x" :: Node BigSig L116)
go117 :: Maybe String; go117 = FOO (Node "x" :: Node BigSig L117)
go118 :: Maybe String; go118 = FOO (Node "x" :: Node BigSig L118)
go119 :: Maybe String; go119 = FOO (Node "x" :: Node BigSig L119)
go120 :: Maybe String; go120 = FOO (Node "x" :: Node BigSig L120)
go121 :: Maybe String; go121 = FOO (Node "x" :: Node BigSig L121)
go122 :: Maybe String; go122 = FOO (Node "x" :: Node BigSig L122)
go123 :: Maybe String; go123 = FOO (Node "x" :: Node BigSig L123)
go124 :: Maybe String; go124 = FOO (Node "x" :: Node BigSig L124)
go125 :: Maybe String; go125 = FOO (Node "x" :: Node BigSig L125)
go126 :: Maybe String; go126 = FOO (Node "x" :: Node BigSig L126)
go127 :: Maybe String; go127 = FOO (Node "x" :: Node BigSig L127)
go128 :: Maybe String; go128 = FOO (Node "x" :: Node BigSig L128)
go129 :: Maybe String; go129 = FOO (Node "x" :: Node BigSig L129)
go130 :: Maybe String; go130 = FOO (Node "x" :: Node BigSig L130)

runAll :: [Maybe String]
runAll =
  [ go001, go002, go003, go004, go005, go006, go007, go008, go009, go010
  , go011, go012, go013, go014, go015, go016, go017, go018, go019, go020
  , go021, go022, go023, go024, go025, go026, go027, go028, go029, go030
  , go031, go032, go033, go034, go035, go036, go037, go038, go039, go040
  , go041, go042, go043, go044, go045, go046, go047, go048, go049, go050
  , go051, go052, go053, go054, go055, go056, go057, go058, go059, go060
  , go061, go062, go063, go064, go065, go066, go067, go068, go069, go070
  , go071, go072, go073, go074, go075, go076, go077, go078, go079, go080
  , go081, go082, go083, go084, go085, go086, go087, go088, go089, go090
  , go091, go092, go093, go094, go095, go096, go097, go098, go099, go100
  , go101, go102, go103, go104, go105, go106, go107, go108, go109, go110
  , go111, go112, go113, go114, go115, go116, go117, go118, go119, go120
  , go121, go122, go123, go124, go125, go126, go127, go128, go129, go130
  ]

ghc-monomorphize-bench.cabal

cabal-version: 2.4
name:          ghc-monomorphize-bench
version:       0.1.0.0
build-type:    Simple

library
  exposed-modules:
    BigClass
    Caller
    CallerPoly
    CallerMono
  hs-source-dirs: src
  default-language: Haskell2010
  ghc-options: -Wall
  build-depends: base >= 4.14 && < 5