Merge remote-tracking branch 'origin/master' into package-dot-json-parsing

2024-12-24 23:42:31 +03:00 · 2018-05-16 12:07:13 -07:00 · 2018-05-16 12:07:13 -07:00 · a60ed7bc16
commit a60ed7bc16
parent 85bfd7b796 742918e44d
51 changed files with 1019 additions and 347 deletions
--- a/semantic.cabal
+++ b/semantic.cabal
@ -21,7 +21,6 @@ library
                     , Analysis.Abstract.Evaluating
                     , Analysis.Abstract.Graph
                     , Analysis.Abstract.Tracing
-                     , Analysis.CallGraph
                     , Analysis.ConstructorName
                     , Analysis.CyclomaticComplexity
                     , Analysis.Decorator
@ -44,6 +43,7 @@ library
                     , Control.Abstract.Matching
                     , Control.Abstract.Modules
                     , Control.Abstract.Roots
+                     , Control.Abstract.TermEvaluator
                     , Control.Abstract.Value
                     -- Datatypes for abstract interpretation
                     , Data.Abstract.Address
--- a/src/Analysis/Abstract/Caching.hs
+++ b/src/Analysis/Abstract/Caching.hs
@ -1,4 +1,4 @@
-{-# LANGUAGE GADTs, ScopedTypeVariables, TypeOperators #-}
+{-# LANGUAGE GADTs, TypeOperators #-}
 module Analysis.Abstract.Caching
 ( cachingTerms
 , convergingModules
@ -12,31 +12,46 @@ import Data.Semilattice.Lower
 import Prologue

 -- | Look up the set of values for a given configuration in the in-cache.
-consultOracle :: (Cacheable term location (Cell location) value, Member (Reader (Cache term location (Cell location) value)) effects) => Configuration term location (Cell location) value -> Evaluator location value effects (Set (value, Heap location (Cell location) value))
+consultOracle :: (Cacheable term location (Cell location) value, Member (Reader (Cache term location (Cell location) value)) effects)
+              => Configuration term location (Cell location) value
+              -> TermEvaluator term location value effects (Set (Cached location (Cell location) value))
 consultOracle configuration = fromMaybe mempty . cacheLookup configuration <$> ask

 -- | Run an action with the given in-cache.
-withOracle :: Member (Reader (Cache term location (Cell location) value)) effects => Cache term location (Cell location) value -> Evaluator location value effects a -> Evaluator location value effects a
+withOracle :: Member (Reader (Cache term location (Cell location) value)) effects
+           => Cache term location (Cell location) value
+           -> TermEvaluator term location value effects a
+           -> TermEvaluator term location value effects a
 withOracle cache = local (const cache)


 -- | Look up the set of values for a given configuration in the out-cache.
-lookupCache :: (Cacheable term location (Cell location) value, Member (State (Cache term location (Cell location) value)) effects) => Configuration term location (Cell location) value -> Evaluator location value effects (Maybe (Set (value, Heap location (Cell location) value)))
+lookupCache :: (Cacheable term location (Cell location) value, Member (State (Cache term location (Cell location) value)) effects)
+            => Configuration term location (Cell location) value
+            -> TermEvaluator term location value effects (Maybe (Set (Cached location (Cell location) value)))
 lookupCache configuration = cacheLookup configuration <$> get

 -- | Run an action, caching its result and 'Heap' under the given configuration.
-cachingConfiguration :: (Cacheable term location (Cell location) value, Members '[State (Cache term location (Cell location) value), State (Heap location (Cell location) value)] effects) => Configuration term location (Cell location) value -> Set (value, Heap location (Cell location) value) -> Evaluator location value effects value -> Evaluator location value effects value
+cachingConfiguration :: (Cacheable term location (Cell location) value, Members '[State (Cache term location (Cell location) value), State (Heap location (Cell location) value)] effects)
+                     => Configuration term location (Cell location) value
+                     -> Set (Cached location (Cell location) value)
+                     -> TermEvaluator term location value effects value
+                     -> TermEvaluator term location value effects value
 cachingConfiguration configuration values action = do
  modify' (cacheSet configuration values)
-  result <- (,) <$> action <*> get
-  fst result <$ modify' (cacheInsert configuration result)
+  result <- Cached <$> action <*> TermEvaluator getHeap
+  cachedValue result <$ modify' (cacheInsert configuration result)

-putCache :: Member (State (Cache term location (Cell location) value)) effects => Cache term location (Cell location) value -> Evaluator location value effects ()
+putCache :: Member (State (Cache term location (Cell location) value)) effects
+         => Cache term location (Cell location) value
+         -> TermEvaluator term location value effects ()
 putCache = put

 -- | Run an action starting from an empty out-cache, and return the out-cache afterwards.
-isolateCache :: forall term location value effects a . Member (State (Cache term location (Cell location) value)) effects => Evaluator location value effects a -> Evaluator location value effects (Cache term location (Cell location) value)
-isolateCache action = putCache @term lowerBound *> action *> get
+isolateCache :: Member (State (Cache term location (Cell location) value)) effects
+             => TermEvaluator term location value effects a
+             -> TermEvaluator term location value effects (Cache term location (Cell location) value)
+isolateCache action = putCache lowerBound *> action *> get


 -- | Analyze a term using the in-cache as an oracle & storing the results of the analysis in the out-cache.
@ -51,8 +66,8 @@ cachingTerms :: ( Cacheable term location (Cell location) value
                           , State (Heap location (Cell location) value)
                           ] effects
                )
-             => SubtermAlgebra (Base term) term (Evaluator location value effects value)
-             -> SubtermAlgebra (Base term) term (Evaluator location value effects value)
+             => SubtermAlgebra (Base term) term (TermEvaluator term location value effects value)
+             -> SubtermAlgebra (Base term) term (TermEvaluator term location value effects value)
 cachingTerms recur term = do
  c <- getConfiguration (embedSubterm term)
  cached <- lookupCache c
@ -72,13 +87,14 @@ convergingModules :: ( Cacheable term location (Cell location) value
                                , State (Heap location (Cell location) value)
                                ] effects
                     )
-                  => SubtermAlgebra Module term (Evaluator location value effects value)
-                  -> SubtermAlgebra Module term (Evaluator location value effects value)
+                  => SubtermAlgebra Module term (TermEvaluator term location value effects value)
+                  -> SubtermAlgebra Module term (TermEvaluator term location value effects value)
 convergingModules recur m = do
  c <- getConfiguration (subterm (moduleBody m))
  -- Convergence here is predicated upon an Eq instance, not α-equivalence
-  cache <- converge (\ prevCache -> isolateCache $ do
-    putHeap (configurationHeap c)
+  cache <- converge lowerBound (\ prevCache -> isolateCache $ do
+    TermEvaluator (putEnv  (configurationEnvironment c))
+    TermEvaluator (putHeap (configurationHeap        c))
    -- We need to reset fresh generation so that this invocation converges.
    resetFresh 0 $
    -- This is subtle: though the calling context supports nondeterminism, we want
@ -86,7 +102,7 @@ convergingModules recur m = do
    -- that it doesn't "leak" to the calling context and diverge (otherwise this
    -- would never complete). We don’t need to use the values, so we 'gather' the
    -- nondeterministic values into @()@.
-      withOracle prevCache (gatherM (const ()) (recur m))) lowerBound
+      withOracle prevCache (gatherM (const ()) (recur m)))
  maybe empty scatter (cacheLookup c cache)


@ -94,10 +110,10 @@ convergingModules recur m = do
 --
 --   This applies the Kleene fixed-point theorem to finitize a monotone action. cf https://en.wikipedia.org/wiki/Kleene_fixed-point_theorem
 converge :: (Eq a, Monad m)
-         => (a -> m a) -- ^ A monadic action to perform at each iteration, starting from the result of the previous iteration or from the seed value for the first iteration.
-         -> a          -- ^ An initial seed value to iterate from.
+         => a          -- ^ An initial seed value to iterate from.
+         -> (a -> m a) -- ^ A monadic action to perform at each iteration, starting from the result of the previous iteration or from the seed value for the first iteration.
         -> m a        -- ^ A computation producing the least fixed point (the first value at which the actions converge).
-converge f = loop
+converge seed f = loop seed
  where loop x = do
          x' <- f x
          if x' == x then
@ -106,11 +122,11 @@ converge f = loop
            loop x'

 -- | Nondeterministically write each of a collection of stores & return their associated results.
-scatter :: (Foldable t, Members '[NonDet, State (Heap location (Cell location) value)] effects) => t (a, Heap location (Cell location) value) -> Evaluator location value effects a
-scatter = foldMapA (\ (value, heap') -> putHeap heap' $> value)
+scatter :: (Foldable t, Members '[NonDet, State (Heap location (Cell location) value)] effects) => t (Cached location (Cell location) value) -> TermEvaluator term location value effects value
+scatter = foldMapA (\ (Cached value heap') -> TermEvaluator (putHeap heap') $> value)


-caching :: Alternative f => Evaluator location value (NonDet ': Reader (Cache term location (Cell location) value) ': State (Cache term location (Cell location) value) ': effects) a -> Evaluator location value effects (f a, Cache term location (Cell location) value)
+caching :: Alternative f => TermEvaluator term location value (NonDet ': Reader (Cache term location (Cell location) value) ': State (Cache term location (Cell location) value) ': effects) a -> TermEvaluator term location value effects (f a, Cache term location (Cell location) value)
 caching
  = runState lowerBound
  . runReader lowerBound
--- a/src/Analysis/Abstract/Collecting.hs
+++ b/src/Analysis/Abstract/Collecting.hs
@ -18,12 +18,12 @@ collectingTerms :: ( Foldable (Cell location)
                   , Ord location
                   , ValueRoots location value
                   )
-                => SubtermAlgebra (Base term) term (Evaluator location value effects value)
-                -> SubtermAlgebra (Base term) term (Evaluator location value effects value)
+                => SubtermAlgebra (Base term) term (TermEvaluator term location value effects value)
+                -> SubtermAlgebra (Base term) term (TermEvaluator term location value effects value)
 collectingTerms recur term = do
-  roots <- askRoots
+  roots <- TermEvaluator askRoots
  v <- recur term
-  v <$ modifyHeap (gc (roots <> valueRoots v))
+  v <$ TermEvaluator (modifyHeap (gc (roots <> valueRoots v)))

 -- | Collect any addresses in the heap not rooted in or reachable from the given 'Live' set.
 gc :: ( Ord location
@ -51,5 +51,5 @@ reachable roots heap = go mempty roots
            _           -> seen)


-providingLiveSet :: Evaluator location value (Reader (Live location value) ': effects) a -> Evaluator location value effects a
+providingLiveSet :: Effectful (m location value) => m location value (Reader (Live location value) ': effects) a -> m location value effects a
 providingLiveSet = runReader lowerBound
--- a/src/Analysis/Abstract/Dead.hs
+++ b/src/Analysis/Abstract/Dead.hs
@ -6,7 +6,7 @@ module Analysis.Abstract.Dead
 , providingDeadSet
 ) where

-import Control.Abstract.Evaluator
+import Control.Abstract
 import Data.Abstract.Module
 import Data.Semigroup.Reducer as Reducer
 import Data.Semilattice.Lower
@ -20,11 +20,11 @@ newtype Dead term = Dead { unDead :: Set term }
 deriving instance Ord term => Reducer term (Dead term)

 -- | Update the current 'Dead' set.
-killAll :: Member (State (Dead term)) effects => Dead term -> Evaluator location value effects ()
+killAll :: Member (State (Dead term)) effects => Dead term -> TermEvaluator term location value effects ()
 killAll = put

 -- | Revive a single term, removing it from the current 'Dead' set.
-revive :: (Member (State (Dead term)) effects, Ord term) => term -> Evaluator location value effects ()
+revive :: (Member (State (Dead term)) effects, Ord term) => term -> TermEvaluator term location value effects ()
 revive t = modify' (Dead . delete t . unDead)

 -- | Compute the set of all subterms recursively.
@ -36,8 +36,8 @@ revivingTerms :: ( Corecursive term
                 , Member (State (Dead term)) effects
                 , Ord term
                 )
-              => SubtermAlgebra (Base term) term (Evaluator location value effects a)
-              -> SubtermAlgebra (Base term) term (Evaluator location value effects a)
+              => SubtermAlgebra (Base term) term (TermEvaluator term location value effects a)
+              -> SubtermAlgebra (Base term) term (TermEvaluator term location value effects a)
 revivingTerms recur term = revive (embedSubterm term) *> recur term

 killingModules :: ( Foldable (Base term)
@ -45,9 +45,9 @@ killingModules :: ( Foldable (Base term)
                  , Ord term
                  , Recursive term
                  )
-               => SubtermAlgebra Module term (Evaluator location value effects a)
-               -> SubtermAlgebra Module term (Evaluator location value effects a)
+               => SubtermAlgebra Module term (TermEvaluator term location value effects a)
+               -> SubtermAlgebra Module term (TermEvaluator term location value effects a)
 killingModules recur m = killAll (subterms (subterm (moduleBody m))) *> recur m

-providingDeadSet :: Evaluator location value (State (Dead term) ': effects) a -> Evaluator location value effects (a, Dead term)
+providingDeadSet :: TermEvaluator term location value (State (Dead term) ': effects) a -> TermEvaluator term location value effects (a, Dead term)
 providingDeadSet = runState lowerBound
--- a/src/Analysis/Abstract/Graph.hs
+++ b/src/Analysis/Abstract/Graph.hs
@ -61,8 +61,8 @@ graphingTerms :: ( Element Syntax.Identifier syntax
                            ] effects
                 , term ~ Term (Sum syntax) ann
                 )
-              => SubtermAlgebra (Base term) term (Evaluator (Located location) value effects a)
-              -> SubtermAlgebra (Base term) term (Evaluator (Located location) value effects a)
+              => SubtermAlgebra (Base term) term (TermEvaluator term (Located location) value effects a)
+              -> SubtermAlgebra (Base term) term (TermEvaluator term (Located location) value effects a)
 graphingTerms recur term@(In _ syntax) = do
  case projectSum syntax of
    Just (Syntax.Identifier name) -> do
@ -76,17 +76,17 @@ graphingLoadErrors :: Members '[ Reader ModuleInfo
                               , Resumable (LoadError location value)
                               , State (Graph Vertex)
                               ] effects
-                   => SubtermAlgebra (Base term) term (Evaluator location value effects a)
-                   -> SubtermAlgebra (Base term) term (Evaluator location value effects a)
-graphingLoadErrors recur term = recur term `resumeLoadError` (\ (ModuleNotFound name) -> moduleInclusion (Module (BC.pack name)) *> moduleNotFound name)
+                   => SubtermAlgebra (Base term) term (TermEvaluator term location value effects a)
+                   -> SubtermAlgebra (Base term) term (TermEvaluator term location value effects a)
+graphingLoadErrors recur term = TermEvaluator (runTermEvaluator (recur term) `resumeLoadError` (\ (ModuleNotFound name) -> moduleInclusion (Module (BC.pack name)) *> moduleNotFound name))

 -- | Add vertices to the graph for evaluated modules and the packages containing them.
 graphingModules :: Members '[ Reader ModuleInfo
                            , Reader PackageInfo
                            , State (Graph Vertex)
                            ] effects
-               => SubtermAlgebra Module term (Evaluator location value effects a)
-               -> SubtermAlgebra Module term (Evaluator location value effects a)
+               => SubtermAlgebra Module term (TermEvaluator term location value effects a)
+               -> SubtermAlgebra Module term (TermEvaluator term location value effects a)
 graphingModules recur m = do
  let name = BC.pack (modulePath (moduleInfo m))
  packageInclusion (Module name)
@ -132,9 +132,9 @@ variableDefinition :: ( Member (Reader (Environment (Located location) value)) e
                      , Member (State (Graph Vertex)) effects
                      )
                   => Name
-                   -> Evaluator (Located location) value effects ()
+                   -> TermEvaluator term (Located location) value effects ()
 variableDefinition name = do
-  graph <- maybe lowerBound (moduleGraph . locationModule . unAddress) <$> lookupEnv name
+  graph <- maybe lowerBound (moduleGraph . locationModule . unAddress) <$> TermEvaluator (lookupEnv name)
  appendGraph (vertex (Variable (unName name)) `connect` graph)

 appendGraph :: (Effectful m, Member (State (Graph Vertex)) effects) => Graph Vertex -> m effects ()
--- a/src/Analysis/Abstract/Tracing.hs
+++ b/src/Analysis/Abstract/Tracing.hs
@ -21,12 +21,12 @@ tracingTerms :: ( Corecursive term
                , Reducer (Configuration term location (Cell location) value) (trace (Configuration term location (Cell location) value))
                )
             => trace (Configuration term location (Cell location) value)
-             -> SubtermAlgebra (Base term) term (Evaluator location value effects a)
-             -> SubtermAlgebra (Base term) term (Evaluator location value effects a)
+             -> SubtermAlgebra (Base term) term (TermEvaluator term location value effects a)
+             -> SubtermAlgebra (Base term) term (TermEvaluator term location value effects a)
 tracingTerms proxy recur term = getConfiguration (embedSubterm term) >>= trace . (`asTypeOf` proxy) . Reducer.unit >> recur term

-trace :: Member (Writer (trace (Configuration term location (Cell location) value))) effects => trace (Configuration term location (Cell location) value) -> Evaluator location value effects ()
+trace :: Member (Writer (trace (Configuration term location (Cell location) value))) effects => trace (Configuration term location (Cell location) value) -> TermEvaluator term location value effects ()
 trace = tell

-tracing :: Monoid (trace (Configuration term location (Cell location) value)) => Evaluator location value (Writer (trace (Configuration term location (Cell location) value)) ': effects) a -> Evaluator location value effects (a, trace (Configuration term location (Cell location) value))
+tracing :: Monoid (trace (Configuration term location (Cell location) value)) => TermEvaluator term location value (Writer (trace (Configuration term location (Cell location) value)) ': effects) a -> TermEvaluator term location value effects (a, trace (Configuration term location (Cell location) value))
 tracing = runWriter
--- a/src/Analysis/CallGraph.hs
+++ b/src/Analysis/CallGraph.hs
@ -1,88 +0,0 @@
-{-# LANGUAGE ScopedTypeVariables, TypeFamilies, UndecidableInstances #-}
-module Analysis.CallGraph
-( CallGraph
-, renderCallGraph
-, buildCallGraph
-, CallGraphAlgebra(..)
-) where
-
-import Algebra.Graph.Export.Dot
-import Data.Abstract.FreeVariables
-import Data.Graph
-import qualified Data.Syntax as Syntax
-import qualified Data.Syntax.Declaration as Declaration
-import Data.Term
-import Prologue
-
-type CallGraph = Graph Name
-
-- | Build the 'CallGraph' for a 'Term' recursively.
-buildCallGraph :: (CallGraphAlgebra syntax, FreeVariables1 syntax, Functor syntax) => Term syntax ann -> [Name] -> CallGraph
-buildCallGraph = foldSubterms callGraphAlgebra
-
-
-- | Render a 'CallGraph' to a 'ByteString' in DOT notation.
-renderCallGraph :: CallGraph -> ByteString
-renderCallGraph = export (defaultStyle unName)
-
-
-- | Types which contribute to a 'CallGraph'. There is exactly one instance of this typeclass; customizing the 'CallGraph's for a new type is done by defining an instance of 'CustomCallGraphAlgebra' instead.
--
--   This typeclass employs the Advanced Overlap techniques designed by Oleg Kiselyov & Simon Peyton Jones: https://wiki.haskell.org/GHC/AdvancedOverlap.
-class CallGraphAlgebra syntax where
-  -- | A 'SubtermAlgebra' computing the 'CallGraph' for a piece of @syntax@.
-  callGraphAlgebra :: FreeVariables term => syntax (Subterm term ([Name] -> CallGraph)) -> [Name] -> CallGraph
-
-instance (CallGraphAlgebraStrategy syntax ~ strategy, CallGraphAlgebraWithStrategy strategy syntax) => CallGraphAlgebra syntax where
-  callGraphAlgebra = callGraphAlgebraWithStrategy (Proxy :: Proxy strategy)
-
-
-- | Types whose contribution to a 'CallGraph' is customized. If an instance’s definition is not being used, ensure that the type is mapped to 'Custom' in the 'CallGraphAlgebraStrategy'.
-class CustomCallGraphAlgebra syntax where
-  customCallGraphAlgebra :: FreeVariables term => syntax (Subterm term ([Name] -> CallGraph)) -> [Name] -> CallGraph
-
-- | 'Declaration.Function's produce a vertex for their name, with edges to any free variables in their body.
-instance CustomCallGraphAlgebra Declaration.Function where
-  customCallGraphAlgebra Declaration.Function{..} bound = foldMap vertex (freeVariables (subterm functionName)) `connect` subtermValue functionBody (foldMap (freeVariables . subterm) functionParameters <> bound)
-
-- | 'Declaration.Method's produce a vertex for their name, with edges to any free variables in their body.
-instance CustomCallGraphAlgebra Declaration.Method where
-  customCallGraphAlgebra Declaration.Method{..} bound = foldMap vertex (freeVariables (subterm methodName)) `connect` subtermValue methodBody (foldMap (freeVariables . subterm) methodParameters <> bound)
-
-- | 'Syntax.Identifier's produce a vertex iff it’s unbound in the 'Set'.
-instance CustomCallGraphAlgebra Syntax.Identifier where
-  customCallGraphAlgebra (Syntax.Identifier name) bound
-    | name `elem` bound = lowerBound
-    | otherwise         = vertex name
-
-instance Apply CallGraphAlgebra syntaxes => CustomCallGraphAlgebra (Sum syntaxes) where
-  customCallGraphAlgebra = apply @CallGraphAlgebra callGraphAlgebra
-
-instance CallGraphAlgebra syntax => CustomCallGraphAlgebra (TermF syntax a) where
-  customCallGraphAlgebra = callGraphAlgebra . termFOut
-
-
-- | The mechanism selecting 'Default'/'Custom' implementations for 'callGraphAlgebra' depending on the @syntax@ type.
-class CallGraphAlgebraWithStrategy (strategy :: Strategy) syntax where
-  callGraphAlgebraWithStrategy :: FreeVariables term => proxy strategy -> syntax (Subterm term ([Name] -> CallGraph)) -> [Name] -> CallGraph
-
-- | The 'Default' definition of 'callGraphAlgebra' combines all of the 'CallGraph's within the @syntax@ 'Monoid'ally.
-instance Foldable syntax => CallGraphAlgebraWithStrategy 'Default syntax where
-  callGraphAlgebraWithStrategy _ = foldMap subtermValue
-
-- | The 'Custom' strategy calls out to the 'customCallGraphAlgebra' method.
-instance CustomCallGraphAlgebra syntax => CallGraphAlgebraWithStrategy 'Custom syntax where
-  callGraphAlgebraWithStrategy _ = customCallGraphAlgebra
-
-
-- | Which instance of 'CustomCallGraphAlgebra' to use for a given @syntax@ type.
-data Strategy = Default | Custom
-
-- | A mapping of @syntax@ types onto 'Strategy's.
-type family CallGraphAlgebraStrategy syntax where
-  CallGraphAlgebraStrategy Declaration.Function = 'Custom
-  CallGraphAlgebraStrategy Declaration.Method = 'Custom
-  CallGraphAlgebraStrategy Syntax.Identifier = 'Custom
-  CallGraphAlgebraStrategy (Sum fs) = 'Custom
-  CallGraphAlgebraStrategy (TermF f a) = 'Custom
-  CallGraphAlgebraStrategy a = 'Default
--- a/src/Control/Abstract.hs
+++ b/src/Control/Abstract.hs
@ -12,4 +12,5 @@ import Control.Abstract.Heap as X
 import Control.Abstract.Goto as X
 import Control.Abstract.Modules as X
 import Control.Abstract.Roots as X
+import Control.Abstract.TermEvaluator as X
 import Control.Abstract.Value as X
--- a/src/Control/Abstract/Addressable.hs
+++ b/src/Control/Abstract/Addressable.hs
@ -12,7 +12,7 @@ import Data.Semigroup.Reducer
 import Prologue

 -- | Defines 'alloc'ation and 'deref'erencing of 'Address'es in a Heap.
-class Ord location => Addressable location effects where
+class (Ord location, Show location) => Addressable location effects where
  derefCell :: Address location value -> Cell location value -> Evaluator location value effects (Maybe value)

  allocLoc :: Name -> Evaluator location value effects location
@ -76,7 +76,7 @@ variable name = lookupEnv name >>= maybe (freeVariableError name) deref

 -- | 'Precise' locations are always 'alloc'ated a fresh 'Address', and 'deref'erence to the 'Latest' value written.
 instance Member Fresh effects => Addressable Precise effects where
-  derefCell _ = pure . unLatest
+  derefCell _ = pure . getLast . unLatest
  allocLoc _ = Precise <$> fresh

 -- | 'Monovariant' locations 'alloc'ate one 'Address' per unique variable name, and 'deref'erence once per stored value, nondeterministically.
@ -122,8 +122,8 @@ instance Eq location => Eq1 (AddressError location value) where
 throwAddressError :: Member (Resumable (AddressError location value)) effects => AddressError location value resume -> Evaluator location value effects resume
 throwAddressError = throwResumable

-runAddressError :: Evaluator location value (Resumable (AddressError location value) ': effects) a -> Evaluator location value effects (Either (SomeExc (AddressError location value)) a)
+runAddressError :: Effectful (m location value) => m location value (Resumable (AddressError location value) ': effects) a -> m location value effects (Either (SomeExc (AddressError location value)) a)
 runAddressError = runResumable

-runAddressErrorWith :: (forall resume . AddressError location value resume -> Evaluator location value effects resume) -> Evaluator location value (Resumable (AddressError location value) ': effects) a -> Evaluator location value effects a
+runAddressErrorWith :: Effectful (m location value) => (forall resume . AddressError location value resume -> m location value effects resume) -> m location value (Resumable (AddressError location value) ': effects) a -> m location value effects a
 runAddressErrorWith = runResumableWith
--- a/src/Control/Abstract/Configuration.hs
+++ b/src/Control/Abstract/Configuration.hs
@ -5,11 +5,11 @@ module Control.Abstract.Configuration
 ) where

 import Control.Abstract.Environment
-import Control.Abstract.Evaluator
 import Control.Abstract.Heap
 import Control.Abstract.Roots
+import Control.Abstract.TermEvaluator
 import Data.Abstract.Configuration

 -- | Get the current 'Configuration' with a passed-in term.
-getConfiguration :: Members '[Reader (Live location value), State (Environment location value), State (Heap location (Cell location) value)] effects => term -> Evaluator location value effects (Configuration term location (Cell location) value)
-getConfiguration term = Configuration term <$> askRoots <*> getEnv <*> getHeap
+getConfiguration :: Members '[Reader (Live location value), State (Environment location value), State (Heap location (Cell location) value)] effects => term -> TermEvaluator term location value effects (Configuration term location (Cell location) value)
+getConfiguration term = Configuration term <$> TermEvaluator askRoots <*> TermEvaluator getEnv <*> TermEvaluator getHeap
--- a/src/Control/Abstract/Environment.hs
+++ b/src/Control/Abstract/Environment.hs
@ -82,8 +82,8 @@ instance Eq1 (EnvironmentError value) where liftEq _ (FreeVariable n1) (FreeVari
 freeVariableError :: Member (Resumable (EnvironmentError value)) effects => Name -> Evaluator location value effects value
 freeVariableError = throwResumable . FreeVariable

-runEnvironmentError :: Evaluator location value (Resumable (EnvironmentError value) ': effects) a -> Evaluator location value effects (Either (SomeExc (EnvironmentError value)) a)
+runEnvironmentError :: Effectful (m location value) => m location value (Resumable (EnvironmentError value) ': effects) a -> m location value effects (Either (SomeExc (EnvironmentError value)) a)
 runEnvironmentError = runResumable

-runEnvironmentErrorWith :: (forall resume . EnvironmentError value resume -> Evaluator location value effects resume) -> Evaluator location value (Resumable (EnvironmentError value) ': effects) a -> Evaluator location value effects a
+runEnvironmentErrorWith :: Effectful (m location value) => (forall resume . EnvironmentError value resume -> m location value effects resume) -> m location value (Resumable (EnvironmentError value) ': effects) a -> m location value effects a
 runEnvironmentErrorWith = runResumableWith
--- a/src/Control/Abstract/Modules.hs
+++ b/src/Control/Abstract/Modules.hs
@ -128,10 +128,10 @@ moduleNotFound = throwResumable . ModuleNotFound
 resumeLoadError :: Member (Resumable (LoadError location value)) effects => Evaluator location value effects a -> (forall resume . LoadError location value resume -> Evaluator location value effects resume) -> Evaluator location value effects a
 resumeLoadError = catchResumable

-runLoadError :: Evaluator location value (Resumable (LoadError location value) ': effects) a -> Evaluator location value effects (Either (SomeExc (LoadError location value)) a)
+runLoadError :: Effectful (m location value) => m location value (Resumable (LoadError location value) ': effects) a -> m location value effects (Either (SomeExc (LoadError location value)) a)
 runLoadError = runResumable

-runLoadErrorWith :: (forall resume . LoadError location value resume -> Evaluator location value effects resume) -> Evaluator location value (Resumable (LoadError location value) ': effects) a -> Evaluator location value effects a
+runLoadErrorWith :: Effectful (m location value) => (forall resume . LoadError location value resume -> m location value effects resume) -> m location value (Resumable (LoadError location value) ': effects) a -> m location value effects a
 runLoadErrorWith = runResumableWith


--- a/src/Control/Abstract/TermEvaluator.hs
+++ b/src/Control/Abstract/TermEvaluator.hs
@ -0,0 +1,29 @@
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+module Control.Abstract.TermEvaluator
+( TermEvaluator(..)
+, raiseHandler
+, module X
+) where
+
+import Control.Abstract.Evaluator
+import Control.Monad.Effect           as X
+import Control.Monad.Effect.Fail      as X
+import Control.Monad.Effect.Fresh     as X
+import Control.Monad.Effect.NonDet    as X
+import Control.Monad.Effect.Reader    as X
+import Control.Monad.Effect.Resumable as X
+import Control.Monad.Effect.State     as X
+import Control.Monad.Effect.Trace     as X
+import Prologue
+
+-- | Evaluators specialized to some specific term type.
+--
+--   This is used to constrain the term type so that inference for analyses can resolve it correctly, but should not be used for any of the term-agonstic machinery like builtins, Evaluatable instances, the mechanics of the heap & environment, etc.
+newtype TermEvaluator term location value effects a = TermEvaluator { runTermEvaluator :: Evaluator location value effects a }
+  deriving (Applicative, Effectful, Functor, Monad)
+
+deriving instance Member NonDet effects => Alternative (TermEvaluator term location value effects)
+
+
+raiseHandler :: (Evaluator location value effects a -> Evaluator location value effects' a') -> (TermEvaluator term location value effects a -> TermEvaluator term location value effects' a')
+raiseHandler f = TermEvaluator . f . runTermEvaluator
--- a/src/Data/Abstract/Address.hs
+++ b/src/Data/Abstract/Address.hs
@ -4,21 +4,23 @@ module Data.Abstract.Address where
 import Data.Abstract.FreeVariables
 import Data.Abstract.Module (ModuleInfo)
 import Data.Abstract.Package (PackageInfo)
+import Data.Monoid (Last(..))
 import Data.Semigroup.Reducer
 import Data.Semilattice.Lower
+import Data.Set as Set
 import Prologue

 -- | An abstract address with a @location@ pointing to a variable of type @value@.
-newtype Address location value = Address location
-  deriving (Eq, Ord, Show)
-
-unAddress :: Address location value -> location
-unAddress (Address location) = location
+newtype Address location value = Address { unAddress :: location }
+  deriving (Eq, Ord)

 instance Eq   location => Eq1   (Address location) where liftEq          _ a b = unAddress a    ==     unAddress b
 instance Ord  location => Ord1  (Address location) where liftCompare     _ a b = unAddress a `compare` unAddress b
 instance Show location => Show1 (Address location) where liftShowsPrec _ _     = showsPrec

+instance Show location => Show (Address location value) where
+  showsPrec d = showsPrec d . unAddress
+

 class Location location where
  -- | The type into which stored values will be written for a given location type.
@ -26,19 +28,25 @@ class Location location where


 -- | 'Precise' models precise store semantics where only the 'Latest' value is taken. Everything gets it's own address (always makes a new allocation) which makes for a larger store.
-newtype Precise = Precise Int
-  deriving (Eq, Ord, Show)
+newtype Precise = Precise { unPrecise :: Int }
+  deriving (Eq, Ord)

 instance Location Precise where
  type Cell Precise = Latest

+instance Show Precise where
+  showsPrec d = showsUnaryWith showsPrec "Precise" d . unPrecise
+

 -- | 'Monovariant' models using one address for a particular name. It trackes the set of values that a particular address takes and uses it's name to lookup in the store and only allocation if new.
-newtype Monovariant = Monovariant Name
-  deriving (Eq, Ord, Show)
+newtype Monovariant = Monovariant { unMonovariant :: Name }
+  deriving (Eq, Ord)

 instance Location Monovariant where
-  type Cell Monovariant = Set
+  type Cell Monovariant = All
+
+instance Show Monovariant where
+  showsPrec d = showsUnaryWith showsPrec "Monovariant" d . unName . unMonovariant


 data Located location = Located
@ -53,22 +61,23 @@ instance Location (Located location) where


 -- | A cell holding a single value. Writes will replace any prior value.
--   This is isomorphic to 'Last' from Data.Monoid, but is more convenient
--   because it has a 'Reducer' instance.
-newtype Latest value = Latest (Maybe value)
-  deriving (Eq, Foldable, Functor, Lower, Ord, Show, Traversable)
-
-unLatest :: Latest value -> Maybe value
-unLatest (Latest value) = value
-
-instance Semigroup (Latest value) where
-  a <> Latest Nothing = a
-  _ <> b              = b
-
-- | 'Option' semantics rather than that of 'Maybe', which is broken.
-instance Monoid (Latest value) where
-  mappend = (<>)
-  mempty  = Latest Nothing
+--
+--   This is equivalent to 'Data.Monoid.Last', but with a 'Show' instance designed to minimize the amount of text we have to scroll past in ghci.
+newtype Latest value = Latest { unLatest :: Last value }
+  deriving (Eq, Foldable, Functor, Lower, Monoid, Semigroup, Ord, Traversable)

 instance Reducer value (Latest value) where
-  unit = Latest . Just
+  unit = Latest . unit . Just
+
+instance Show value => Show (Latest value) where
+  showsPrec d = showsPrec d . getLast . unLatest
+
+
+-- | A cell holding all values written to its address.
+--
+--   This is equivalent to 'Set', but with a 'Show' instance designed to minimize the amount of text we have to scroll past in ghci.
+newtype All value = All { unAll :: Set value }
+  deriving (Eq, Foldable, Lower, Monoid, Ord, Reducer value, Semigroup)
+
+instance Show value => Show (All value) where
+  showsPrec d = showsPrec d . Set.toList . unAll
--- a/src/Data/Abstract/Cache.hs
+++ b/src/Data/Abstract/Cache.hs
@ -8,19 +8,30 @@ import Data.Semilattice.Lower
 import Prologue

 -- | A map of 'Configuration's to 'Set's of resulting values & 'Heap's.
-newtype Cache term location cell value = Cache { unCache :: Monoidal.Map (Configuration term location cell value) (Set (value, Heap location cell value)) }
-  deriving (Eq, Lower, Monoid, Ord, Reducer (Configuration term location cell value, (value, Heap location cell value)), Show, Semigroup)
+newtype Cache term location cell value = Cache { unCache :: Monoidal.Map (Configuration term location cell value) (Set (Cached location cell value)) }
+  deriving (Eq, Lower, Monoid, Ord, Reducer (Configuration term location cell value, Cached location cell value), Semigroup)
+
+data Cached location cell value = Cached
+  { cachedValue :: value
+  , cachedHeap  :: Heap location cell value
+  }
+  deriving (Eq, Ord, Show)
+

 type Cacheable term location cell value = (Ord (cell value), Ord location, Ord term, Ord value)

 -- | Look up the resulting value & 'Heap' for a given 'Configuration'.
-cacheLookup :: Cacheable term location cell value => Configuration term location cell value -> Cache term location cell value -> Maybe (Set (value, Heap location cell value))
+cacheLookup :: Cacheable term location cell value => Configuration term location cell value -> Cache term location cell value -> Maybe (Set (Cached location cell value))
 cacheLookup key = Monoidal.lookup key . unCache

 -- | Set the resulting value & 'Heap' for a given 'Configuration', overwriting any previous entry.
-cacheSet :: Cacheable term location cell value => Configuration term location cell value -> Set (value, Heap location cell value) -> Cache term location cell value -> Cache term location cell value
+cacheSet :: Cacheable term location cell value => Configuration term location cell value -> Set (Cached location cell value) -> Cache term location cell value -> Cache term location cell value
 cacheSet key value = Cache . Monoidal.insert key value . unCache

 -- | Insert the resulting value & 'Heap' for a given 'Configuration', appending onto any previous entry.
-cacheInsert :: Cacheable term location cell value => Configuration term location cell value -> (value, Heap location cell value) -> Cache term location cell value -> Cache term location cell value
+cacheInsert :: Cacheable term location cell value => Configuration term location cell value -> Cached location cell value -> Cache term location cell value -> Cache term location cell value
 cacheInsert = curry cons
+
+
+instance (Show term, Show location, Show (cell value), Show value) => Show (Cache term location cell value) where
+  showsPrec d = showsUnaryWith showsPrec "Cache" d . map (second toList) . Monoidal.pairs . unCache
--- a/src/Data/Abstract/Declarations.hs
+++ b/src/Data/Abstract/Declarations.hs
@ -1,4 +1,4 @@
-{-# LANGUAGE UndecidableInstances #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving, UndecidableInstances #-}
 module Data.Abstract.Declarations  where

 import Data.Abstract.FreeVariables
@ -18,8 +18,10 @@ class Declarations1 syntax where
 instance Declarations t => Declarations (Subterm t a) where
  declaredName = declaredName . subterm

-instance (FreeVariables1 syntax, Declarations1 syntax, Functor syntax) => Declarations (Term syntax ann) where
-  declaredName = liftDeclaredName freeVariables . termOut
+deriving instance (Declarations1 syntax, FreeVariables1 syntax) => Declarations (Term syntax ann)
+
+instance (FreeVariables recur, Declarations1 syntax) => Declarations (TermF syntax ann recur) where
+  declaredName = liftDeclaredName freeVariables . termFOut

 instance (Apply Declarations1 fs) => Declarations1 (Sum fs) where
  liftDeclaredName f = apply @Declarations1 (liftDeclaredName f)
--- a/src/Data/Abstract/Environment.hs
+++ b/src/Data/Abstract/Environment.hs
@ -37,11 +37,8 @@ import qualified Data.List.NonEmpty as NonEmpty
 -- | A LIFO stack of maps of names to addresses, representing a lexically-scoped evaluation environment.
 --   All behaviors can be assumed to be frontmost-biased: looking up "a" will check the most specific
 --   scope for "a", then the next, and so on.
-newtype Environment location value = Environment (NonEmpty (Map.Map Name location))
-  deriving (Eq, Ord, Show)
-
-unEnvironment :: Environment location value -> NonEmpty (Map.Map Name location)
-unEnvironment (Environment env) = env
+newtype Environment location value = Environment { unEnvironment :: NonEmpty (Map.Map Name location) }
+  deriving (Eq, Ord)

 instance Eq   location => Eq1   (Environment location) where liftEq      _ (Environment a) (Environment b) = a == b
 instance Ord  location => Ord1  (Environment location) where liftCompare _ (Environment a) (Environment b) = a `compare` b
@ -88,7 +85,7 @@ mergeNewer (Environment a) (Environment b) =
 -- | Extract an association list of bindings from an 'Environment'.
 --
 -- >>> pairs shadowed
-- [(Name {unName = "foo"},Address (Precise 1))]
+-- [(Name {unName = "foo"},Precise 1)]
 pairs :: Environment location value -> [(Name, Address location value)]
 pairs = map (second Address) . Map.toList . fold . unEnvironment

@ -98,7 +95,7 @@ unpairs = fromList
 -- | Lookup a 'Name' in the environment.
 --
 -- >>> lookup (name "foo") shadowed
-- Just (Address (Precise 1))
+-- Just (Precise 1)
 lookup :: Name -> Environment location value -> Maybe (Address location value)
 lookup k = fmap Address . foldMapA (Map.lookup k) . unEnvironment

@ -109,7 +106,7 @@ insert name (Address value) (Environment (a :| as)) = Environment (Map.insert na
 -- | Remove a 'Name' from the environment.
 --
 -- >>> delete (name "foo") shadowed
-- Environment (fromList [] :| [])
+-- Environment []
 delete :: Name -> Environment location value -> Environment location value
 delete name = trim . Environment . fmap (Map.delete name) . unEnvironment

@ -143,3 +140,6 @@ addresses = fromAddresses . map snd . pairs


 instance Lower (Environment location value) where lowerBound = emptyEnv
+
+instance Show location => Show (Environment location value) where
+  showsPrec d = showsUnaryWith showsPrec "Environment" d . map (first unName) . pairs
--- a/src/Data/Abstract/Evaluatable.hs
+++ b/src/Data/Abstract/Evaluatable.hs
@ -17,10 +17,11 @@ module Data.Abstract.Evaluatable
 , Modules
 ) where

-import Control.Abstract as X hiding (Goto(..), LoopControl(..), Modules(..), Return(..))
+import Control.Abstract as X hiding (Goto(..), LoopControl(..), Modules(..), Return(..), TermEvaluator(..))
 import Control.Abstract.Evaluator (LoopControl, Return(..))
 import Control.Abstract.Goto (Goto(..))
 import Control.Abstract.Modules (Modules(..))
+import Control.Abstract.TermEvaluator (TermEvaluator(..))
 import Data.Abstract.Declarations as X
 import Data.Abstract.Environment as X
 import Data.Abstract.Exports as Exports
@ -84,10 +85,10 @@ data EvalError value resume where
  ExportError         :: ModulePath -> Name -> EvalError value ()
  EnvironmentLookupError :: value -> EvalError value value

-runEvalError :: Evaluator location value (Resumable (EvalError value) ': effects) a -> Evaluator location value effects (Either (SomeExc (EvalError value)) a)
+runEvalError :: Effectful (m value) => m value (Resumable (EvalError value) ': effects) a -> m value effects (Either (SomeExc (EvalError value)) a)
 runEvalError = runResumable

-runEvalErrorWith :: (forall resume . EvalError value resume -> Evaluator location value effects resume) -> Evaluator location value (Resumable (EvalError value) ': effects) a -> Evaluator location value effects a
+runEvalErrorWith :: Effectful (m value) => (forall resume . EvalError value resume -> m value effects resume) -> m value (Resumable (EvalError value) ': effects) a -> m value effects a
 runEvalErrorWith = runResumableWith

 -- | Evaluate a term within the context of the scoped environment of 'scopedEnvTerm'.
@ -135,10 +136,10 @@ deriving instance Show (Unspecialized a b)
 instance Show1 (Unspecialized a) where
  liftShowsPrec _ _ = showsPrec

-runUnspecialized :: Evaluator location value (Resumable (Unspecialized value) ': effects) a -> Evaluator location value effects (Either (SomeExc (Unspecialized value)) a)
+runUnspecialized :: Effectful (m value) => m value (Resumable (Unspecialized value) ': effects) a -> m value effects (Either (SomeExc (Unspecialized value)) a)
 runUnspecialized = runResumable

-runUnspecializedWith :: (forall resume . Unspecialized value resume -> Evaluator location value effects resume) -> Evaluator location value (Resumable (Unspecialized value) ': effects) a -> Evaluator location value effects a
+runUnspecializedWith :: Effectful (m value) => (forall resume . Unspecialized value resume -> m value effects resume) -> m value (Resumable (Unspecialized value) ': effects) a -> m value effects a
 runUnspecializedWith = runResumableWith


@ -202,43 +203,46 @@ evaluatePackageWith :: forall location term value inner inner' outer
                       , inner ~ (Goto inner' value ': inner')
                       , inner' ~ (LoopControl value ': Return value ': Reader ModuleInfo ': Modules location value ': State (Gotos location value (Reader Span ': Reader PackageInfo ': outer)) ': Reader Span ': Reader PackageInfo ': outer)
                       )
-                    => (SubtermAlgebra Module      term (Evaluator location value inner value) -> SubtermAlgebra Module      term (Evaluator location value inner value))
-                    -> (SubtermAlgebra (Base term) term (Evaluator location value inner value) -> SubtermAlgebra (Base term) term (Evaluator location value inner value))
+                    => (SubtermAlgebra Module      term (TermEvaluator term location value inner value) -> SubtermAlgebra Module      term (TermEvaluator term location value inner value))
+                    -> (SubtermAlgebra (Base term) term (TermEvaluator term location value inner value) -> SubtermAlgebra (Base term) term (TermEvaluator term location value inner value))
                    -> Package term
-                    -> Evaluator location value outer [value]
+                    -> TermEvaluator term location value outer [value]
 evaluatePackageWith analyzeModule analyzeTerm package
  = runReader (packageInfo package)
  . runReader lowerBound
  . fmap fst
  . runState (lowerBound :: Gotos location value (Reader Span ': Reader PackageInfo ': outer))
  . runReader (packageModules (packageBody package))
-  . runModules evalModule
  . withPrelude (packagePrelude (packageBody package))
+  . raiseHandler (runModules (runTermEvaluator . evalModule))
  $ traverse (uncurry evaluateEntryPoint) (ModuleTable.toPairs (packageEntryPoints (packageBody package)))
  where evalModule m
          = pairValueWithEnv
          . runInModule (moduleInfo m)
          . analyzeModule (subtermValue . moduleBody)
-          $ fmap (Subterm <*> foldSubterms (analyzeTerm eval)) m
+          $ fmap (Subterm <*> foldSubterms (analyzeTerm (TermEvaluator . eval . fmap (second runTermEvaluator)))) m

        runInModule info
          = runReader info
-          . runReturn
-          . runLoopControl
-          . runGoto Gotos getGotos
+          . raiseHandler runReturn
+          . raiseHandler runLoopControl
+          . raiseHandler (runGoto Gotos getGotos)

-        evaluateEntryPoint :: ModulePath -> Maybe Name -> Evaluator location value (Modules location value ': State (Gotos location value (Reader Span ': Reader PackageInfo ': outer)) ': Reader Span ': Reader PackageInfo ': outer) value
-        evaluateEntryPoint m sym = runInModule (ModuleInfo m) $ do
+        evaluateEntryPoint :: ModulePath -> Maybe Name -> TermEvaluator term location value (Modules location value ': State (Gotos location value (Reader Span ': Reader PackageInfo ': outer)) ': Reader Span ': Reader PackageInfo ': outer) value
+        evaluateEntryPoint m sym = runInModule (ModuleInfo m) . TermEvaluator $ do
          v <- maybe unit (pure . snd) <$> require m
          maybe v ((`call` []) <=< variable) sym

-        withPrelude Nothing a = a
-        withPrelude (Just prelude) a = do
-          _ <- runInModule moduleInfoFromCallStack $ do
+        evalPrelude prelude = raiseHandler (runModules (runTermEvaluator . evalModule)) $ do
+          _ <- runInModule moduleInfoFromCallStack . TermEvaluator $ do
            builtin "print" (closure ["s"] lowerBound (variable "s" >>= asString >>= trace . unpack >> unit))
            unit
-          preludeEnv <- fst <$> evalModule prelude
-          withDefaultEnvironment preludeEnv a
+          fst <$> evalModule prelude
+
+        withPrelude Nothing a = a
+        withPrelude (Just prelude) a = do
+          preludeEnv <- evalPrelude prelude
+          raiseHandler (withDefaultEnvironment preludeEnv) a

        -- TODO: If the set of exports is empty because no exports have been
        -- defined, do we export all terms, or no terms? This behavior varies across
@ -246,7 +250,7 @@ evaluatePackageWith analyzeModule analyzeTerm package
        filterEnv ports env
          | Exports.null ports = env
          | otherwise          = Exports.toEnvironment ports `mergeEnvs` overwrite (Exports.aliases ports) env
-        pairValueWithEnv action = flip (,) <$> action <*> (filterEnv <$> getExports <*> getEnv)
+        pairValueWithEnv action = flip (,) <$> action <*> (filterEnv <$> TermEvaluator getExports <*> TermEvaluator getEnv)

 newtype Gotos location value outer = Gotos { getGotos :: GotoTable (LoopControl value ': Return value ': Reader ModuleInfo ': Modules location value ': State (Gotos location value outer) ': outer) value }
  deriving (Lower)
--- a/src/Data/Abstract/Exports.hs
+++ b/src/Data/Abstract/Exports.hs
@ -16,11 +16,8 @@ import qualified Data.Map as Map
 import Data.Semilattice.Lower

 -- | A map of export names to an alias & address tuple.
-newtype Exports location value = Exports (Map.Map Name (Name, Maybe (Address location value)))
-  deriving (Eq, Lower, Monoid, Ord, Semigroup, Show)
-
-unExports :: Exports location value -> Map.Map Name (Name, Maybe (Address location value))
-unExports (Exports exports) = exports
+newtype Exports location value = Exports { unExports :: Map.Map Name (Name, Maybe (Address location value)) }
+  deriving (Eq, Lower, Monoid, Ord, Semigroup)

 null :: Exports location value -> Bool
 null = Map.null . unExports
@ -37,3 +34,7 @@ insert name alias address = Exports . Map.insert name (alias, address) . unExpor
 -- TODO: Should we filter for duplicates here?
 aliases :: Exports location value -> [(Name, Name)]
 aliases = Map.toList . fmap fst . unExports
+
+
+instance Show location => Show (Exports location value) where
+  showsPrec d = showsUnaryWith showsPrec "Exports" d . Map.toList . unExports
--- a/src/Data/Abstract/FreeVariables.hs
+++ b/src/Data/Abstract/FreeVariables.hs
@ -1,4 +1,4 @@
-{-# LANGUAGE DefaultSignatures, UndecidableInstances #-}
+{-# LANGUAGE DefaultSignatures, GeneralizedNewtypeDeriving, UndecidableInstances #-}
 module Data.Abstract.FreeVariables where

 import qualified Data.ByteString.Char8 as BC
@ -45,8 +45,10 @@ freeVariable term = case freeVariables term of
 instance (FreeVariables t) => FreeVariables (Subterm t a) where
  freeVariables = freeVariables . subterm

-instance (FreeVariables1 syntax, Functor syntax) => FreeVariables (Term syntax ann) where
-  freeVariables = cata (liftFreeVariables id)
+deriving instance FreeVariables1 syntax => FreeVariables (Term syntax ann)
+
+instance (FreeVariables recur, FreeVariables1 syntax) => FreeVariables (TermF syntax ann recur) where
+  freeVariables = liftFreeVariables freeVariables

 instance (FreeVariables1 syntax) => FreeVariables1 (TermF syntax ann) where
  liftFreeVariables f (In _ s) = liftFreeVariables f s
--- a/src/Data/Abstract/Heap.hs
+++ b/src/Data/Abstract/Heap.hs
@ -9,11 +9,8 @@ import Data.Semilattice.Lower
 import Prologue

 -- | A map of addresses onto cells holding their values.
-newtype Heap location cell value = Heap (Monoidal.Map location (cell value))
-  deriving (Eq, Foldable, Functor, Lower, Monoid, Ord, Semigroup, Show, Traversable)
-
-unHeap :: Heap location cell value -> Monoidal.Map location (cell value)
-unHeap (Heap heap) = heap
+newtype Heap location cell value = Heap { unHeap :: Monoidal.Map location (cell value) }
+  deriving (Eq, Foldable, Functor, Lower, Monoid, Ord, Semigroup, Traversable)

 deriving instance (Ord location, Reducer value (cell value)) => Reducer (location, value) (Heap location cell value)

@ -40,3 +37,8 @@ heapSize = Monoidal.size . unHeap
 -- | Restrict a 'Heap' to only those 'Address'es in the given 'Live' set (in essence garbage collecting the rest).
 heapRestrict :: Ord location => Heap location cell value -> Live location value -> Heap location cell value
 heapRestrict (Heap m) roots = Heap (Monoidal.filterWithKey (\ address _ -> Address address `liveMember` roots) m)
+
+
+
+instance (Show location, Show (cell value)) => Show (Heap location cell value) where
+  showsPrec d = showsUnaryWith showsPrec "Heap" d . Monoidal.pairs . unHeap
--- a/src/Data/Abstract/Live.hs
+++ b/src/Data/Abstract/Live.hs
@ -8,7 +8,7 @@ import Prologue

 -- | A set of live addresses (whether roots or reachable).
 newtype Live location value = Live { unLive :: Set location }
-  deriving (Eq, Lower, Monoid, Ord, Semigroup, Show)
+  deriving (Eq, Lower, Monoid, Ord, Semigroup)

 fromAddresses :: (Foldable t, Ord location) => t (Address location value) -> Live location value
 fromAddresses = Prologue.foldr liveInsert lowerBound
@ -36,3 +36,7 @@ liveMember addr = Set.member (unAddress addr) . unLive
 -- | Decompose a 'Live' set into a pair of one member address and the remaining set, or 'Nothing' if empty.
 liveSplit :: Live location value -> Maybe (Address location value, Live location value)
 liveSplit = fmap (bimap Address Live) . Set.minView . unLive
+
+
+instance Show location => Show (Live location value) where
+  showsPrec d = showsUnaryWith showsPrec "Live" d . Set.toList . unLive
--- a/src/Data/Abstract/ModuleTable.hs
+++ b/src/Data/Abstract/ModuleTable.hs
@ -21,11 +21,8 @@ import System.FilePath.Posix
 import GHC.Generics (Generic1)
 import Prelude hiding (lookup)

-newtype ModuleTable a = ModuleTable (Map.Map ModulePath a)
-  deriving (Eq, Foldable, Functor, Generic1, Lower, Monoid, Ord, Semigroup, Show, Traversable)
-
-unModuleTable :: ModuleTable a -> Map.Map ModulePath a
-unModuleTable (ModuleTable table) = table
+newtype ModuleTable a = ModuleTable { unModuleTable :: Map.Map ModulePath a }
+  deriving (Eq, Foldable, Functor, Generic1, Lower, Monoid, Ord, Semigroup, Traversable)

 singleton :: ModulePath -> a -> ModuleTable a
 singleton name = ModuleTable . Map.singleton name
@ -52,3 +49,7 @@ fromModules modules = ModuleTable (Map.fromListWith (<>) (map toEntry modules))

 toPairs :: ModuleTable a -> [(ModulePath, a)]
 toPairs = Map.toList . unModuleTable
+
+
+instance Show a => Show (ModuleTable a) where
+  showsPrec d = showsUnaryWith showsPrec "ModuleTable" d . toPairs
--- a/src/Data/Abstract/Type.hs
+++ b/src/Data/Abstract/Type.hs
@ -1,82 +1,104 @@
-{-# LANGUAGE GADTs, TypeFamilies, TypeOperators, UndecidableInstances #-}
+{-# LANGUAGE GADTs, RankNTypes, TypeFamilies, TypeOperators, UndecidableInstances #-}
 module Data.Abstract.Type
  ( Type (..)
  , TypeError (..)
  , runTypeError
+  , runTypeErrorWith
  , unify
  ) where

 import Control.Abstract
 import Data.Abstract.Environment as Env
-import Data.Align (alignWith)
+import Data.Semigroup.Foldable (foldMap1)
 import Data.Semigroup.Reducer (Reducer)
-import Prelude
 import Prologue hiding (TypeError)

 type TName = Int

 -- | A datatype representing primitive types and combinations thereof.
-data Type location
-  = Int                                   -- ^ Primitive int type.
-  | Bool                                  -- ^ Primitive boolean type.
-  | String                                -- ^ Primitive string type.
-  | Symbol                                -- ^ Type of unique symbols.
-  | Unit                                  -- ^ The unit type.
-  | Float                                 -- ^ Floating-point type.
-  | Rational                              -- ^ Rational type.
-  | Type location :-> Type location       -- ^ Binary function types.
-  | Var TName                             -- ^ A type variable.
-  | Product [Type location]               -- ^ N-ary products.
-  | Array [Type location]                 -- ^ Arrays. Note that this is heterogenous.
-  | Hash [(Type location, Type location)] -- ^ Heterogenous key-value maps.
-  | Object                                -- ^ Objects. Once we have some notion of inheritance we'll need to store a superclass.
-  | Null                                  -- ^ The null type. Unlike 'Unit', this unifies with any other type.
-  | Hole                                  -- ^ The hole type.
+data Type
+  = Int                 -- ^ Primitive int type.
+  | Bool                -- ^ Primitive boolean type.
+  | String              -- ^ Primitive string type.
+  | Symbol              -- ^ Type of unique symbols.
+  | Unit                -- ^ The unit type.
+  | Float               -- ^ Floating-point type.
+  | Rational            -- ^ Rational type.
+  | Type :-> Type       -- ^ Binary function types.
+  | Var TName           -- ^ A type variable.
+  | Type :* Type        -- ^ Binary products.
+  | Type :+ Type        -- ^ Binary sums.
+  | Void                -- ^ Uninhabited void type.
+  | Array Type          -- ^ Arrays.
+  | Hash [(Type, Type)] -- ^ Heterogenous key-value maps.
+  | Object              -- ^ Objects. Once we have some notion of inheritance we'll need to store a superclass.
+  | Null                -- ^ The null type. Unlike 'Unit', this unifies with any other type.
+  | Hole                -- ^ The hole type.
  deriving (Eq, Ord, Show)

+infixl 6 :+
+infixl 7 :*
+infixr 0 :->
+
+newtype Product = Product { getProduct :: Type }
+
+instance Semigroup Product where
+  Product a <> Product b = Product (a :* b)
+
+instance Monoid Product where
+  mempty = Product Unit
+  mappend = (<>)
+
+oneOrMoreProduct :: NonEmpty Type -> Type
+oneOrMoreProduct = getProduct . foldMap1 Product
+
+zeroOrMoreProduct :: [Type] -> Type
+zeroOrMoreProduct = maybe Unit oneOrMoreProduct . nonEmpty
+
 -- TODO: À la carte representation of types.

+-- | Errors representing failures in typechecking. Note that we should in general constrain allowable types by 'unify'ing, and thus throwing 'UnificationError's when constraints aren’t met, in order to allow uniform resumption with one or the other parameter type.
 data TypeError resume where
-  NumOpError       :: Type location -> Type location -> TypeError (Type location)
-  BitOpError       :: Type location -> Type location -> TypeError (Type location)
-  UnificationError :: Type location -> Type location -> TypeError (Type location)
-  SubscriptError   :: Type location -> Type location -> TypeError (Type location)
+  UnificationError :: Type -> Type -> TypeError Type

+deriving instance Eq   (TypeError resume)
+deriving instance Ord  (TypeError resume)
 deriving instance Show (TypeError resume)

-instance Show1 TypeError where
-  liftShowsPrec _ _ _ (NumOpError l r)       = showString "NumOpError " . shows [l, r]
-  liftShowsPrec _ _ _ (BitOpError l r)       = showString "BitOpError " . shows [l, r]
-  liftShowsPrec _ _ _ (UnificationError l r) = showString "UnificationError " . shows [l, r]
-  liftShowsPrec _ _ _ (SubscriptError l r)   = showString "SubscriptError " . shows [l, r]
+instance Eq1   TypeError where liftEq      _ (UnificationError a1 b1) (UnificationError a2 b2) = a1 == a2 && b1 == b2
+instance Ord1  TypeError where liftCompare _ (UnificationError a1 b1) (UnificationError a2 b2) = compare a1 a2 <> compare b1 b2
+instance Show1 TypeError where liftShowsPrec _ _ = showsPrec

-instance Eq1 TypeError where
-  liftEq eq (BitOpError a b) (BitOpError c d)             = a `eq` c && b `eq` d
-  liftEq eq (NumOpError a b) (NumOpError c d)             = a `eq` c && b `eq` d
-  liftEq eq (UnificationError a b) (UnificationError c d) = a `eq` c && b `eq` d
-  liftEq _ _ _                                           = False

-runTypeError :: Evaluator location value (Resumable TypeError ': effects) a -> Evaluator location value effects (Either (SomeExc TypeError) a)
+runTypeError :: Effectful m => m (Resumable TypeError ': effects) a -> m effects (Either (SomeExc TypeError) a)
 runTypeError = runResumable

+runTypeErrorWith :: Effectful m => (forall resume . TypeError resume -> m effects resume) -> m (Resumable TypeError ': effects) a -> m effects a
+runTypeErrorWith = runResumableWith
+
+
 -- | Unify two 'Type's.
-unify :: (Effectful m, Applicative (m effects), Member (Resumable TypeError) effects) => Type location -> Type location -> m effects (Type location)
+unify :: (Effectful m, Applicative (m effects), Member (Resumable TypeError) effects) => Type -> Type -> m effects Type
 unify (a1 :-> b1) (a2 :-> b2) = (:->) <$> unify a1 a2 <*> unify b1 b2
 unify a Null = pure a
 unify Null b = pure b
 -- FIXME: this should be constructing a substitution.
 unify (Var _) b = pure b
 unify a (Var _) = pure a
-unify (Product as) (Product bs) = Product <$> sequenceA (alignWith (these pure pure unify) as bs)
+unify (Array t1) (Array t2) = Array <$> unify t1 t2
+-- FIXME: unifying with sums should distribute nondeterministically.
+-- FIXME: ordering shouldn’t be significant for undiscriminated sums.
+unify (a1 :+ b1) (a2 :+ b2) = (:+) <$> unify a1 a2 <*> unify b1 b2
+unify (a1 :* b1) (a2 :* b2) = (:*) <$> unify a1 a2 <*> unify b1 b2
 unify t1 t2
  | t1 == t2  = pure t2
  | otherwise = throwResumable (UnificationError t1 t2)

-instance Ord location => ValueRoots location (Type location) where
+instance Ord location => ValueRoots location Type where
  valueRoots _ = mempty


-instance AbstractHole (Type location) where
+instance AbstractHole Type where
  hole = Hole

 -- | Discard the value arguments (if any), constructing a 'Type' instead.
@ -84,21 +106,20 @@ instance ( Addressable location effects
         , Members '[ Fresh
                    , NonDet
                    , Resumable TypeError
-                    , State (Environment location (Type location))
-                    , State (Heap location (Cell location) (Type location))
+                    , Return Type
+                    , State (Environment location Type)
+                    , State (Heap location (Cell location) Type)
                    ] effects
-         , Reducer (Type location) (Cell location (Type location))
+         , Reducer Type (Cell location Type)
         )
-      => AbstractValue location (Type location) effects where
+      => AbstractValue location Type effects where
  closure names _ body = do
    (env, tvars) <- foldr (\ name rest -> do
      a <- alloc name
      tvar <- Var <$> fresh
      assign a tvar
-      (env, tvars) <- rest
-      pure (Env.insert name a env, tvar : tvars)) (pure (emptyEnv, [])) names
-    ret <- localEnv (mergeEnvs env) body
-    pure (Product tvars :-> ret)
+      bimap (Env.insert name a) (tvar :) <$> rest) (pure (emptyEnv, [])) names
+    (zeroOrMoreProduct tvars :->) <$> localEnv (mergeEnvs env) (body `catchReturn` \ (Return value) -> pure value)

  unit       = pure Unit
  integer _  = pure Int
@ -107,10 +128,12 @@ instance ( Addressable location effects
  float _    = pure Float
  symbol _   = pure Symbol
  rational _ = pure Rational
-  multiple   = pure . Product
-  array      = pure . Array
+  multiple   = pure . zeroOrMoreProduct
+  array fields = do
+    var <- fresh
+    Array <$> foldr (\ t1 -> (unify t1 =<<)) (pure (Var var)) fields
  hash       = pure . Hash
-  kvPair k v = pure (Product [k, v])
+  kvPair k v = pure (k :* v)

  null          = pure Null

@ -123,31 +146,26 @@ instance ( Addressable location effects
  asPair t   = do
    t1 <- fresh
    t2 <- fresh
-    unify t (Product [Var t1, Var t2]) $> (Var t1, Var t2)
+    unify t (Var t1 :* Var t2) $> (Var t1, Var t2)
  asBool t   = unify t Bool *> (pure True <|> pure False)

  isHole ty = pure (ty == Hole)

-  index (Array (mem:_)) Int   = pure mem
-  index (Product (mem:_)) Int = pure mem
-  index a b                   = throwResumable (SubscriptError a b)
+  index arr sub = do
+    _ <- unify sub Int
+    field <- fresh
+    Var field <$ unify (Array (Var field)) arr

  ifthenelse cond if' else' = unify cond Bool *> (if' <|> else')

-  liftNumeric _ Float      = pure Float
-  liftNumeric _ Int        = pure Int
-  liftNumeric _ t          = throwResumable (NumOpError t Hole)
-
+  liftNumeric _ = unify (Int :+ Float :+ Rational)
  liftNumeric2 _ left right = case (left, right) of
    (Float, Int) -> pure Float
    (Int, Float) -> pure Float
    _            -> unify left right

-  liftBitwise _ Int = pure Int
-  liftBitwise _ t   = throwResumable (BitOpError t Hole)
-
-  liftBitwise2 _ Int Int = pure Int
-  liftBitwise2 _ t1 t2   = throwResumable (BitOpError t1 t2)
+  liftBitwise _ = unify Int
+  liftBitwise2 _ t1 t2   = unify Int t1 >>= flip unify t2

  liftComparison (Concrete _) left right = case (left, right) of
    (Float, Int) ->                     pure Bool
@ -161,7 +179,7 @@ instance ( Addressable location effects
  call op params = do
    tvar <- fresh
    paramTypes <- sequenceA params
-    let needed = Product paramTypes :-> Var tvar
+    let needed = zeroOrMoreProduct paramTypes :-> Var tvar
    unified <- op `unify` needed
    case unified of
      _ :-> ret -> pure ret
--- a/src/Data/Abstract/Value.hs
+++ b/src/Data/Abstract/Value.hs
@ -366,7 +366,7 @@ instance ( Addressable location (Goto effects (Value location) ': effects)
            a <- alloc name
            assign a v
            Env.insert name a <$> rest) (pure env) (zip names params)
-          localEnv (mergeEnvs bindings) (catchReturn body (\ (Return value) -> pure value))
+          localEnv (mergeEnvs bindings) (body `catchReturn` \ (Return value) -> pure value)
      Nothing -> throwValueError (CallError op)

  loop x = catchLoopControl (fix x) (\ control -> case control of
@ -412,11 +412,11 @@ deriving instance Show location => Show (ValueError location resume)
 instance Show location => Show1 (ValueError location) where
  liftShowsPrec _ _ = showsPrec

-throwValueError :: Member (Resumable (ValueError location)) effects => ValueError location resume -> Evaluator location value effects resume
+throwValueError :: Member (Resumable (ValueError location)) effects => ValueError location resume -> Evaluator location (Value location) effects resume
 throwValueError = throwResumable

-runValueError :: Evaluator location value (Resumable (ValueError location) ': effects) a -> Evaluator location value effects (Either (SomeExc (ValueError location)) a)
+runValueError :: Effectful (m location (Value location)) => m location (Value location) (Resumable (ValueError location) ': effects) a -> m location (Value location) effects (Either (SomeExc (ValueError location)) a)
 runValueError = runResumable

-runValueErrorWith :: (forall resume . ValueError location resume -> Evaluator location value effects resume) -> Evaluator location value (Resumable (ValueError location) ': effects) a -> Evaluator location value effects a
+runValueErrorWith :: Effectful (m location (Value location)) => (forall resume . ValueError location resume -> m location (Value location) effects resume) -> m location (Value location) (Resumable (ValueError location) ': effects) a -> m location (Value location) effects a
 runValueErrorWith = runResumableWith
--- a/src/Data/JSON/Fields.hs
+++ b/src/Data/JSON/Fields.hs
@ -1,5 +1,13 @@
-{-# LANGUAGE MultiParamTypeClasses, TypeOperators, UndecidableInstances #-}
-module Data.JSON.Fields where
+{-# LANGUAGE DefaultSignatures, MultiParamTypeClasses, TypeOperators, UndecidableInstances #-}
+module Data.JSON.Fields
+  ( JSONFields (..)
+  , JSONFields1 (..)
+  , ToJSONFields (..)
+  , ToJSONFields1 (..)
+  , (.=)
+  , noChildren
+  , withChildren
+  ) where

 import Data.Aeson
 import Data.Sum (Apply(..), Sum)
@ -10,7 +18,14 @@ class ToJSONFields a where

 class ToJSONFields1 f where
  toJSONFields1 :: (KeyValue kv, ToJSON a) => f a -> [kv]
+  default toJSONFields1 :: (KeyValue kv, ToJSON a, Foldable f) => f a -> [kv]
+  toJSONFields1 f = ["children" .= toList f]

+withChildren :: (KeyValue kv, ToJSON a, Foldable f) => f a -> [kv] -> [kv]
+withChildren f ks = ("children" .= toList f) : ks
+
+noChildren :: KeyValue kv => [kv] -> [kv]
+noChildren ks = ("children" .= ([] :: [Int])) : ks

 instance ToJSONFields a => ToJSONFields (Join (,) a) where
  toJSONFields (Join (a, b)) = [ "before" .= object (toJSONFields a), "after" .= object (toJSONFields b) ]
@ -24,8 +39,8 @@ instance ToJSON a => ToJSONFields [a] where
 instance ToJSONFields1 [] where
  toJSONFields1 list = [ "children" .= list ]

-instance Apply Foldable fs => ToJSONFields1 (Sum fs) where
-  toJSONFields1 r = [ "children" .= toList r ]
+instance Apply ToJSONFields1 fs => ToJSONFields1 (Sum fs) where
+  toJSONFields1 = apply @ToJSONFields1 toJSONFields1

 instance (ToJSONFields a, ToJSONFields b) => ToJSONFields (a, b) where
  toJSONFields (a, b) = [ "before" .= JSONFields a, "after" .= JSONFields b ]
--- a/src/Data/Map/Monoidal.hs
+++ b/src/Data/Map/Monoidal.hs
@ -7,6 +7,7 @@ module Data.Map.Monoidal
 , size
 , insert
 , filterWithKey
+, pairs
 , module Reducer
 ) where

@ -41,6 +42,10 @@ filterWithKey :: (key -> value -> Bool) -> Map key value -> Map key value
 filterWithKey f = Map . Map.filterWithKey f . unMap


+pairs :: Map key value -> [(key, value)]
+pairs = Map.toList . unMap
+
+
 instance (Ord key, Semigroup value) => Semigroup (Map key value) where
  Map a <> Map b = Map (Map.unionWith (<>) a b)

--- a/src/Data/Semilattice/Lower.hs
+++ b/src/Data/Semilattice/Lower.hs
@ -6,6 +6,7 @@ module Data.Semilattice.Lower
 import Data.IntMap as IntMap
 import Data.IntSet as IntSet
 import Data.Map as Map
+import Data.Monoid as Monoid
 import Data.Set as Set

 class Lower s where
@ -33,6 +34,12 @@ instance Lower b => Lower (a -> b) where lowerBound = const lowerBound
 instance Lower (Maybe a) where lowerBound = Nothing
 instance Lower [a] where lowerBound = []

+instance (Lower a, Lower b) => Lower (a, b) where lowerBound = (lowerBound, lowerBound)
+
+
+-- Data.Monoid
+instance Lower (Last a) where lowerBound = mempty
+
 -- containers
 instance Lower (IntMap a) where lowerBound = IntMap.empty
 instance Lower IntSet where lowerBound = IntSet.empty
--- a/src/Data/Syntax.hs
+++ b/src/Data/Syntax.hs
@ -3,7 +3,9 @@
 module Data.Syntax where

 import Data.Abstract.Evaluatable
+import Data.Aeson (ToJSON(..), object)
 import Data.AST
+import Data.JSON.Fields
 import Data.Range
 import Data.Record
 import Data.Span
@ -106,6 +108,9 @@ instance Eq1 Identifier where liftEq = genericLiftEq
 instance Ord1 Identifier where liftCompare = genericLiftCompare
 instance Show1 Identifier where liftShowsPrec = genericLiftShowsPrec

+-- Propagating the identifier name into JSON is handled with the IdentifierName analysis.
+instance ToJSONFields1 Identifier
+
 instance Evaluatable Identifier where
  eval (Identifier name) = variable name

@ -122,6 +127,8 @@ instance Eq1 Program where liftEq = genericLiftEq
 instance Ord1 Program where liftCompare = genericLiftCompare
 instance Show1 Program where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Program
+
 instance Evaluatable Program where
  eval (Program xs) = eval xs

@ -133,6 +140,8 @@ instance Eq1 AccessibilityModifier where liftEq = genericLiftEq
 instance Ord1 AccessibilityModifier where liftCompare = genericLiftCompare
 instance Show1 AccessibilityModifier where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 AccessibilityModifier
+
 -- TODO: Implement Eval instance for AccessibilityModifier
 instance Evaluatable AccessibilityModifier

@ -142,6 +151,8 @@ instance Evaluatable AccessibilityModifier
 data Empty a = Empty
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Empty
+
 instance Eq1 Empty where liftEq _ _ _ = True
 instance Ord1 Empty where liftCompare _ _ _ = EQ
 instance Show1 Empty where liftShowsPrec _ _ _ _ = showString "Empty"
@ -160,6 +171,13 @@ instance Show1 Error where liftShowsPrec = genericLiftShowsPrec

 instance Evaluatable Error

+instance ToJSONFields1 Error where
+  toJSONFields1 f@Error{..} = withChildren f [ "stack" .= errorCallStack
+                                             , "expected" .= errorExpected
+                                             , "actual" .= errorActual
+                                             ]
+
+
 errorSyntax :: Error.Error String -> [a] -> Error a
 errorSyntax Error.Error{..} = Error (ErrorStack (getCallStack callStack)) errorExpected errorActual

@ -169,6 +187,18 @@ unError span Error{..} = Error.withCallStack (freezeCallStack (fromCallSiteList
 newtype ErrorStack = ErrorStack { unErrorStack :: [(String, SrcLoc)] }
  deriving (Eq, Show)

+instance ToJSON ErrorStack where
+  toJSON (ErrorStack es) = toJSON (jSite <$> es) where
+    jSite (site, SrcLoc{..}) = object
+      [ "site" .= site
+      , "package" .= srcLocPackage
+      , "module" .= srcLocModule
+      , "file" .= srcLocFile
+      , "startLine" .= srcLocStartLine
+      , "startColumn" .= srcLocStartCol
+      , "endColumn" .= srcLocEndCol
+      ]
+
 instance Ord ErrorStack where
  compare = liftCompare (liftCompare compareSrcLoc) `on` unErrorStack
    where compareSrcLoc s1 s2 = mconcat
@ -185,6 +215,8 @@ instance Ord ErrorStack where
 data Context a = Context { contextTerms :: NonEmpty a, contextSubject :: a }
  deriving (Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Context
+
 instance Diffable Context where
  subalgorithmFor blur focus (Context n s) = Context <$> traverse blur n <*> focus s

--- a/src/Data/Syntax/Comment.hs
+++ b/src/Data/Syntax/Comment.hs
@ -3,6 +3,8 @@ module Data.Syntax.Comment where

 import Prologue
 import Data.Abstract.Evaluatable
+import Data.ByteString (unpack)
+import Data.JSON.Fields
 import Diffing.Algorithm

 -- | An unnested comment (line or block).
@ -13,6 +15,9 @@ instance Eq1 Comment where liftEq = genericLiftEq
 instance Ord1 Comment where liftCompare = genericLiftCompare
 instance Show1 Comment where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Comment where
+  toJSONFields1 f@Comment{..} = withChildren f ["contents" .= unpack commentContent ]
+
 instance Evaluatable Comment where
  eval _ = unit

--- a/src/Data/Syntax/Declaration.hs
+++ b/src/Data/Syntax/Declaration.hs
@ -3,6 +3,7 @@ module Data.Syntax.Declaration where

 import qualified Data.Abstract.Environment as Env
 import Data.Abstract.Evaluatable
+import Data.JSON.Fields
 import qualified Data.Set as Set (fromList)
 import Diffing.Algorithm
 import Prologue
@ -17,6 +18,8 @@ instance Eq1 Function where liftEq = genericLiftEq
 instance Ord1 Function where liftCompare = genericLiftCompare
 instance Show1 Function where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Function
+
 -- TODO: Filter the closed-over environment by the free variables in the term.
 -- TODO: How should we represent function types, where applicable?

@ -35,13 +38,15 @@ instance Declarations a => Declarations (Function a) where
 data Method a = Method { methodContext :: ![a], methodReceiver :: !a, methodName :: !a, methodParameters :: ![a], methodBody :: !a }
  deriving (Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

-instance Diffable Method where
-  equivalentBySubterm = Just . methodName
-
 instance Eq1 Method where liftEq = genericLiftEq
 instance Ord1 Method where liftCompare = genericLiftCompare
 instance Show1 Method where liftShowsPrec = genericLiftShowsPrec

+instance Diffable Method where
+  equivalentBySubterm = Just . methodName
+
+instance ToJSONFields1 Method
+
 -- Evaluating a Method creates a closure and makes that value available in the
 -- local environment.
 instance Evaluatable Method where
@ -61,6 +66,8 @@ instance Eq1 MethodSignature where liftEq = genericLiftEq
 instance Ord1 MethodSignature where liftCompare = genericLiftCompare
 instance Show1 MethodSignature where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 MethodSignature
+
 -- TODO: Implement Eval instance for MethodSignature
 instance Evaluatable MethodSignature

@ -72,6 +79,8 @@ instance Eq1 RequiredParameter where liftEq = genericLiftEq
 instance Ord1 RequiredParameter where liftCompare = genericLiftCompare
 instance Show1 RequiredParameter where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 RequiredParameter
+
 -- TODO: Implement Eval instance for RequiredParameter
 instance Evaluatable RequiredParameter

@ -83,6 +92,8 @@ instance Eq1 OptionalParameter where liftEq = genericLiftEq
 instance Ord1 OptionalParameter where liftCompare = genericLiftCompare
 instance Show1 OptionalParameter where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 OptionalParameter
+
 -- TODO: Implement Eval instance for OptionalParameter
 instance Evaluatable OptionalParameter

@ -98,6 +109,8 @@ instance Eq1 VariableDeclaration where liftEq = genericLiftEq
 instance Ord1 VariableDeclaration where liftCompare = genericLiftCompare
 instance Show1 VariableDeclaration where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 VariableDeclaration
+
 instance Evaluatable VariableDeclaration where
  eval (VariableDeclaration [])   = unit
  eval (VariableDeclaration decs) = multiple =<< traverse subtermValue decs
@ -116,6 +129,8 @@ instance Eq1 InterfaceDeclaration where liftEq = genericLiftEq
 instance Ord1 InterfaceDeclaration where liftCompare = genericLiftCompare
 instance Show1 InterfaceDeclaration where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 InterfaceDeclaration
+
 -- TODO: Implement Eval instance for InterfaceDeclaration
 instance Evaluatable InterfaceDeclaration

@ -131,6 +146,8 @@ instance Eq1 PublicFieldDefinition where liftEq = genericLiftEq
 instance Ord1 PublicFieldDefinition where liftCompare = genericLiftCompare
 instance Show1 PublicFieldDefinition where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 PublicFieldDefinition
+
 -- TODO: Implement Eval instance for PublicFieldDefinition
 instance Evaluatable PublicFieldDefinition

@ -142,6 +159,8 @@ instance Eq1 Variable where liftEq = genericLiftEq
 instance Ord1 Variable where liftCompare = genericLiftCompare
 instance Show1 Variable where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Variable
+
 -- TODO: Implement Eval instance for Variable
 instance Evaluatable Variable

@ -151,6 +170,8 @@ data Class a = Class { classContext :: ![a], classIdentifier :: !a, classSupercl
 instance Declarations a => Declarations (Class a) where
  declaredName (Class _ name _ _) = declaredName name

+instance ToJSONFields1 Class
+
 instance Diffable Class where
  equivalentBySubterm = Just . classIdentifier

@ -176,6 +197,8 @@ instance Eq1 Decorator where liftEq = genericLiftEq
 instance Ord1 Decorator where liftCompare = genericLiftCompare
 instance Show1 Decorator where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Decorator
+
 -- TODO: Implement Eval instance for Decorator
 instance Evaluatable Decorator

@ -190,6 +213,8 @@ instance Eq1 Data.Syntax.Declaration.Datatype where liftEq = genericLiftEq
 instance Ord1 Data.Syntax.Declaration.Datatype where liftCompare = genericLiftCompare
 instance Show1 Data.Syntax.Declaration.Datatype where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Data.Syntax.Declaration.Datatype
+
 -- TODO: Implement Eval instance for Datatype
 instance Evaluatable Data.Syntax.Declaration.Datatype

@ -202,6 +227,8 @@ instance Eq1 Data.Syntax.Declaration.Constructor where liftEq = genericLiftEq
 instance Ord1 Data.Syntax.Declaration.Constructor where liftCompare = genericLiftCompare
 instance Show1 Data.Syntax.Declaration.Constructor where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Data.Syntax.Declaration.Constructor
+
 -- TODO: Implement Eval instance for Constructor
 instance Evaluatable Data.Syntax.Declaration.Constructor

@ -214,6 +241,8 @@ instance Eq1 Comprehension where liftEq = genericLiftEq
 instance Ord1 Comprehension where liftCompare = genericLiftCompare
 instance Show1 Comprehension where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Comprehension
+
 -- TODO: Implement Eval instance for Comprehension
 instance Evaluatable Comprehension

@ -226,6 +255,8 @@ instance Eq1 Type where liftEq = genericLiftEq
 instance Ord1 Type where liftCompare = genericLiftCompare
 instance Show1 Type where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Type
+
 -- TODO: Implement Eval instance for Type
 instance Evaluatable Type

@ -238,6 +269,8 @@ instance Eq1 TypeAlias where liftEq = genericLiftEq
 instance Ord1 TypeAlias where liftCompare = genericLiftCompare
 instance Show1 TypeAlias where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 TypeAlias
+
 -- TODO: Implement Eval instance for TypeAlias
 instance Evaluatable TypeAlias where
  eval TypeAlias{..} = do
--- a/src/Data/Syntax/Directive.hs
+++ b/src/Data/Syntax/Directive.hs
@ -4,6 +4,7 @@ module Data.Syntax.Directive where
 import           Data.Abstract.Evaluatable
 import           Data.Abstract.Module (ModuleInfo(..))
 import qualified Data.ByteString.Char8 as BC
+import           Data.JSON.Fields
 import           Data.Span
 import           Diffing.Algorithm
 import           Prologue
@ -16,6 +17,8 @@ instance Eq1 File where liftEq = genericLiftEq
 instance Ord1 File where liftCompare = genericLiftCompare
 instance Show1 File where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 File
+
 instance Evaluatable File where
  eval File = currentModule >>= string . BC.pack . modulePath

@ -28,5 +31,7 @@ instance Eq1 Line where liftEq = genericLiftEq
 instance Ord1 Line where liftCompare = genericLiftCompare
 instance Show1 Line where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Line
+
 instance Evaluatable Line where
  eval Line = currentSpan >>= integer . fromIntegral . posLine . spanStart
--- a/src/Data/Syntax/Expression.hs
+++ b/src/Data/Syntax/Expression.hs
@ -4,6 +4,7 @@ module Data.Syntax.Expression where
 import Data.Abstract.Evaluatable
 import Data.Abstract.Number (liftIntegralFrac, liftReal, liftedExponent, liftedFloorDiv)
 import Data.Fixed
+import Data.JSON.Fields
 import Diffing.Algorithm
 import Prologue hiding (index)

@ -15,6 +16,8 @@ instance Eq1 Call where liftEq = genericLiftEq
 instance Ord1 Call where liftCompare = genericLiftCompare
 instance Show1 Call where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Call
+
 instance Evaluatable Call where
  eval Call{..} = do
    op <- subtermValue callFunction
@ -33,6 +36,8 @@ instance Eq1 Comparison where liftEq = genericLiftEq
 instance Ord1 Comparison where liftCompare = genericLiftCompare
 instance Show1 Comparison where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Comparison
+
 instance Evaluatable Comparison where
  eval = traverse subtermValue >=> go where
    go x = case x of
@ -59,6 +64,8 @@ instance Eq1 Arithmetic where liftEq = genericLiftEq
 instance Ord1 Arithmetic where liftCompare = genericLiftCompare
 instance Show1 Arithmetic where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Arithmetic
+
 instance Evaluatable Arithmetic where
  eval = traverse subtermValue >=> go where
    go (Plus a b)          = liftNumeric2 add a b  where add    = liftReal (+)
@ -80,6 +87,8 @@ instance Eq1 Match where liftEq = genericLiftEq
 instance Ord1 Match where liftCompare = genericLiftCompare
 instance Show1 Match where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Match
+
 -- TODO: Implement Eval instance for Match
 instance Evaluatable Match

@ -95,6 +104,8 @@ instance Eq1 Boolean where liftEq = genericLiftEq
 instance Ord1 Boolean where liftCompare = genericLiftCompare
 instance Show1 Boolean where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Boolean
+
 instance Evaluatable Boolean where
  -- N.B. we have to use Monad rather than Applicative/Traversable on 'And' and 'Or' so that we don't evaluate both operands
  eval = go . fmap subtermValue where
@ -115,6 +126,8 @@ instance Eq1 Delete where liftEq = genericLiftEq
 instance Ord1 Delete where liftCompare = genericLiftCompare
 instance Show1 Delete where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Delete
+
 -- TODO: Implement Eval instance for Delete
 instance Evaluatable Delete

@ -127,6 +140,8 @@ instance Eq1 SequenceExpression where liftEq = genericLiftEq
 instance Ord1 SequenceExpression where liftCompare = genericLiftCompare
 instance Show1 SequenceExpression where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 SequenceExpression
+
 -- TODO: Implement Eval instance for SequenceExpression
 instance Evaluatable SequenceExpression

@ -139,6 +154,8 @@ instance Eq1 Void where liftEq = genericLiftEq
 instance Ord1 Void where liftCompare = genericLiftCompare
 instance Show1 Void where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Void
+
 -- TODO: Implement Eval instance for Void
 instance Evaluatable Void

@ -151,6 +168,8 @@ instance Eq1 Typeof where liftEq = genericLiftEq
 instance Ord1 Typeof where liftCompare = genericLiftCompare
 instance Show1 Typeof where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Typeof
+
 -- TODO: Implement Eval instance for Typeof
 instance Evaluatable Typeof

@ -170,6 +189,8 @@ instance Eq1 Bitwise where liftEq = genericLiftEq
 instance Ord1 Bitwise where liftCompare = genericLiftCompare
 instance Show1 Bitwise where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Bitwise
+
 instance Evaluatable Bitwise where
  eval = traverse subtermValue >=> go where
    genLShift x y = shiftL x (fromIntegral y)
@ -192,6 +213,8 @@ instance Eq1 MemberAccess where liftEq = genericLiftEq
 instance Ord1 MemberAccess where liftCompare = genericLiftCompare
 instance Show1 MemberAccess where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 MemberAccess
+
 instance Evaluatable MemberAccess where
  eval (fmap subtermValue -> MemberAccess mem acc) = evaluateInScopedEnv mem acc

@ -205,7 +228,9 @@ instance Eq1 Subscript where liftEq = genericLiftEq
 instance Ord1 Subscript where liftCompare = genericLiftCompare
 instance Show1 Subscript where liftShowsPrec = genericLiftShowsPrec

-- TODO: Implement Eval instance for Subscript
+instance ToJSONFields1 Subscript
+
+-- TODO: Finish Eval instance for Subscript
 instance Evaluatable Subscript where
  eval (Subscript l [r]) = join (index <$> subtermValue l <*> subtermValue r)
  eval (Subscript _ _)   = throwResumable (Unspecialized "Eval unspecialized for subscript with slices")
@ -220,6 +245,8 @@ instance Eq1 Enumeration where liftEq = genericLiftEq
 instance Ord1 Enumeration where liftCompare = genericLiftCompare
 instance Show1 Enumeration where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Enumeration
+
 -- TODO: Implement Eval instance for Enumeration
 instance Evaluatable Enumeration

@ -232,6 +259,8 @@ instance Eq1 InstanceOf where liftEq = genericLiftEq
 instance Ord1 InstanceOf where liftCompare = genericLiftCompare
 instance Show1 InstanceOf where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 InstanceOf
+
 -- TODO: Implement Eval instance for InstanceOf
 instance Evaluatable InstanceOf

@ -244,6 +273,8 @@ instance Eq1 ScopeResolution where liftEq = genericLiftEq
 instance Ord1 ScopeResolution where liftCompare = genericLiftCompare
 instance Show1 ScopeResolution where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 ScopeResolution
+
 -- TODO: Implement Eval instance for ScopeResolution
 instance Evaluatable ScopeResolution

@ -256,6 +287,8 @@ instance Eq1 NonNullExpression where liftEq = genericLiftEq
 instance Ord1 NonNullExpression where liftCompare = genericLiftCompare
 instance Show1 NonNullExpression where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 NonNullExpression
+
 -- TODO: Implement Eval instance for NonNullExpression
 instance Evaluatable NonNullExpression

@ -268,6 +301,8 @@ instance Eq1 Await where liftEq = genericLiftEq
 instance Ord1 Await where liftCompare = genericLiftCompare
 instance Show1 Await where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Await
+
 -- TODO: Implement Eval instance for Await
 instance Evaluatable Await

@ -280,6 +315,8 @@ instance Eq1 New where liftEq = genericLiftEq
 instance Ord1 New where liftCompare = genericLiftCompare
 instance Show1 New where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 New
+
 -- TODO: Implement Eval instance for New
 instance Evaluatable New

@ -292,5 +329,7 @@ instance Eq1 Cast where liftEq = genericLiftEq
 instance Ord1 Cast where liftCompare = genericLiftCompare
 instance Show1 Cast where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Cast
+
 -- TODO: Implement Eval instance for Cast
 instance Evaluatable Cast
--- a/src/Data/Syntax/Literal.hs
+++ b/src/Data/Syntax/Literal.hs
@ -2,6 +2,7 @@
 module Data.Syntax.Literal where

 import Control.Arrow ((>>>))
+import Data.JSON.Fields
 import Data.Abstract.Evaluatable
 import Data.ByteString.Char8 (readInteger, unpack)
 import qualified Data.ByteString.Char8 as B
@ -29,6 +30,8 @@ instance Show1 Boolean where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Boolean where
  eval (Boolean x) = boolean x

+instance ToJSONFields1 Boolean where
+  toJSONFields1 (Boolean b) = noChildren [ "value" .= b ]

 -- Numeric

@ -45,6 +48,9 @@ instance Evaluatable Data.Syntax.Literal.Integer where
  eval (Data.Syntax.Literal.Integer x) =
    integer =<< maybeM (throwEvalError (IntegerFormatError x)) (fst <$> readInteger x)

+instance ToJSONFields1 Data.Syntax.Literal.Integer where
+  toJSONFields1 (Integer i) = noChildren ["asString" .= unpack i]
+

 -- TODO: Should IntegerLiteral hold an Integer instead of a ByteString?
 -- TODO: Do we care about differentiating between hex/octal/decimal/binary integer literals?
@ -62,6 +68,9 @@ instance Evaluatable Data.Syntax.Literal.Float where
  eval (Float s) =
    float =<< either (const (throwEvalError (FloatFormatError s))) pure (parseScientific s)

+instance ToJSONFields1 Float where
+  toJSONFields1 (Float f) = noChildren ["asString" .= unpack f]
+
 -- Rational literals e.g. `2/3r`
 newtype Rational a = Rational ByteString
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
@ -77,6 +86,8 @@ instance Evaluatable Data.Syntax.Literal.Rational where
      parsed = readMaybe @Prelude.Integer (unpack trimmed)
    in rational =<< maybe (throwEvalError (RationalFormatError r)) (pure . toRational) parsed

+instance ToJSONFields1 Data.Syntax.Literal.Rational where
+  toJSONFields1 (Rational r) = noChildren ["asString" .= unpack r]

 -- Complex literals e.g. `3 + 2i`
 newtype Complex a = Complex ByteString
@ -89,6 +100,9 @@ instance Show1 Data.Syntax.Literal.Complex where liftShowsPrec = genericLiftShow
 -- TODO: Implement Eval instance for Complex
 instance Evaluatable Complex

+instance ToJSONFields1 Complex where
+  toJSONFields1 (Complex c) = noChildren ["asString" .= unpack c]
+
 -- Strings, symbols

 newtype String a = String { stringElements :: [a] }
@ -103,6 +117,7 @@ instance Show1 Data.Syntax.Literal.String where liftShowsPrec = genericLiftShows
 -- TODO: Implement Eval instance for String
 instance Evaluatable Data.Syntax.Literal.String

+instance ToJSONFields1 Data.Syntax.Literal.String

 -- | An interpolation element within a string literal.
 newtype InterpolationElement a = InterpolationElement { interpolationBody :: a }
@ -115,6 +130,7 @@ instance Show1 InterpolationElement where liftShowsPrec = genericLiftShowsPrec
 -- TODO: Implement Eval instance for InterpolationElement
 instance Evaluatable InterpolationElement

+instance ToJSONFields1 InterpolationElement

 -- | A sequence of textual contents within a string literal.
 newtype TextElement a = TextElement { textElementContent :: ByteString }
@ -124,6 +140,9 @@ instance Eq1 TextElement where liftEq = genericLiftEq
 instance Ord1 TextElement where liftCompare = genericLiftCompare
 instance Show1 TextElement where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 TextElement where
+  toJSONFields1 (TextElement c) = noChildren ["asString" .= unpack c]
+
 instance Evaluatable TextElement where
  eval (TextElement x) = string x

@ -136,6 +155,8 @@ instance Show1 Null where liftShowsPrec = genericLiftShowsPrec

 instance Evaluatable Null where eval = const null

+instance ToJSONFields1 Null
+
 newtype Symbol a = Symbol { symbolContent :: ByteString }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

@ -143,6 +164,8 @@ instance Eq1 Symbol where liftEq = genericLiftEq
 instance Ord1 Symbol where liftCompare = genericLiftCompare
 instance Show1 Symbol where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Symbol
+
 instance Evaluatable Symbol where
  eval (Symbol s) = symbol s

@ -156,6 +179,10 @@ instance Show1 Regex where liftShowsPrec = genericLiftShowsPrec
 -- TODO: Heredoc-style string literals?
 -- TODO: Character literals.

+instance ToJSONFields1 Regex where
+  toJSONFields1 (Regex r) = noChildren ["asString" .= unpack r]
+
+
 -- TODO: Implement Eval instance for Regex
 instance Evaluatable Regex

@ -169,6 +196,8 @@ instance Eq1 Array where liftEq = genericLiftEq
 instance Ord1 Array where liftCompare = genericLiftCompare
 instance Show1 Array where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Array
+
 instance Evaluatable Array where
  eval (Array a) = array =<< traverse subtermValue a

@ -179,6 +208,8 @@ instance Eq1 Hash where liftEq = genericLiftEq
 instance Ord1 Hash where liftCompare = genericLiftCompare
 instance Show1 Hash where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Hash
+
 instance Evaluatable Hash where
  eval = hashElements >>> traverse (subtermValue >=> asPair) >=> hash

@ -189,10 +220,14 @@ instance Eq1 KeyValue where liftEq = genericLiftEq
 instance Ord1 KeyValue where liftCompare = genericLiftCompare
 instance Show1 KeyValue where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 KeyValue
+
 instance Evaluatable KeyValue where
  eval (fmap subtermValue -> KeyValue{..}) =
    join (kvPair <$> key <*> value)

+instance ToJSONFields1 Tuple
+
 newtype Tuple a = Tuple { tupleContents :: [a] }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

@ -210,6 +245,8 @@ instance Eq1 Set where liftEq = genericLiftEq
 instance Ord1 Set where liftCompare = genericLiftCompare
 instance Show1 Set where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Set
+
 -- TODO: Implement Eval instance for Set
 instance Evaluatable Set

@ -224,6 +261,8 @@ instance Eq1 Pointer where liftEq = genericLiftEq
 instance Ord1 Pointer where liftCompare = genericLiftCompare
 instance Show1 Pointer where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Pointer
+
 -- TODO: Implement Eval instance for Pointer
 instance Evaluatable Pointer

@ -236,6 +275,8 @@ instance Eq1 Reference where liftEq = genericLiftEq
 instance Ord1 Reference where liftCompare = genericLiftCompare
 instance Show1 Reference where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Reference
+
 -- TODO: Implement Eval instance for Reference
 instance Evaluatable Reference

--- a/src/Data/Syntax/Statement.hs
+++ b/src/Data/Syntax/Statement.hs
@ -3,6 +3,8 @@ module Data.Syntax.Statement where

 import qualified Data.Abstract.Environment as Env
 import Data.Abstract.Evaluatable
+import Data.ByteString.Char8 (unpack)
+import Data.JSON.Fields
 import Diffing.Algorithm
 import Prelude
 import Prologue
@ -15,6 +17,8 @@ instance Eq1 If where liftEq = genericLiftEq
 instance Ord1 If where liftCompare = genericLiftCompare
 instance Show1 If where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 If
+
 instance Evaluatable If where
  eval (If cond if' else') = do
    bool <- subtermValue cond
@ -28,6 +32,8 @@ instance Eq1 Else where liftEq = genericLiftEq
 instance Ord1 Else where liftCompare = genericLiftCompare
 instance Show1 Else where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Else
+
 -- TODO: Implement Eval instance for Else
 instance Evaluatable Else

@ -41,6 +47,8 @@ instance Eq1 Goto where liftEq = genericLiftEq
 instance Ord1 Goto where liftCompare = genericLiftCompare
 instance Show1 Goto where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Goto
+
 -- TODO: Implement Eval instance for Goto
 instance Evaluatable Goto

@ -53,6 +61,8 @@ instance Eq1 Match where liftEq = genericLiftEq
 instance Ord1 Match where liftCompare = genericLiftCompare
 instance Show1 Match where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Match
+
 -- TODO: Implement Eval instance for Match
 instance Evaluatable Match

@ -65,6 +75,8 @@ instance Eq1 Pattern where liftEq = genericLiftEq
 instance Ord1 Pattern where liftCompare = genericLiftCompare
 instance Show1 Pattern where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Pattern
+
 -- TODO: Implement Eval instance for Pattern
 instance Evaluatable Pattern

@ -77,6 +89,8 @@ instance Eq1 Let where liftEq = genericLiftEq
 instance Ord1 Let where liftCompare = genericLiftCompare
 instance Show1 Let where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Let
+
 instance Evaluatable Let where
  eval Let{..} = do
    name <- either (throwEvalError . FreeVariablesError) pure (freeVariable $ subterm letVariable)
@ -94,6 +108,8 @@ instance Eq1 Assignment where liftEq = genericLiftEq
 instance Ord1 Assignment where liftCompare = genericLiftCompare
 instance Show1 Assignment where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Assignment
+
 instance Evaluatable Assignment where
  eval Assignment{..} = do
    case freeVariables (subterm assignmentTarget) of
@ -112,6 +128,8 @@ instance Eq1 PostIncrement where liftEq = genericLiftEq
 instance Ord1 PostIncrement where liftCompare = genericLiftCompare
 instance Show1 PostIncrement where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 PostIncrement
+
 -- TODO: Implement Eval instance for PostIncrement
 instance Evaluatable PostIncrement

@ -124,6 +142,8 @@ instance Eq1 PostDecrement where liftEq = genericLiftEq
 instance Ord1 PostDecrement where liftCompare = genericLiftCompare
 instance Show1 PostDecrement where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 PostDecrement
+
 -- TODO: Implement Eval instance for PostDecrement
 instance Evaluatable PostDecrement

@ -137,6 +157,8 @@ instance Eq1 Return where liftEq = genericLiftEq
 instance Ord1 Return where liftCompare = genericLiftCompare
 instance Show1 Return where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Return
+
 instance Evaluatable Return where
  eval (Return x) = subtermValue x >>= earlyReturn

@ -147,6 +169,8 @@ instance Eq1 Yield where liftEq = genericLiftEq
 instance Ord1 Yield where liftCompare = genericLiftCompare
 instance Show1 Yield where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Yield
+
 -- TODO: Implement Eval instance for Yield
 instance Evaluatable Yield

@ -158,6 +182,8 @@ instance Eq1 Break where liftEq = genericLiftEq
 instance Ord1 Break where liftCompare = genericLiftCompare
 instance Show1 Break where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Break
+
 instance Evaluatable Break where
  eval (Break x) = subtermValue x >>= throwBreak

@ -168,6 +194,8 @@ instance Eq1 Continue where liftEq = genericLiftEq
 instance Ord1 Continue where liftCompare = genericLiftCompare
 instance Show1 Continue where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Continue
+
 instance Evaluatable Continue where
  eval (Continue a) = subtermValue a >>= throwContinue

@ -178,6 +206,8 @@ instance Eq1 Retry where liftEq = genericLiftEq
 instance Ord1 Retry where liftCompare = genericLiftCompare
 instance Show1 Retry where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Retry
+
 -- TODO: Implement Eval instance for Retry
 instance Evaluatable Retry

@ -189,6 +219,8 @@ instance Eq1 NoOp where liftEq = genericLiftEq
 instance Ord1 NoOp where liftCompare = genericLiftCompare
 instance Show1 NoOp where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 NoOp
+
 instance Evaluatable NoOp where
  eval _ = unit

@ -201,6 +233,8 @@ instance Eq1 For where liftEq = genericLiftEq
 instance Ord1 For where liftCompare = genericLiftCompare
 instance Show1 For where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 For
+
 instance Evaluatable For where
  eval (fmap subtermValue -> For before cond step body) = forLoop before cond step body

@ -212,6 +246,8 @@ instance Eq1 ForEach where liftEq = genericLiftEq
 instance Ord1 ForEach where liftCompare = genericLiftCompare
 instance Show1 ForEach where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 ForEach
+
 -- TODO: Implement Eval instance for ForEach
 instance Evaluatable ForEach

@ -223,6 +259,8 @@ instance Eq1 While where liftEq = genericLiftEq
 instance Ord1 While where liftCompare = genericLiftCompare
 instance Show1 While where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 While
+
 instance Evaluatable While where
  eval While{..} = while (subtermValue whileCondition)  (subtermValue whileBody)

@ -233,6 +271,8 @@ instance Eq1 DoWhile where liftEq = genericLiftEq
 instance Ord1 DoWhile where liftCompare = genericLiftCompare
 instance Show1 DoWhile where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 DoWhile
+
 instance Evaluatable DoWhile where
  eval DoWhile{..} = doWhile (subtermValue doWhileBody) (subtermValue doWhileCondition)

@ -245,6 +285,8 @@ instance Eq1 Throw where liftEq = genericLiftEq
 instance Ord1 Throw where liftCompare = genericLiftCompare
 instance Show1 Throw where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Throw
+
 -- TODO: Implement Eval instance for Throw
 instance Evaluatable Throw

@ -256,6 +298,8 @@ instance Eq1 Try where liftEq = genericLiftEq
 instance Ord1 Try where liftCompare = genericLiftCompare
 instance Show1 Try where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Try
+
 -- TODO: Implement Eval instance for Try
 instance Evaluatable Try

@ -267,6 +311,8 @@ instance Eq1 Catch where liftEq = genericLiftEq
 instance Ord1 Catch where liftCompare = genericLiftCompare
 instance Show1 Catch where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Catch
+
 -- TODO: Implement Eval instance for Catch
 instance Evaluatable Catch

@ -278,6 +324,8 @@ instance Eq1 Finally where liftEq = genericLiftEq
 instance Ord1 Finally where liftCompare = genericLiftCompare
 instance Show1 Finally where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Finally
+
 -- TODO: Implement Eval instance for Finally
 instance Evaluatable Finally

@ -292,6 +340,8 @@ instance Eq1 ScopeEntry where liftEq = genericLiftEq
 instance Ord1 ScopeEntry where liftCompare = genericLiftCompare
 instance Show1 ScopeEntry where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 ScopeEntry
+
 -- TODO: Implement Eval instance for ScopeEntry
 instance Evaluatable ScopeEntry

@ -304,6 +354,8 @@ instance Eq1 ScopeExit where liftEq = genericLiftEq
 instance Ord1 ScopeExit where liftCompare = genericLiftCompare
 instance Show1 ScopeExit where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 ScopeExit
+
 -- TODO: Implement Eval instance for ScopeExit
 instance Evaluatable ScopeExit

@ -315,5 +367,8 @@ instance Eq1 HashBang where liftEq = genericLiftEq
 instance Ord1 HashBang where liftCompare = genericLiftCompare
 instance Show1 HashBang where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 HashBang where
+  toJSONFields1 (HashBang f) = noChildren [ "contents" .= unpack f ]
+
 -- TODO: Implement Eval instance for HashBang
 instance Evaluatable HashBang
--- a/src/Data/Syntax/Type.hs
+++ b/src/Data/Syntax/Type.hs
@ -2,6 +2,7 @@
 module Data.Syntax.Type where

 import Data.Abstract.Evaluatable
+import Data.JSON.Fields
 import Diffing.Algorithm
 import Prologue hiding (Map)

@ -12,6 +13,8 @@ instance Eq1 Array where liftEq = genericLiftEq
 instance Ord1 Array where liftCompare = genericLiftCompare
 instance Show1 Array where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Array
+
 -- TODO: Implement Eval instance for Array
 instance Evaluatable Array

@ -24,6 +27,8 @@ instance Eq1 Annotation where liftEq = genericLiftEq
 instance Ord1 Annotation where liftCompare = genericLiftCompare
 instance Show1 Annotation where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Annotation where
+
 -- TODO: Specialize Evaluatable for Type to unify the inferred type of the subject with the specified type
 instance Evaluatable Annotation where
  eval Annotation{annotationSubject = Subterm _ action} = action
@ -36,6 +41,8 @@ instance Eq1 Function where liftEq = genericLiftEq
 instance Ord1 Function where liftCompare = genericLiftCompare
 instance Show1 Function where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Function
+
 -- TODO: Implement Eval instance for Function
 instance Evaluatable Function

@ -47,6 +54,8 @@ instance Eq1 Interface where liftEq = genericLiftEq
 instance Ord1 Interface where liftCompare = genericLiftCompare
 instance Show1 Interface where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Interface
+
 -- TODO: Implement Eval instance for Interface
 instance Evaluatable Interface

@ -58,6 +67,8 @@ instance Eq1 Map where liftEq = genericLiftEq
 instance Ord1 Map where liftCompare = genericLiftCompare
 instance Show1 Map where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Map
+
 -- TODO: Implement Eval instance for Map
 instance Evaluatable Map

@ -69,6 +80,8 @@ instance Eq1 Parenthesized where liftEq = genericLiftEq
 instance Ord1 Parenthesized where liftCompare = genericLiftCompare
 instance Show1 Parenthesized where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Parenthesized
+
 -- TODO: Implement Eval instance for Parenthesized
 instance Evaluatable Parenthesized

@ -80,6 +93,8 @@ instance Eq1 Pointer where liftEq = genericLiftEq
 instance Ord1 Pointer where liftCompare = genericLiftCompare
 instance Show1 Pointer where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Pointer
+
 -- TODO: Implement Eval instance for Pointer
 instance Evaluatable Pointer

@ -91,6 +106,8 @@ instance Eq1 Product where liftEq = genericLiftEq
 instance Ord1 Product where liftCompare = genericLiftCompare
 instance Show1 Product where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Product
+
 -- TODO: Implement Eval instance for Product
 instance Evaluatable Product

@ -102,6 +119,8 @@ instance Eq1 Readonly where liftEq = genericLiftEq
 instance Ord1 Readonly where liftCompare = genericLiftCompare
 instance Show1 Readonly where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Readonly
+
 -- TODO: Implement Eval instance for Readonly
 instance Evaluatable Readonly

@ -113,6 +132,8 @@ instance Eq1 Slice where liftEq = genericLiftEq
 instance Ord1 Slice where liftCompare = genericLiftCompare
 instance Show1 Slice where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Slice
+
 -- TODO: Implement Eval instance for Slice
 instance Evaluatable Slice

@ -124,5 +145,7 @@ instance Eq1 TypeParameters where liftEq = genericLiftEq
 instance Ord1 TypeParameters where liftCompare = genericLiftCompare
 instance Show1 TypeParameters where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 TypeParameters
+
 -- TODO: Implement Eval instance for TypeParameters
 instance Evaluatable TypeParameters
--- a/src/Data/Term.hs
+++ b/src/Data/Term.hs
@ -73,7 +73,7 @@ instance (Eq1 f, Eq a) => Eq (Term f a) where
  (==) = eq1

 instance Show1 f => Show1 (Term f) where
-  liftShowsPrec spA slA = go where go d = showsUnaryWith (liftShowsPrec2 spA slA go (showListWith (go 0))) "Term" d . unTerm
+  liftShowsPrec spA _ = go where go d (Term (In a f)) = showsBinaryWith spA (liftShowsPrec go (showListWith (go 0))) "Term" d a f

 instance (Show1 f, Show a) => Show (Term f a) where
  showsPrec = showsPrec1
--- a/src/Language/Go/Syntax.hs
+++ b/src/Language/Go/Syntax.hs
@ -8,6 +8,7 @@ import qualified Data.Abstract.Package as Package
 import           Data.Abstract.Path
 import qualified Data.ByteString as B
 import qualified Data.ByteString.Char8 as BC
+import           Data.JSON.Fields
 import           Diffing.Algorithm
 import           Prologue
 import           System.FilePath.Posix
@ -62,6 +63,8 @@ instance Eq1 Import where liftEq = genericLiftEq
 instance Ord1 Import where liftCompare = genericLiftCompare
 instance Show1 Import where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Import
+
 instance Evaluatable Import where
  eval (Import importPath _) = do
    paths <- resolveGoImport importPath
@ -82,6 +85,8 @@ instance Eq1 QualifiedImport where liftEq = genericLiftEq
 instance Ord1 QualifiedImport where liftCompare = genericLiftCompare
 instance Show1 QualifiedImport where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 QualifiedImport
+
 instance Evaluatable QualifiedImport where
  eval (QualifiedImport importPath aliasTerm) = do
    paths <- resolveGoImport importPath
@ -102,6 +107,8 @@ instance Eq1 SideEffectImport where liftEq = genericLiftEq
 instance Ord1 SideEffectImport where liftCompare = genericLiftCompare
 instance Show1 SideEffectImport where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 SideEffectImport
+
 instance Evaluatable SideEffectImport where
  eval (SideEffectImport importPath _) = do
    paths <- resolveGoImport importPath
@ -117,6 +124,8 @@ instance Eq1 Composite where liftEq = genericLiftEq
 instance Ord1 Composite where liftCompare = genericLiftCompare
 instance Show1 Composite where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Composite
+
 -- TODO: Implement Eval instance for Composite
 instance Evaluatable Composite

@ -128,6 +137,8 @@ instance Eq1 DefaultPattern where liftEq = genericLiftEq
 instance Ord1 DefaultPattern where liftCompare = genericLiftCompare
 instance Show1 DefaultPattern where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 DefaultPattern
+
 -- TODO: Implement Eval instance for DefaultPattern
 instance Evaluatable DefaultPattern

@ -139,6 +150,8 @@ instance Eq1 Defer where liftEq = genericLiftEq
 instance Ord1 Defer where liftCompare = genericLiftCompare
 instance Show1 Defer where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Defer
+
 -- TODO: Implement Eval instance for Defer
 instance Evaluatable Defer

@ -150,6 +163,8 @@ instance Eq1 Go where liftEq = genericLiftEq
 instance Ord1 Go where liftCompare = genericLiftCompare
 instance Show1 Go where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Go
+
 -- TODO: Implement Eval instance for Go
 instance Evaluatable Go

@ -161,6 +176,8 @@ instance Eq1 Label where liftEq = genericLiftEq
 instance Ord1 Label where liftCompare = genericLiftCompare
 instance Show1 Label where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Label
+
 -- TODO: Implement Eval instance for Label
 instance Evaluatable Label

@ -168,6 +185,8 @@ instance Evaluatable Label
 newtype Rune a = Rune { _runeLiteral :: ByteString }
  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Rune
+
 -- TODO: Implement Eval instance for Rune
 instance Evaluatable Rune

@ -179,6 +198,8 @@ instance Show1 Rune where liftShowsPrec = genericLiftShowsPrec
 newtype Select a = Select { selectCases :: a }
  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Select
+
 -- TODO: Implement Eval instance for Select
 instance Evaluatable Select

@ -194,6 +215,8 @@ instance Eq1 Send where liftEq = genericLiftEq
 instance Ord1 Send where liftCompare = genericLiftCompare
 instance Show1 Send where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Send
+
 -- TODO: Implement Eval instance for Send
 instance Evaluatable Send

@ -205,6 +228,8 @@ instance Eq1 Slice where liftEq = genericLiftEq
 instance Ord1 Slice where liftCompare = genericLiftCompare
 instance Show1 Slice where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Slice
+
 -- TODO: Implement Eval instance for Slice
 instance Evaluatable Slice

@ -216,6 +241,8 @@ instance Eq1 TypeSwitch where liftEq = genericLiftEq
 instance Ord1 TypeSwitch where liftCompare = genericLiftCompare
 instance Show1 TypeSwitch where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 TypeSwitch
+
 -- TODO: Implement Eval instance for TypeSwitch
 instance Evaluatable TypeSwitch

@ -227,6 +254,8 @@ instance Eq1 TypeSwitchGuard where liftEq = genericLiftEq
 instance Ord1 TypeSwitchGuard where liftCompare = genericLiftCompare
 instance Show1 TypeSwitchGuard where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 TypeSwitchGuard
+
 -- TODO: Implement Eval instance for TypeSwitchGuard
 instance Evaluatable TypeSwitchGuard

@ -238,6 +267,8 @@ instance Eq1 Receive where liftEq = genericLiftEq
 instance Ord1 Receive where liftCompare = genericLiftCompare
 instance Show1 Receive where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Receive
+
 -- TODO: Implement Eval instance for Receive
 instance Evaluatable Receive

@ -249,6 +280,8 @@ instance Eq1 ReceiveOperator where liftEq = genericLiftEq
 instance Ord1 ReceiveOperator where liftCompare = genericLiftCompare
 instance Show1 ReceiveOperator where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 ReceiveOperator
+
 -- TODO: Implement Eval instance for ReceiveOperator
 instance Evaluatable ReceiveOperator

@ -260,6 +293,8 @@ instance Eq1 Field where liftEq = genericLiftEq
 instance Ord1 Field where liftCompare = genericLiftCompare
 instance Show1 Field where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Field
+
 -- TODO: Implement Eval instance for Field
 instance Evaluatable Field

@ -271,6 +306,8 @@ instance Eq1 Package where liftEq = genericLiftEq
 instance Ord1 Package where liftCompare = genericLiftCompare
 instance Show1 Package where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Package
+
 instance Evaluatable Package where
  eval (Package _ xs) = eval xs

@ -283,6 +320,8 @@ instance Eq1 TypeAssertion where liftEq = genericLiftEq
 instance Ord1 TypeAssertion where liftCompare = genericLiftCompare
 instance Show1 TypeAssertion where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 TypeAssertion
+
 -- TODO: Implement Eval instance for TypeAssertion
 instance Evaluatable TypeAssertion

@ -294,6 +333,8 @@ instance Eq1 TypeConversion where liftEq = genericLiftEq
 instance Ord1 TypeConversion where liftCompare = genericLiftCompare
 instance Show1 TypeConversion where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 TypeConversion
+
 -- TODO: Implement Eval instance for TypeConversion
 instance Evaluatable TypeConversion

@ -305,5 +346,7 @@ instance Eq1 Variadic where liftEq = genericLiftEq
 instance Ord1 Variadic where liftCompare = genericLiftCompare
 instance Show1 Variadic where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Variadic
+
 -- TODO: Implement Eval instance for Variadic
 instance Evaluatable Variadic
--- a/src/Language/Go/Type.hs
+++ b/src/Language/Go/Type.hs
@ -3,6 +3,7 @@ module Language.Go.Type where

 import Prologue
 import Data.Abstract.Evaluatable
+import Data.JSON.Fields
 import Diffing.Algorithm

 -- | A Bidirectional channel in Go (e.g. `chan`).
@ -13,6 +14,8 @@ instance Eq1 BidirectionalChannel where liftEq = genericLiftEq
 instance Ord1 BidirectionalChannel where liftCompare = genericLiftCompare
 instance Show1 BidirectionalChannel where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 BidirectionalChannel
+
 -- TODO: Implement Eval instance for BidirectionalChannel
 instance Evaluatable BidirectionalChannel

@ -24,6 +27,8 @@ instance Eq1 ReceiveChannel where liftEq = genericLiftEq
 instance Ord1 ReceiveChannel where liftCompare = genericLiftCompare
 instance Show1 ReceiveChannel where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 ReceiveChannel
+
 -- TODO: Implement Eval instance for ReceiveChannel
 instance Evaluatable ReceiveChannel

@ -35,5 +40,7 @@ instance Eq1 SendChannel where liftEq = genericLiftEq
 instance Ord1 SendChannel where liftCompare = genericLiftCompare
 instance Show1 SendChannel where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 SendChannel
+
 -- TODO: Implement Eval instance for SendChannel
 instance Evaluatable SendChannel
--- a/src/Language/Markdown/Syntax.hs
+++ b/src/Language/Markdown/Syntax.hs
@ -2,11 +2,15 @@
 module Language.Markdown.Syntax where

 import Prologue hiding (Text)
+import Data.ByteString.Char8 (unpack)
+import Data.JSON.Fields
 import Diffing.Algorithm

 newtype Document a = Document [a]
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Document
+
 instance Eq1 Document where liftEq = genericLiftEq
 instance Ord1 Document where liftCompare = genericLiftCompare
 instance Show1 Document where liftShowsPrec = genericLiftShowsPrec
@ -17,6 +21,8 @@ instance Show1 Document where liftShowsPrec = genericLiftShowsPrec
 newtype Paragraph a = Paragraph [a]
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Paragraph
+
 instance Eq1 Paragraph where liftEq = genericLiftEq
 instance Ord1 Paragraph where liftCompare = genericLiftCompare
 instance Show1 Paragraph where liftShowsPrec = genericLiftShowsPrec
@ -24,6 +30,8 @@ instance Show1 Paragraph where liftShowsPrec = genericLiftShowsPrec
 data Heading a = Heading { headingLevel :: Int, headingContent :: [a], sectionContent :: [a] }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Heading
+
 instance Eq1 Heading where liftEq = genericLiftEq
 instance Ord1 Heading where liftCompare = genericLiftCompare
 instance Show1 Heading where liftShowsPrec = genericLiftShowsPrec
@ -31,10 +39,14 @@ instance Show1 Heading where liftShowsPrec = genericLiftShowsPrec
 newtype UnorderedList a = UnorderedList [a]
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 UnorderedList
+
 instance Eq1 UnorderedList where liftEq = genericLiftEq
 instance Ord1 UnorderedList where liftCompare = genericLiftCompare
 instance Show1 UnorderedList where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 OrderedList
+
 newtype OrderedList a = OrderedList [a]
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

@ -42,6 +54,8 @@ instance Eq1 OrderedList where liftEq = genericLiftEq
 instance Ord1 OrderedList where liftCompare = genericLiftCompare
 instance Show1 OrderedList where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 BlockQuote
+
 newtype BlockQuote a = BlockQuote [a]
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

@ -49,6 +63,8 @@ instance Eq1 BlockQuote where liftEq = genericLiftEq
 instance Ord1 BlockQuote where liftCompare = genericLiftCompare
 instance Show1 BlockQuote where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 ThematicBreak
+
 data ThematicBreak a = ThematicBreak
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

@ -56,6 +72,9 @@ instance Eq1 ThematicBreak where liftEq = genericLiftEq
 instance Ord1 ThematicBreak where liftCompare = genericLiftCompare
 instance Show1 ThematicBreak where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 HTMLBlock where
+  toJSONFields1 (HTMLBlock b) = noChildren [ "asString" .= unpack b ]
+
 newtype HTMLBlock a = HTMLBlock ByteString
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

@ -66,6 +85,8 @@ instance Show1 HTMLBlock where liftShowsPrec = genericLiftShowsPrec
 newtype Table a = Table [a]
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Table
+
 instance Eq1 Table where liftEq = genericLiftEq
 instance Ord1 Table where liftCompare = genericLiftCompare
 instance Show1 Table where liftShowsPrec = genericLiftShowsPrec
@ -73,6 +94,8 @@ instance Show1 Table where liftShowsPrec = genericLiftShowsPrec
 newtype TableRow a = TableRow [a]
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 TableRow
+
 instance Eq1 TableRow where liftEq = genericLiftEq
 instance Ord1 TableRow where liftCompare = genericLiftCompare
 instance Show1 TableRow where liftShowsPrec = genericLiftShowsPrec
@ -80,6 +103,8 @@ instance Show1 TableRow where liftShowsPrec = genericLiftShowsPrec
 newtype TableCell a = TableCell [a]
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 TableCell
+
 instance Eq1 TableCell where liftEq = genericLiftEq
 instance Ord1 TableCell where liftCompare = genericLiftCompare
 instance Show1 TableCell where liftShowsPrec = genericLiftShowsPrec
@ -90,6 +115,8 @@ instance Show1 TableCell where liftShowsPrec = genericLiftShowsPrec
 newtype Strong a = Strong [a]
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Strong
+
 instance Eq1 Strong where liftEq = genericLiftEq
 instance Ord1 Strong where liftCompare = genericLiftCompare
 instance Show1 Strong where liftShowsPrec = genericLiftShowsPrec
@ -97,6 +124,8 @@ instance Show1 Strong where liftShowsPrec = genericLiftShowsPrec
 newtype Emphasis a = Emphasis [a]
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Emphasis
+
 instance Eq1 Emphasis where liftEq = genericLiftEq
 instance Ord1 Emphasis where liftCompare = genericLiftCompare
 instance Show1 Emphasis where liftShowsPrec = genericLiftShowsPrec
@ -104,6 +133,9 @@ instance Show1 Emphasis where liftShowsPrec = genericLiftShowsPrec
 newtype Text a = Text ByteString
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Text where
+  toJSONFields1 (Text s) = noChildren ["asString" .= unpack s ]
+
 instance Eq1 Text where liftEq = genericLiftEq
 instance Ord1 Text where liftCompare = genericLiftCompare
 instance Show1 Text where liftShowsPrec = genericLiftShowsPrec
@ -111,6 +143,9 @@ instance Show1 Text where liftShowsPrec = genericLiftShowsPrec
 data Link a = Link { linkURL :: ByteString, linkTitle :: Maybe ByteString }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+-- TODO: Better ToJSONFields1 instance
+instance ToJSONFields1 Link
+
 instance Eq1 Link where liftEq = genericLiftEq
 instance Ord1 Link where liftCompare = genericLiftCompare
 instance Show1 Link where liftShowsPrec = genericLiftShowsPrec
@ -118,6 +153,9 @@ instance Show1 Link where liftShowsPrec = genericLiftShowsPrec
 data Image a = Image { imageURL :: ByteString, imageTitle :: Maybe ByteString }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+-- TODO: Better ToJSONFields1 instance
+instance ToJSONFields1 Image
+
 instance Eq1 Image where liftEq = genericLiftEq
 instance Ord1 Image where liftCompare = genericLiftCompare
 instance Show1 Image where liftShowsPrec = genericLiftShowsPrec
@ -125,6 +163,9 @@ instance Show1 Image where liftShowsPrec = genericLiftShowsPrec
 data Code a = Code { codeLanguage :: Maybe ByteString, codeContent :: ByteString }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+-- TODO: Better ToJSONFields1 instance
+instance ToJSONFields1 Code
+
 instance Eq1 Code where liftEq = genericLiftEq
 instance Ord1 Code where liftCompare = genericLiftCompare
 instance Show1 Code where liftShowsPrec = genericLiftShowsPrec
@ -132,10 +173,14 @@ instance Show1 Code where liftShowsPrec = genericLiftShowsPrec
 data LineBreak a = LineBreak
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 LineBreak
+
 instance Eq1 LineBreak where liftEq = genericLiftEq
 instance Ord1 LineBreak where liftCompare = genericLiftCompare
 instance Show1 LineBreak where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Strikethrough
+
 newtype Strikethrough a = Strikethrough [a]
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

--- a/src/Language/PHP/Syntax.hs
+++ b/src/Language/PHP/Syntax.hs
@ -5,6 +5,7 @@ import           Data.Abstract.Evaluatable
 import           Data.Abstract.Module
 import           Data.Abstract.Path
 import qualified Data.ByteString.Char8 as BC
+import           Data.JSON.Fields
 import qualified Data.Language as Language
 import           Diffing.Algorithm
 import           Prelude hiding (fail)
@ -13,6 +14,9 @@ import           Prologue hiding (Text)
 newtype Text a = Text ByteString
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Text where
+  toJSONFields1 (Text t) = noChildren ["asString" .= BC.unpack t]
+
 instance Eq1 Text where liftEq = genericLiftEq
 instance Ord1 Text where liftCompare = genericLiftCompare
 instance Show1 Text where liftShowsPrec = genericLiftShowsPrec
@ -22,6 +26,8 @@ instance Evaluatable Text
 newtype VariableName a = VariableName a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 VariableName
+
 instance Eq1 VariableName where liftEq = genericLiftEq
 instance Ord1 VariableName where liftCompare = genericLiftCompare
 instance Show1 VariableName where liftShowsPrec = genericLiftShowsPrec
@ -72,6 +78,8 @@ instance Eq1 Require where liftEq          = genericLiftEq
 instance Ord1 Require where liftCompare    = genericLiftCompare
 instance Show1 Require where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Require
+
 instance Evaluatable Require where
  eval (Require path) = include path load

@ -83,6 +91,8 @@ instance Eq1 RequireOnce where liftEq = genericLiftEq
 instance Ord1 RequireOnce where liftCompare = genericLiftCompare
 instance Show1 RequireOnce where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 RequireOnce
+
 instance Evaluatable RequireOnce where
  eval (RequireOnce path) = include path require

@ -94,6 +104,8 @@ instance Eq1 Include where liftEq          = genericLiftEq
 instance Ord1 Include where liftCompare    = genericLiftCompare
 instance Show1 Include where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Include
+
 instance Evaluatable Include where
  eval (Include path) = include path load

@ -105,6 +117,8 @@ instance Eq1 IncludeOnce where liftEq          = genericLiftEq
 instance Ord1 IncludeOnce where liftCompare    = genericLiftCompare
 instance Show1 IncludeOnce where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 IncludeOnce
+
 instance Evaluatable IncludeOnce where
  eval (IncludeOnce path) = include path require

@ -112,6 +126,8 @@ instance Evaluatable IncludeOnce where
 newtype ArrayElement a = ArrayElement a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 ArrayElement
+
 instance Eq1 ArrayElement where liftEq          = genericLiftEq
 instance Ord1 ArrayElement where liftCompare    = genericLiftCompare
 instance Show1 ArrayElement where liftShowsPrec = genericLiftShowsPrec
@ -120,6 +136,8 @@ instance Evaluatable ArrayElement
 newtype GlobalDeclaration a = GlobalDeclaration [a]
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 GlobalDeclaration
+
 instance Eq1 GlobalDeclaration where liftEq          = genericLiftEq
 instance Ord1 GlobalDeclaration where liftCompare    = genericLiftCompare
 instance Show1 GlobalDeclaration where liftShowsPrec = genericLiftShowsPrec
@ -128,6 +146,8 @@ instance Evaluatable GlobalDeclaration
 newtype SimpleVariable a = SimpleVariable a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 SimpleVariable
+
 instance Eq1 SimpleVariable where liftEq          = genericLiftEq
 instance Ord1 SimpleVariable where liftCompare    = genericLiftCompare
 instance Show1 SimpleVariable where liftShowsPrec = genericLiftShowsPrec
@ -138,6 +158,8 @@ instance Evaluatable SimpleVariable
 newtype CastType a = CastType { _castType :: ByteString }
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 CastType
+
 instance Eq1 CastType where liftEq = genericLiftEq
 instance Ord1 CastType where liftCompare = genericLiftCompare
 instance Show1 CastType where liftShowsPrec = genericLiftShowsPrec
@ -146,6 +168,8 @@ instance Evaluatable CastType
 newtype ErrorControl a = ErrorControl a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 ErrorControl
+
 instance Eq1 ErrorControl where liftEq = genericLiftEq
 instance Ord1 ErrorControl where liftCompare = genericLiftCompare
 instance Show1 ErrorControl where liftShowsPrec = genericLiftShowsPrec
@ -154,6 +178,8 @@ instance Evaluatable ErrorControl
 newtype Clone a = Clone a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Clone
+
 instance Eq1 Clone where liftEq = genericLiftEq
 instance Ord1 Clone where liftCompare = genericLiftCompare
 instance Show1 Clone where liftShowsPrec = genericLiftShowsPrec
@ -162,6 +188,8 @@ instance Evaluatable Clone
 newtype ShellCommand a = ShellCommand ByteString
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 ShellCommand
+
 instance Eq1 ShellCommand where liftEq = genericLiftEq
 instance Ord1 ShellCommand where liftCompare = genericLiftCompare
 instance Show1 ShellCommand where liftShowsPrec = genericLiftShowsPrec
@ -171,6 +199,8 @@ instance Evaluatable ShellCommand
 newtype Update a = Update { _updateSubject :: a }
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Update
+
 instance Eq1 Update where liftEq = genericLiftEq
 instance Ord1 Update where liftCompare = genericLiftCompare
 instance Show1 Update where liftShowsPrec = genericLiftShowsPrec
@ -179,6 +209,8 @@ instance Evaluatable Update
 newtype NewVariable a = NewVariable [a]
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 NewVariable
+
 instance Eq1 NewVariable where liftEq = genericLiftEq
 instance Ord1 NewVariable where liftCompare = genericLiftCompare
 instance Show1 NewVariable where liftShowsPrec = genericLiftShowsPrec
@ -187,6 +219,8 @@ instance Evaluatable NewVariable
 newtype RelativeScope a = RelativeScope ByteString
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 RelativeScope
+
 instance Eq1 RelativeScope where liftEq = genericLiftEq
 instance Ord1 RelativeScope where liftCompare = genericLiftCompare
 instance Show1 RelativeScope where liftShowsPrec = genericLiftShowsPrec
@ -195,6 +229,8 @@ instance Evaluatable RelativeScope
 data QualifiedName a = QualifiedName !a !a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 QualifiedName
+
 instance Eq1 QualifiedName where liftEq = genericLiftEq
 instance Ord1 QualifiedName where liftCompare = genericLiftCompare
 instance Show1 QualifiedName where liftShowsPrec = genericLiftShowsPrec
@ -205,6 +241,8 @@ instance Evaluatable QualifiedName where
 newtype NamespaceName a = NamespaceName (NonEmpty a)
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 NamespaceName
+
 instance Eq1 NamespaceName where liftEq = genericLiftEq
 instance Ord1 NamespaceName where liftCompare = genericLiftCompare
 instance Show1 NamespaceName where liftShowsPrec = genericLiftShowsPrec
@ -215,6 +253,8 @@ instance Evaluatable NamespaceName where
 newtype ConstDeclaration a = ConstDeclaration [a]
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 ConstDeclaration
+
 instance Eq1 ConstDeclaration where liftEq = genericLiftEq
 instance Ord1 ConstDeclaration where liftCompare = genericLiftCompare
 instance Show1 ConstDeclaration where liftShowsPrec = genericLiftShowsPrec
@ -223,6 +263,8 @@ instance Evaluatable ConstDeclaration
 data ClassConstDeclaration a = ClassConstDeclaration a [a]
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 ClassConstDeclaration
+
 instance Eq1 ClassConstDeclaration where liftEq = genericLiftEq
 instance Ord1 ClassConstDeclaration where liftCompare = genericLiftCompare
 instance Show1 ClassConstDeclaration where liftShowsPrec = genericLiftShowsPrec
@ -231,6 +273,8 @@ instance Evaluatable ClassConstDeclaration
 newtype ClassInterfaceClause a = ClassInterfaceClause [a]
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 ClassInterfaceClause
+
 instance Eq1 ClassInterfaceClause where liftEq = genericLiftEq
 instance Ord1 ClassInterfaceClause where liftCompare = genericLiftCompare
 instance Show1 ClassInterfaceClause where liftShowsPrec = genericLiftShowsPrec
@ -239,6 +283,8 @@ instance Evaluatable ClassInterfaceClause
 newtype ClassBaseClause a = ClassBaseClause a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 ClassBaseClause
+
 instance Eq1 ClassBaseClause where liftEq = genericLiftEq
 instance Ord1 ClassBaseClause where liftCompare = genericLiftCompare
 instance Show1 ClassBaseClause where liftShowsPrec = genericLiftShowsPrec
@ -248,6 +294,8 @@ instance Evaluatable ClassBaseClause
 newtype UseClause a = UseClause [a]
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 UseClause
+
 instance Eq1 UseClause where liftEq = genericLiftEq
 instance Ord1 UseClause where liftCompare = genericLiftCompare
 instance Show1 UseClause where liftShowsPrec = genericLiftShowsPrec
@ -256,6 +304,8 @@ instance Evaluatable UseClause
 newtype ReturnType a = ReturnType a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 ReturnType
+
 instance Eq1 ReturnType where liftEq = genericLiftEq
 instance Ord1 ReturnType where liftCompare = genericLiftCompare
 instance Show1 ReturnType where liftShowsPrec = genericLiftShowsPrec
@ -264,6 +314,8 @@ instance Evaluatable ReturnType
 newtype TypeDeclaration a = TypeDeclaration a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 TypeDeclaration
+
 instance Eq1 TypeDeclaration where liftEq = genericLiftEq
 instance Ord1 TypeDeclaration where liftCompare = genericLiftCompare
 instance Show1 TypeDeclaration where liftShowsPrec = genericLiftShowsPrec
@ -272,6 +324,8 @@ instance Evaluatable TypeDeclaration
 newtype BaseTypeDeclaration a = BaseTypeDeclaration a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 BaseTypeDeclaration
+
 instance Eq1 BaseTypeDeclaration where liftEq = genericLiftEq
 instance Ord1 BaseTypeDeclaration where liftCompare = genericLiftCompare
 instance Show1 BaseTypeDeclaration where liftShowsPrec = genericLiftShowsPrec
@ -280,6 +334,8 @@ instance Evaluatable BaseTypeDeclaration
 newtype ScalarType a = ScalarType ByteString
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 ScalarType
+
 instance Eq1 ScalarType where liftEq = genericLiftEq
 instance Ord1 ScalarType where liftCompare = genericLiftCompare
 instance Show1 ScalarType where liftShowsPrec = genericLiftShowsPrec
@ -288,6 +344,8 @@ instance Evaluatable ScalarType
 newtype EmptyIntrinsic a = EmptyIntrinsic a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 EmptyIntrinsic
+
 instance Eq1 EmptyIntrinsic where liftEq = genericLiftEq
 instance Ord1 EmptyIntrinsic where liftCompare = genericLiftCompare
 instance Show1 EmptyIntrinsic where liftShowsPrec = genericLiftShowsPrec
@ -296,6 +354,8 @@ instance Evaluatable EmptyIntrinsic
 newtype ExitIntrinsic a = ExitIntrinsic a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 ExitIntrinsic
+
 instance Eq1 ExitIntrinsic where liftEq = genericLiftEq
 instance Ord1 ExitIntrinsic where liftCompare = genericLiftCompare
 instance Show1 ExitIntrinsic where liftShowsPrec = genericLiftShowsPrec
@ -304,6 +364,8 @@ instance Evaluatable ExitIntrinsic
 newtype IssetIntrinsic a = IssetIntrinsic a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 IssetIntrinsic
+
 instance Eq1 IssetIntrinsic where liftEq = genericLiftEq
 instance Ord1 IssetIntrinsic where liftCompare = genericLiftCompare
 instance Show1 IssetIntrinsic where liftShowsPrec = genericLiftShowsPrec
@ -312,6 +374,8 @@ instance Evaluatable IssetIntrinsic
 newtype EvalIntrinsic a = EvalIntrinsic a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 EvalIntrinsic
+
 instance Eq1 EvalIntrinsic where liftEq = genericLiftEq
 instance Ord1 EvalIntrinsic where liftCompare = genericLiftCompare
 instance Show1 EvalIntrinsic where liftShowsPrec = genericLiftShowsPrec
@ -320,6 +384,8 @@ instance Evaluatable EvalIntrinsic
 newtype PrintIntrinsic a = PrintIntrinsic a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 PrintIntrinsic
+
 instance Eq1 PrintIntrinsic where liftEq = genericLiftEq
 instance Ord1 PrintIntrinsic where liftCompare = genericLiftCompare
 instance Show1 PrintIntrinsic where liftShowsPrec = genericLiftShowsPrec
@ -328,6 +394,8 @@ instance Evaluatable PrintIntrinsic
 newtype NamespaceAliasingClause a = NamespaceAliasingClause a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 NamespaceAliasingClause
+
 instance Eq1 NamespaceAliasingClause where liftEq = genericLiftEq
 instance Ord1 NamespaceAliasingClause where liftCompare = genericLiftCompare
 instance Show1 NamespaceAliasingClause where liftShowsPrec = genericLiftShowsPrec
@ -336,6 +404,8 @@ instance Evaluatable NamespaceAliasingClause
 newtype NamespaceUseDeclaration a = NamespaceUseDeclaration [a]
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 NamespaceUseDeclaration
+
 instance Eq1 NamespaceUseDeclaration where liftEq = genericLiftEq
 instance Ord1 NamespaceUseDeclaration where liftCompare = genericLiftCompare
 instance Show1 NamespaceUseDeclaration where liftShowsPrec = genericLiftShowsPrec
@ -344,6 +414,8 @@ instance Evaluatable NamespaceUseDeclaration
 newtype NamespaceUseClause a = NamespaceUseClause [a]
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 NamespaceUseClause
+
 instance Eq1 NamespaceUseClause where liftEq = genericLiftEq
 instance Ord1 NamespaceUseClause where liftCompare = genericLiftCompare
 instance Show1 NamespaceUseClause where liftShowsPrec = genericLiftShowsPrec
@ -352,6 +424,8 @@ instance Evaluatable NamespaceUseClause
 newtype NamespaceUseGroupClause a = NamespaceUseGroupClause [a]
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 NamespaceUseGroupClause
+
 instance Eq1 NamespaceUseGroupClause where liftEq = genericLiftEq
 instance Ord1 NamespaceUseGroupClause where liftCompare = genericLiftCompare
 instance Show1 NamespaceUseGroupClause where liftShowsPrec = genericLiftShowsPrec
@ -364,6 +438,8 @@ instance Eq1 Namespace where liftEq = genericLiftEq
 instance Ord1 Namespace where liftCompare = genericLiftCompare
 instance Show1 Namespace where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Namespace
+
 instance Evaluatable Namespace where
  eval Namespace{..} = go names
    where
@ -379,6 +455,8 @@ instance Evaluatable Namespace where
 data TraitDeclaration a = TraitDeclaration { traitName :: a, traitStatements :: [a] }
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 TraitDeclaration
+
 instance Eq1 TraitDeclaration where liftEq = genericLiftEq
 instance Ord1 TraitDeclaration where liftCompare = genericLiftCompare
 instance Show1 TraitDeclaration where liftShowsPrec = genericLiftShowsPrec
@ -387,6 +465,8 @@ instance Evaluatable TraitDeclaration
 data AliasAs a = AliasAs { aliasAsName  :: a, aliasAsModifier :: a, aliasAsClause :: a }
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 AliasAs
+
 instance Eq1 AliasAs where liftEq = genericLiftEq
 instance Ord1 AliasAs where liftCompare = genericLiftCompare
 instance Show1 AliasAs where liftShowsPrec = genericLiftShowsPrec
@ -395,6 +475,8 @@ instance Evaluatable AliasAs
 data InsteadOf a = InsteadOf a a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 InsteadOf
+
 instance Eq1 InsteadOf where liftEq = genericLiftEq
 instance Ord1 InsteadOf where liftCompare = genericLiftCompare
 instance Show1 InsteadOf where liftShowsPrec = genericLiftShowsPrec
@ -403,6 +485,8 @@ instance Evaluatable InsteadOf
 newtype TraitUseSpecification a = TraitUseSpecification [a]
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 TraitUseSpecification
+
 instance Eq1 TraitUseSpecification where liftEq = genericLiftEq
 instance Ord1 TraitUseSpecification where liftCompare = genericLiftCompare
 instance Show1 TraitUseSpecification where liftShowsPrec = genericLiftShowsPrec
@ -411,6 +495,8 @@ instance Evaluatable TraitUseSpecification
 data TraitUseClause a = TraitUseClause [a] a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 TraitUseClause
+
 instance Eq1 TraitUseClause where liftEq = genericLiftEq
 instance Ord1 TraitUseClause where liftCompare = genericLiftCompare
 instance Show1 TraitUseClause where liftShowsPrec = genericLiftShowsPrec
@ -419,6 +505,8 @@ instance Evaluatable TraitUseClause
 data DestructorDeclaration a = DestructorDeclaration [a] a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 DestructorDeclaration
+
 instance Eq1 DestructorDeclaration where liftEq = genericLiftEq
 instance Ord1 DestructorDeclaration where liftCompare = genericLiftCompare
 instance Show1 DestructorDeclaration where liftShowsPrec = genericLiftShowsPrec
@ -427,6 +515,8 @@ instance Evaluatable DestructorDeclaration
 newtype Static a = Static ByteString
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Static
+
 instance Eq1 Static where liftEq = genericLiftEq
 instance Ord1 Static where liftCompare = genericLiftCompare
 instance Show1 Static where liftShowsPrec = genericLiftShowsPrec
@ -435,6 +525,8 @@ instance Evaluatable Static
 newtype ClassModifier a = ClassModifier ByteString
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 ClassModifier
+
 instance Eq1 ClassModifier where liftEq = genericLiftEq
 instance Ord1 ClassModifier where liftCompare = genericLiftCompare
 instance Show1 ClassModifier where liftShowsPrec = genericLiftShowsPrec
@ -443,6 +535,8 @@ instance Evaluatable ClassModifier
 data ConstructorDeclaration a = ConstructorDeclaration [a] [a] a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 ConstructorDeclaration
+
 instance Eq1 ConstructorDeclaration where liftEq = genericLiftEq
 instance Ord1 ConstructorDeclaration where liftCompare = genericLiftCompare
 instance Show1 ConstructorDeclaration where liftShowsPrec = genericLiftShowsPrec
@ -451,6 +545,8 @@ instance Evaluatable ConstructorDeclaration
 data PropertyDeclaration a = PropertyDeclaration a [a]
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 PropertyDeclaration
+
 instance Eq1 PropertyDeclaration where liftEq = genericLiftEq
 instance Ord1 PropertyDeclaration where liftCompare = genericLiftCompare
 instance Show1 PropertyDeclaration where liftShowsPrec = genericLiftShowsPrec
@ -459,6 +555,8 @@ instance Evaluatable PropertyDeclaration
 data PropertyModifier a = PropertyModifier a a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 PropertyModifier
+
 instance Eq1 PropertyModifier where liftEq = genericLiftEq
 instance Ord1 PropertyModifier where liftCompare = genericLiftCompare
 instance Show1 PropertyModifier where liftShowsPrec = genericLiftShowsPrec
@ -467,6 +565,8 @@ instance Evaluatable PropertyModifier
 data InterfaceDeclaration a = InterfaceDeclaration a a [a]
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 InterfaceDeclaration
+
 instance Eq1 InterfaceDeclaration where liftEq = genericLiftEq
 instance Ord1 InterfaceDeclaration where liftCompare = genericLiftCompare
 instance Show1 InterfaceDeclaration where liftShowsPrec = genericLiftShowsPrec
@ -475,6 +575,8 @@ instance Evaluatable InterfaceDeclaration
 newtype InterfaceBaseClause a = InterfaceBaseClause [a]
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 InterfaceBaseClause
+
 instance Eq1 InterfaceBaseClause where liftEq = genericLiftEq
 instance Ord1 InterfaceBaseClause where liftCompare = genericLiftCompare
 instance Show1 InterfaceBaseClause where liftShowsPrec = genericLiftShowsPrec
@ -483,6 +585,8 @@ instance Evaluatable InterfaceBaseClause
 newtype Echo a = Echo a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Echo
+
 instance Eq1 Echo where liftEq = genericLiftEq
 instance Ord1 Echo where liftCompare = genericLiftCompare
 instance Show1 Echo where liftShowsPrec = genericLiftShowsPrec
@ -491,6 +595,8 @@ instance Evaluatable Echo
 newtype Unset a = Unset a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Unset
+
 instance Eq1 Unset where liftEq = genericLiftEq
 instance Ord1 Unset where liftCompare = genericLiftCompare
 instance Show1 Unset where liftShowsPrec = genericLiftShowsPrec
@ -499,6 +605,8 @@ instance Evaluatable Unset
 data Declare a = Declare a a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 Declare
+
 instance Eq1 Declare where liftEq = genericLiftEq
 instance Ord1 Declare where liftCompare = genericLiftCompare
 instance Show1 Declare where liftShowsPrec = genericLiftShowsPrec
@ -507,6 +615,8 @@ instance Evaluatable Declare
 newtype DeclareDirective a = DeclareDirective a
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 DeclareDirective
+
 instance Eq1 DeclareDirective where liftEq = genericLiftEq
 instance Ord1 DeclareDirective where liftCompare = genericLiftCompare
 instance Show1 DeclareDirective where liftShowsPrec = genericLiftShowsPrec
@ -515,6 +625,8 @@ instance Evaluatable DeclareDirective
 newtype LabeledStatement a = LabeledStatement { _labeledStatementIdentifier :: a }
  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)

+instance ToJSONFields1 LabeledStatement
+
 instance Eq1 LabeledStatement where liftEq = genericLiftEq
 instance Ord1 LabeledStatement where liftCompare = genericLiftCompare
 instance Show1 LabeledStatement where liftShowsPrec = genericLiftShowsPrec
--- a/src/Language/Python/Syntax.hs
+++ b/src/Language/Python/Syntax.hs
@ -8,6 +8,7 @@ import           Data.Abstract.Module
 import           Data.Align.Generic
 import qualified Data.ByteString.Char8 as BC
 import           Data.Functor.Classes.Generic
+import           Data.JSON.Fields
 import qualified Data.Language as Language
 import qualified Data.List.NonEmpty as NonEmpty
 import           Data.Mergeable
@ -90,6 +91,8 @@ resolvePythonModules q = do
 data Import a = Import { importFrom :: QualifiedName, importSymbols :: ![(Name, Name)] }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Import
+
 instance Eq1 Import where liftEq = genericLiftEq
 instance Ord1 Import where liftCompare = genericLiftCompare
 instance Show1 Import where liftShowsPrec = genericLiftShowsPrec
@ -118,6 +121,8 @@ instance Evaluatable Import where
 newtype QualifiedImport a = QualifiedImport { qualifiedImportFrom :: QualifiedName }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 QualifiedImport
+
 instance Eq1 QualifiedImport where liftEq = genericLiftEq
 instance Ord1 QualifiedImport where liftCompare = genericLiftCompare
 instance Show1 QualifiedImport where liftShowsPrec = genericLiftShowsPrec
@ -144,6 +149,8 @@ instance Evaluatable QualifiedImport where
 data QualifiedAliasedImport a = QualifiedAliasedImport { qualifiedAliasedImportFrom :: QualifiedName, qualifiedAliasedImportAlias :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 QualifiedAliasedImport
+
 instance Eq1 QualifiedAliasedImport where liftEq = genericLiftEq
 instance Ord1 QualifiedAliasedImport where liftCompare = genericLiftCompare
 instance Show1 QualifiedAliasedImport where liftShowsPrec = genericLiftShowsPrec
@ -173,6 +180,8 @@ instance Eq1 Ellipsis where liftEq = genericLiftEq
 instance Ord1 Ellipsis where liftCompare = genericLiftCompare
 instance Show1 Ellipsis where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Ellipsis
+
 -- TODO: Implement Eval instance for Ellipsis
 instance Evaluatable Ellipsis

@ -184,5 +193,7 @@ instance Eq1 Redirect where liftEq = genericLiftEq
 instance Ord1 Redirect where liftCompare = genericLiftCompare
 instance Show1 Redirect where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Redirect
+
 -- TODO: Implement Eval instance for Redirect
 instance Evaluatable Redirect
--- a/src/Language/Ruby/Syntax.hs
+++ b/src/Language/Ruby/Syntax.hs
@ -6,6 +6,7 @@ import           Data.Abstract.Evaluatable
 import qualified Data.Abstract.Module as M
 import           Data.Abstract.Path
 import qualified Data.ByteString.Char8 as BC
+import           Data.JSON.Fields
 import qualified Data.Language as Language
 import           Diffing.Algorithm
 import           Prelude hiding (fail)
@ -48,11 +49,13 @@ instance Eq1 Send where liftEq = genericLiftEq
 instance Ord1 Send where liftCompare = genericLiftCompare
 instance Show1 Send where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Send
+
 instance Evaluatable Send where
  eval Send{..} = do
    let sel = case sendSelector of
          Just sel -> subtermValue sel
-          Nothing -> variable (name "call")
+          Nothing  -> variable (name "call")
    func <- maybe sel (flip evaluateInScopedEnv sel . subtermValue) sendReceiver
    call func (map subtermValue sendArgs) -- TODO pass through sendBlock

@ -63,6 +66,8 @@ instance Eq1 Require where liftEq = genericLiftEq
 instance Ord1 Require where liftCompare = genericLiftCompare
 instance Show1 Require where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Require
+
 instance Evaluatable Require where
  eval (Require _ x) = do
    name <- subtermValue x >>= asString
@ -91,6 +96,8 @@ instance Eq1 Load where liftEq = genericLiftEq
 instance Ord1 Load where liftCompare = genericLiftCompare
 instance Show1 Load where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Load
+
 instance Evaluatable Load where
  eval (Load [x]) = do
    path <- subtermValue x >>= asString
@ -124,6 +131,8 @@ doLoad path shouldWrap = do
 data Class a = Class { classIdentifier :: !a, classSuperClass :: !(Maybe a), classBody :: !a }
  deriving (Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Class
+
 instance Diffable Class where
  equivalentBySubterm = Just . classIdentifier

@ -145,6 +154,8 @@ instance Eq1 Module where liftEq = genericLiftEq
 instance Ord1 Module where liftCompare = genericLiftCompare
 instance Show1 Module where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Module
+
 instance Evaluatable Module where
  eval (Module iden xs) = do
    name <- either (throwEvalError . FreeVariablesError) pure (freeVariable $ subterm iden)
@ -156,6 +167,8 @@ data LowPrecedenceBoolean a
  | LowOr !a !a
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 LowPrecedenceBoolean
+
 instance Evaluatable LowPrecedenceBoolean where
  -- N.B. we have to use Monad rather than Applicative/Traversable on 'And' and 'Or' so that we don't evaluate both operands
  eval = go . fmap subtermValue where
--- a/src/Language/TypeScript/Syntax.hs
+++ b/src/Language/TypeScript/Syntax.hs
@ -9,6 +9,7 @@ import           Data.Abstract.Package
 import           Data.Abstract.Path
 import qualified Data.ByteString as B
 import qualified Data.ByteString.Char8 as BC
+import           Data.JSON.Fields
 import qualified Data.Language as Language
 import qualified Data.Map as Map
 import           Data.Semigroup.Reducer (Reducer)
@ -155,6 +156,8 @@ evalRequire modulePath alias = letrec' alias $ \addr -> do
 data Import a = Import { importSymbols :: ![(Name, Name)], importFrom :: ImportPath }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Import
+
 instance Eq1 Import where liftEq = genericLiftEq
 instance Ord1 Import where liftCompare = genericLiftCompare
 instance Show1 Import where liftShowsPrec = genericLiftShowsPrec
@ -177,6 +180,8 @@ instance Eq1 JavaScriptRequire where liftEq = genericLiftEq
 instance Ord1 JavaScriptRequire where liftCompare = genericLiftCompare
 instance Show1 JavaScriptRequire where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 JavaScriptRequire
+
 instance Evaluatable JavaScriptRequire where
  eval (JavaScriptRequire aliasTerm importPath) = do
    modulePath <- resolveWithNodejsStrategy importPath javascriptExtensions
@ -191,6 +196,8 @@ instance Eq1 QualifiedAliasedImport where liftEq = genericLiftEq
 instance Ord1 QualifiedAliasedImport where liftCompare = genericLiftCompare
 instance Show1 QualifiedAliasedImport where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 QualifiedAliasedImport
+
 instance Evaluatable QualifiedAliasedImport where
  eval (QualifiedAliasedImport aliasTerm importPath) = do
    modulePath <- resolveWithNodejsStrategy importPath typescriptExtensions
@ -204,6 +211,8 @@ instance Eq1 SideEffectImport where liftEq = genericLiftEq
 instance Ord1 SideEffectImport where liftCompare = genericLiftCompare
 instance Show1 SideEffectImport where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 SideEffectImport
+
 instance Evaluatable SideEffectImport where
  eval (SideEffectImport importPath) = do
    modulePath <- resolveWithNodejsStrategy importPath typescriptExtensions
@ -219,6 +228,8 @@ instance Eq1 QualifiedExport where liftEq = genericLiftEq
 instance Ord1 QualifiedExport where liftCompare = genericLiftCompare
 instance Show1 QualifiedExport where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 QualifiedExport
+
 instance Evaluatable QualifiedExport where
  eval (QualifiedExport exportSymbols) = do
    -- Insert the aliases with no addresses.
@ -235,6 +246,8 @@ instance Eq1 QualifiedExportFrom where liftEq = genericLiftEq
 instance Ord1 QualifiedExportFrom where liftCompare = genericLiftCompare
 instance Show1 QualifiedExportFrom where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 QualifiedExportFrom
+
 instance Evaluatable QualifiedExportFrom where
  eval (QualifiedExportFrom importPath exportSymbols) = do
    modulePath <- resolveWithNodejsStrategy importPath typescriptExtensions
@ -248,6 +261,8 @@ instance Evaluatable QualifiedExportFrom where
 newtype DefaultExport a = DefaultExport { defaultExport :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 DefaultExport
+
 instance Eq1 DefaultExport where liftEq = genericLiftEq
 instance Ord1 DefaultExport where liftCompare = genericLiftCompare
 instance Show1 DefaultExport where liftShowsPrec = genericLiftShowsPrec
@ -269,6 +284,8 @@ instance Evaluatable DefaultExport where
 data LookupType a = LookupType { lookupTypeIdentifier :: a, lookupTypeKey :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 LookupType
+
 instance Eq1 LookupType where liftEq = genericLiftEq
 instance Ord1 LookupType where liftCompare = genericLiftCompare
 instance Show1 LookupType where liftShowsPrec = genericLiftShowsPrec
@ -278,6 +295,8 @@ instance Evaluatable LookupType
 newtype ShorthandPropertyIdentifier a = ShorthandPropertyIdentifier ByteString
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ShorthandPropertyIdentifier
+
 instance Eq1 ShorthandPropertyIdentifier where liftEq = genericLiftEq
 instance Ord1 ShorthandPropertyIdentifier where liftCompare = genericLiftCompare
 instance Show1 ShorthandPropertyIdentifier where liftShowsPrec = genericLiftShowsPrec
@ -286,6 +305,8 @@ instance Evaluatable ShorthandPropertyIdentifier
 data Union a = Union { _unionLeft :: !a, _unionRight :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Language.TypeScript.Syntax.Union
+
 instance Eq1 Language.TypeScript.Syntax.Union where liftEq = genericLiftEq
 instance Ord1 Language.TypeScript.Syntax.Union where liftCompare = genericLiftCompare
 instance Show1 Language.TypeScript.Syntax.Union where liftShowsPrec = genericLiftShowsPrec
@ -294,6 +315,8 @@ instance Evaluatable Language.TypeScript.Syntax.Union
 data Intersection a = Intersection { _intersectionLeft :: !a, _intersectionRight :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Intersection
+
 instance Eq1 Intersection where liftEq = genericLiftEq
 instance Ord1 Intersection where liftCompare = genericLiftCompare
 instance Show1 Intersection where liftShowsPrec = genericLiftShowsPrec
@ -302,6 +325,8 @@ instance Evaluatable Intersection
 data FunctionType a = FunctionType { _functionTypeParameters :: !a, _functionFormalParameters :: ![a], _functionType :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 FunctionType
+
 instance Eq1 FunctionType where liftEq = genericLiftEq
 instance Ord1 FunctionType where liftCompare = genericLiftCompare
 instance Show1 FunctionType where liftShowsPrec = genericLiftShowsPrec
@ -310,6 +335,8 @@ instance Evaluatable FunctionType
 data AmbientFunction a = AmbientFunction { _ambientFunctionContext :: ![a], _ambientFunctionIdentifier :: !a, _ambientFunctionParameters :: ![a] }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 AmbientFunction
+
 instance Eq1 AmbientFunction where liftEq = genericLiftEq
 instance Ord1 AmbientFunction where liftCompare = genericLiftCompare
 instance Show1 AmbientFunction where liftShowsPrec = genericLiftShowsPrec
@ -318,6 +345,8 @@ instance Evaluatable AmbientFunction
 data ImportRequireClause a = ImportRequireClause { _importRequireIdentifier :: !a, _importRequireSubject :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ImportRequireClause
+
 instance Eq1 ImportRequireClause where liftEq = genericLiftEq
 instance Ord1 ImportRequireClause where liftCompare = genericLiftCompare
 instance Show1 ImportRequireClause where liftShowsPrec = genericLiftShowsPrec
@ -326,6 +355,8 @@ instance Evaluatable ImportRequireClause
 newtype ImportClause a = ImportClause { _importClauseElements :: [a] }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ImportClause
+
 instance Eq1 ImportClause where liftEq = genericLiftEq
 instance Ord1 ImportClause where liftCompare = genericLiftCompare
 instance Show1 ImportClause where liftShowsPrec = genericLiftShowsPrec
@ -334,6 +365,8 @@ instance Evaluatable ImportClause
 newtype Tuple a = Tuple { _tupleElements :: [a] }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Tuple
+
 instance Eq1 Tuple where liftEq = genericLiftEq
 instance Ord1 Tuple where liftCompare = genericLiftCompare
 instance Show1 Tuple where liftShowsPrec = genericLiftShowsPrec
@ -344,6 +377,8 @@ instance Evaluatable Tuple
 data Constructor a = Constructor { _constructorTypeParameters :: !a, _constructorFormalParameters :: ![a], _constructorType :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Language.TypeScript.Syntax.Constructor
+
 instance Eq1 Language.TypeScript.Syntax.Constructor where liftEq = genericLiftEq
 instance Ord1 Language.TypeScript.Syntax.Constructor where liftCompare = genericLiftCompare
 instance Show1 Language.TypeScript.Syntax.Constructor where liftShowsPrec = genericLiftShowsPrec
@ -352,6 +387,8 @@ instance Evaluatable Language.TypeScript.Syntax.Constructor
 data TypeParameter a = TypeParameter { _typeParameter :: !a, _typeParameterConstraint :: !a, _typeParameterDefaultType :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 TypeParameter
+
 instance Eq1 TypeParameter where liftEq = genericLiftEq
 instance Ord1 TypeParameter where liftCompare = genericLiftCompare
 instance Show1 TypeParameter where liftShowsPrec = genericLiftShowsPrec
@ -360,6 +397,8 @@ instance Evaluatable TypeParameter
 data TypeAssertion a = TypeAssertion { _typeAssertionParameters :: !a, _typeAssertionExpression :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 TypeAssertion
+
 instance Eq1 TypeAssertion where liftEq = genericLiftEq
 instance Ord1 TypeAssertion where liftCompare = genericLiftCompare
 instance Show1 TypeAssertion where liftShowsPrec = genericLiftShowsPrec
@ -368,6 +407,8 @@ instance Evaluatable TypeAssertion
 newtype Annotation a = Annotation { _annotationType :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Annotation
+
 instance Eq1 Annotation where liftEq = genericLiftEq
 instance Ord1 Annotation where liftCompare = genericLiftCompare
 instance Show1 Annotation where liftShowsPrec = genericLiftShowsPrec
@ -376,6 +417,8 @@ instance Evaluatable Annotation
 newtype Decorator a = Decorator { _decoratorTerm :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Decorator
+
 instance Eq1 Decorator where liftEq = genericLiftEq
 instance Ord1 Decorator where liftCompare = genericLiftCompare
 instance Show1 Decorator where liftShowsPrec = genericLiftShowsPrec
@ -384,6 +427,8 @@ instance Evaluatable Decorator
 newtype ComputedPropertyName a = ComputedPropertyName a
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ComputedPropertyName
+
 instance Eq1 ComputedPropertyName where liftEq = genericLiftEq
 instance Ord1 ComputedPropertyName where liftCompare = genericLiftCompare
 instance Show1 ComputedPropertyName where liftShowsPrec = genericLiftShowsPrec
@ -392,6 +437,8 @@ instance Evaluatable ComputedPropertyName
 newtype Constraint a = Constraint { _constraintType :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Constraint
+
 instance Eq1 Constraint where liftEq = genericLiftEq
 instance Ord1 Constraint where liftCompare = genericLiftCompare
 instance Show1 Constraint where liftShowsPrec = genericLiftShowsPrec
@ -400,6 +447,8 @@ instance Evaluatable Constraint
 newtype DefaultType a = DefaultType { _defaultType :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 DefaultType
+
 instance Eq1 DefaultType where liftEq = genericLiftEq
 instance Ord1 DefaultType where liftCompare = genericLiftCompare
 instance Show1 DefaultType where liftShowsPrec = genericLiftShowsPrec
@ -408,6 +457,8 @@ instance Evaluatable DefaultType
 newtype ParenthesizedType a = ParenthesizedType { _parenthesizedType :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ParenthesizedType
+
 instance Eq1 ParenthesizedType where liftEq = genericLiftEq
 instance Ord1 ParenthesizedType where liftCompare = genericLiftCompare
 instance Show1 ParenthesizedType where liftShowsPrec = genericLiftShowsPrec
@ -416,6 +467,8 @@ instance Evaluatable ParenthesizedType
 newtype PredefinedType a = PredefinedType { _predefinedType :: ByteString }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 PredefinedType
+
 instance Eq1 PredefinedType where liftEq = genericLiftEq
 instance Ord1 PredefinedType where liftCompare = genericLiftCompare
 instance Show1 PredefinedType where liftShowsPrec = genericLiftShowsPrec
@ -424,6 +477,8 @@ instance Evaluatable PredefinedType
 newtype TypeIdentifier a = TypeIdentifier ByteString
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 TypeIdentifier
+
 instance Eq1 TypeIdentifier where liftEq = genericLiftEq
 instance Ord1 TypeIdentifier where liftCompare = genericLiftCompare
 instance Show1 TypeIdentifier where liftShowsPrec = genericLiftShowsPrec
@ -432,6 +487,8 @@ instance Evaluatable TypeIdentifier
 data NestedIdentifier a = NestedIdentifier !a !a
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 NestedIdentifier
+
 instance Eq1 NestedIdentifier where liftEq = genericLiftEq
 instance Ord1 NestedIdentifier where liftCompare = genericLiftCompare
 instance Show1 NestedIdentifier where liftShowsPrec = genericLiftShowsPrec
@ -440,6 +497,8 @@ instance Evaluatable NestedIdentifier
 data NestedTypeIdentifier a = NestedTypeIdentifier !a !a
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 NestedTypeIdentifier
+
 instance Eq1 NestedTypeIdentifier where liftEq = genericLiftEq
 instance Ord1 NestedTypeIdentifier where liftCompare = genericLiftCompare
 instance Show1 NestedTypeIdentifier where liftShowsPrec = genericLiftShowsPrec
@ -448,6 +507,8 @@ instance Evaluatable NestedTypeIdentifier
 data GenericType a = GenericType { _genericTypeIdentifier :: !a, _genericTypeArguments :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 GenericType
+
 instance Eq1 GenericType where liftEq = genericLiftEq
 instance Ord1 GenericType where liftCompare = genericLiftCompare
 instance Show1 GenericType where liftShowsPrec = genericLiftShowsPrec
@ -456,6 +517,8 @@ instance Evaluatable GenericType
 data TypePredicate a = TypePredicate { _typePredicateIdentifier :: !a, _typePredicateType :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 TypePredicate
+
 instance Eq1 TypePredicate where liftEq = genericLiftEq
 instance Ord1 TypePredicate where liftCompare = genericLiftCompare
 instance Show1 TypePredicate where liftShowsPrec = genericLiftShowsPrec
@ -464,6 +527,8 @@ instance Evaluatable TypePredicate
 newtype ObjectType a = ObjectType { _objectTypeElements :: [a] }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ObjectType
+
 instance Eq1 ObjectType where liftEq = genericLiftEq
 instance Ord1 ObjectType where liftCompare = genericLiftCompare
 instance Show1 ObjectType where liftShowsPrec = genericLiftShowsPrec
@ -472,6 +537,8 @@ instance Evaluatable ObjectType
 data With a = With { _withExpression :: !a, _withBody :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 With
+
 instance Eq1 With where liftEq = genericLiftEq
 instance Ord1 With where liftCompare = genericLiftCompare
 instance Show1 With where liftShowsPrec = genericLiftShowsPrec
@ -480,6 +547,8 @@ instance Evaluatable With
 newtype AmbientDeclaration a = AmbientDeclaration { _ambientDeclarationBody :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 AmbientDeclaration
+
 instance Eq1 AmbientDeclaration where liftEq = genericLiftEq
 instance Ord1 AmbientDeclaration where liftCompare = genericLiftCompare
 instance Show1 AmbientDeclaration where liftShowsPrec = genericLiftShowsPrec
@ -490,6 +559,8 @@ instance Evaluatable AmbientDeclaration where
 data EnumDeclaration a = EnumDeclaration { enumDeclarationIdentifier :: !a, _enumDeclarationBody :: ![a] }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 EnumDeclaration
+
 instance Eq1 EnumDeclaration where liftEq = genericLiftEq
 instance Ord1 EnumDeclaration where liftCompare = genericLiftCompare
 instance Show1 EnumDeclaration where liftShowsPrec = genericLiftShowsPrec
@ -501,6 +572,8 @@ instance Declarations a => Declarations (EnumDeclaration a) where
 newtype ExtendsClause a = ExtendsClause { _extendsClauses :: [a] }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ExtendsClause
+
 instance Eq1 ExtendsClause where liftEq = genericLiftEq
 instance Ord1 ExtendsClause where liftCompare = genericLiftCompare
 instance Show1 ExtendsClause where liftShowsPrec = genericLiftShowsPrec
@ -509,6 +582,8 @@ instance Evaluatable ExtendsClause
 newtype ArrayType a = ArrayType { _arrayType :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ArrayType
+
 instance Eq1 ArrayType where liftEq = genericLiftEq
 instance Ord1 ArrayType where liftCompare = genericLiftCompare
 instance Show1 ArrayType where liftShowsPrec = genericLiftShowsPrec
@ -517,6 +592,8 @@ instance Evaluatable ArrayType
 newtype FlowMaybeType a = FlowMaybeType { _flowMaybeType :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 FlowMaybeType
+
 instance Eq1 FlowMaybeType where liftEq = genericLiftEq
 instance Ord1 FlowMaybeType where liftCompare = genericLiftCompare
 instance Show1 FlowMaybeType where liftShowsPrec = genericLiftShowsPrec
@ -525,6 +602,8 @@ instance Evaluatable FlowMaybeType
 newtype TypeQuery a = TypeQuery { _typeQuerySubject :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 TypeQuery
+
 instance Eq1 TypeQuery where liftEq = genericLiftEq
 instance Ord1 TypeQuery where liftCompare = genericLiftCompare
 instance Show1 TypeQuery where liftShowsPrec = genericLiftShowsPrec
@ -533,6 +612,8 @@ instance Evaluatable TypeQuery
 newtype IndexTypeQuery a = IndexTypeQuery { _indexTypeQuerySubject :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 IndexTypeQuery
+
 instance Eq1 IndexTypeQuery where liftEq = genericLiftEq
 instance Ord1 IndexTypeQuery where liftCompare = genericLiftCompare
 instance Show1 IndexTypeQuery where liftShowsPrec = genericLiftShowsPrec
@ -541,6 +622,8 @@ instance Evaluatable IndexTypeQuery
 newtype TypeArguments a = TypeArguments { _typeArguments :: [a] }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 TypeArguments
+
 instance Eq1 TypeArguments where liftEq = genericLiftEq
 instance Ord1 TypeArguments where liftCompare = genericLiftCompare
 instance Show1 TypeArguments where liftShowsPrec = genericLiftShowsPrec
@ -549,6 +632,8 @@ instance Evaluatable TypeArguments
 newtype ThisType a = ThisType ByteString
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ThisType
+
 instance Eq1 ThisType where liftEq = genericLiftEq
 instance Ord1 ThisType where liftCompare = genericLiftCompare
 instance Show1 ThisType where liftShowsPrec = genericLiftShowsPrec
@ -557,6 +642,8 @@ instance Evaluatable ThisType
 newtype ExistentialType a = ExistentialType ByteString
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ExistentialType
+
 instance Eq1 ExistentialType where liftEq = genericLiftEq
 instance Ord1 ExistentialType where liftCompare = genericLiftCompare
 instance Show1 ExistentialType where liftShowsPrec = genericLiftShowsPrec
@ -565,6 +652,8 @@ instance Evaluatable ExistentialType
 newtype LiteralType a = LiteralType { _literalTypeSubject :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 LiteralType
+
 instance Eq1 LiteralType where liftEq = genericLiftEq
 instance Ord1 LiteralType where liftCompare = genericLiftCompare
 instance Show1 LiteralType where liftShowsPrec = genericLiftShowsPrec
@ -573,6 +662,8 @@ instance Evaluatable LiteralType
 data PropertySignature a = PropertySignature { _modifiers :: ![a], _propertySignaturePropertyName :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 PropertySignature
+
 instance Eq1 PropertySignature where liftEq = genericLiftEq
 instance Ord1 PropertySignature where liftCompare = genericLiftCompare
 instance Show1 PropertySignature where liftShowsPrec = genericLiftShowsPrec
@ -581,6 +672,8 @@ instance Evaluatable PropertySignature
 data CallSignature a = CallSignature { _callSignatureTypeParameters :: !a, _callSignatureParameters :: ![a], _callSignatureType :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 CallSignature
+
 instance Eq1 CallSignature where liftEq = genericLiftEq
 instance Ord1 CallSignature where liftCompare = genericLiftCompare
 instance Show1 CallSignature where liftShowsPrec = genericLiftShowsPrec
@ -590,6 +683,8 @@ instance Evaluatable CallSignature
 data ConstructSignature a = ConstructSignature { _constructSignatureTypeParameters :: !a, _constructSignatureParameters :: ![a], _constructSignatureType :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ConstructSignature
+
 instance Eq1 ConstructSignature where liftEq = genericLiftEq
 instance Ord1 ConstructSignature where liftCompare = genericLiftCompare
 instance Show1 ConstructSignature where liftShowsPrec = genericLiftShowsPrec
@ -598,6 +693,8 @@ instance Evaluatable ConstructSignature
 data IndexSignature a = IndexSignature { _indexSignatureSubject :: a, _indexSignatureType :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 IndexSignature
+
 instance Eq1 IndexSignature where liftEq = genericLiftEq
 instance Ord1 IndexSignature where liftCompare = genericLiftCompare
 instance Show1 IndexSignature where liftShowsPrec = genericLiftShowsPrec
@ -606,6 +703,8 @@ instance Evaluatable IndexSignature
 data AbstractMethodSignature a = AbstractMethodSignature { _abstractMethodSignatureContext :: ![a], _abstractMethodSignatureName :: !a, _abstractMethodSignatureParameters :: ![a] }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 AbstractMethodSignature
+
 instance Eq1 AbstractMethodSignature where liftEq = genericLiftEq
 instance Ord1 AbstractMethodSignature where liftCompare = genericLiftCompare
 instance Show1 AbstractMethodSignature where liftShowsPrec = genericLiftShowsPrec
@ -614,6 +713,8 @@ instance Evaluatable AbstractMethodSignature
 data Debugger a = Debugger
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Debugger
+
 instance Eq1 Debugger where liftEq = genericLiftEq
 instance Ord1 Debugger where liftCompare = genericLiftCompare
 instance Show1 Debugger where liftShowsPrec = genericLiftShowsPrec
@ -622,6 +723,8 @@ instance Evaluatable Debugger
 data ForOf a = ForOf { _forOfBinding :: !a, _forOfSubject :: !a, _forOfBody :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ForOf
+
 instance Eq1 ForOf where liftEq = genericLiftEq
 instance Ord1 ForOf where liftCompare = genericLiftCompare
 instance Show1 ForOf where liftShowsPrec = genericLiftShowsPrec
@ -630,6 +733,8 @@ instance Evaluatable ForOf
 data This a = This
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 This
+
 instance Eq1 This where liftEq = genericLiftEq
 instance Ord1 This where liftCompare = genericLiftCompare
 instance Show1 This where liftShowsPrec = genericLiftShowsPrec
@ -638,6 +743,8 @@ instance Evaluatable This
 data LabeledStatement a = LabeledStatement { _labeledStatementIdentifier :: !a, _labeledStatementSubject :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 LabeledStatement
+
 instance Eq1 LabeledStatement where liftEq = genericLiftEq
 instance Ord1 LabeledStatement where liftCompare = genericLiftCompare
 instance Show1 LabeledStatement where liftShowsPrec = genericLiftShowsPrec
@ -646,6 +753,8 @@ instance Evaluatable LabeledStatement
 newtype Update a = Update { _updateSubject :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Update
+
 instance Eq1 Update where liftEq = genericLiftEq
 instance Ord1 Update where liftCompare = genericLiftCompare
 instance Show1 Update where liftShowsPrec = genericLiftShowsPrec
@ -658,6 +767,8 @@ instance Eq1 Module where liftEq = genericLiftEq
 instance Ord1 Module where liftCompare = genericLiftCompare
 instance Show1 Module where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 Module
+
 instance Evaluatable Module where
  eval (Module iden xs) = do
    name <- either (throwEvalError . FreeVariablesError) pure (freeVariable $ subterm iden)
@ -673,6 +784,8 @@ instance Eq1 InternalModule where liftEq = genericLiftEq
 instance Ord1 InternalModule where liftCompare = genericLiftCompare
 instance Show1 InternalModule where liftShowsPrec = genericLiftShowsPrec

+instance ToJSONFields1 InternalModule
+
 instance Evaluatable InternalModule where
  eval (InternalModule iden xs) = do
    name <- either (throwEvalError . FreeVariablesError) pure (freeVariable $ subterm iden)
@ -686,6 +799,8 @@ instance Declarations a => Declarations (InternalModule a) where
 data ImportAlias a = ImportAlias { _importAliasSubject :: !a, _importAlias :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ImportAlias
+
 instance Eq1 ImportAlias where liftEq = genericLiftEq
 instance Ord1 ImportAlias where liftCompare = genericLiftCompare
 instance Show1 ImportAlias where liftShowsPrec = genericLiftShowsPrec
@ -694,6 +809,8 @@ instance Evaluatable ImportAlias
 data Super a = Super
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Super
+
 instance Eq1 Super where liftEq = genericLiftEq
 instance Ord1 Super where liftCompare = genericLiftCompare
 instance Show1 Super where liftShowsPrec = genericLiftShowsPrec
@ -702,6 +819,8 @@ instance Evaluatable Super
 data Undefined a = Undefined
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 Undefined
+
 instance Eq1 Undefined where liftEq = genericLiftEq
 instance Ord1 Undefined where liftCompare = genericLiftCompare
 instance Show1 Undefined where liftShowsPrec = genericLiftShowsPrec
@ -710,6 +829,8 @@ instance Evaluatable Undefined
 data ClassHeritage a = ClassHeritage { _classHeritageExtendsClause :: !a, _implementsClause :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ClassHeritage
+
 instance Eq1 ClassHeritage where liftEq = genericLiftEq
 instance Ord1 ClassHeritage where liftCompare = genericLiftCompare
 instance Show1 ClassHeritage where liftShowsPrec = genericLiftShowsPrec
@ -724,6 +845,8 @@ instance Show1 AbstractClass where liftShowsPrec = genericLiftShowsPrec
 instance Declarations a => Declarations (AbstractClass a) where
  declaredName AbstractClass{..} = declaredName abstractClassIdentifier

+instance ToJSONFields1 AbstractClass
+
 instance Evaluatable AbstractClass where
  eval AbstractClass{..} = do
    name <- either (throwEvalError . FreeVariablesError) pure (freeVariable $ subterm abstractClassIdentifier)
@ -738,6 +861,8 @@ instance Evaluatable AbstractClass where
 data JsxElement a = JsxElement { _jsxOpeningElement :: !a,  _jsxElements :: ![a], _jsxClosingElement :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 JsxElement
+
 instance Eq1 JsxElement where liftEq = genericLiftEq
 instance Ord1 JsxElement where liftCompare = genericLiftCompare
 instance Show1 JsxElement where liftShowsPrec = genericLiftShowsPrec
@ -746,6 +871,8 @@ instance Evaluatable JsxElement
 newtype JsxText a = JsxText ByteString
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 JsxText
+
 instance Eq1 JsxText where liftEq = genericLiftEq
 instance Ord1 JsxText where liftCompare = genericLiftCompare
 instance Show1 JsxText where liftShowsPrec = genericLiftShowsPrec
@ -754,6 +881,8 @@ instance Evaluatable JsxText
 newtype JsxExpression a = JsxExpression { _jsxExpression :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 JsxExpression
+
 instance Eq1 JsxExpression where liftEq = genericLiftEq
 instance Ord1 JsxExpression where liftCompare = genericLiftCompare
 instance Show1 JsxExpression where liftShowsPrec = genericLiftShowsPrec
@ -762,6 +891,8 @@ instance Evaluatable JsxExpression
 data JsxOpeningElement a = JsxOpeningElement { _jsxOpeningElementIdentifier :: !a,  _jsxAttributes :: ![a] }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 JsxOpeningElement
+
 instance Eq1 JsxOpeningElement where liftEq = genericLiftEq
 instance Ord1 JsxOpeningElement where liftCompare = genericLiftCompare
 instance Show1 JsxOpeningElement where liftShowsPrec = genericLiftShowsPrec
@ -770,6 +901,8 @@ instance Evaluatable JsxOpeningElement
 newtype JsxClosingElement a = JsxClosingElement { _jsxClosingElementIdentifier :: a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 JsxClosingElement
+
 instance Eq1 JsxClosingElement where liftEq = genericLiftEq
 instance Ord1 JsxClosingElement where liftCompare = genericLiftCompare
 instance Show1 JsxClosingElement where liftShowsPrec = genericLiftShowsPrec
@ -778,6 +911,8 @@ instance Evaluatable JsxClosingElement
 data JsxSelfClosingElement a = JsxSelfClosingElement { _jsxSelfClosingElementIdentifier :: !a, _jsxSelfClosingElementAttributes :: ![a] }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 JsxSelfClosingElement
+
 instance Eq1 JsxSelfClosingElement where liftEq = genericLiftEq
 instance Ord1 JsxSelfClosingElement where liftCompare = genericLiftCompare
 instance Show1 JsxSelfClosingElement where liftShowsPrec = genericLiftShowsPrec
@ -786,6 +921,8 @@ instance Evaluatable JsxSelfClosingElement
 data JsxAttribute a = JsxAttribute { _jsxAttributeTarget :: !a, _jsxAttributeValue :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 JsxAttribute
+
 instance Eq1 JsxAttribute where liftEq = genericLiftEq
 instance Ord1 JsxAttribute where liftCompare = genericLiftCompare
 instance Show1 JsxAttribute where liftShowsPrec = genericLiftShowsPrec
@ -794,6 +931,8 @@ instance Evaluatable JsxAttribute
 newtype ImplementsClause a = ImplementsClause { _implementsClauseTypes :: [a] }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 ImplementsClause
+
 instance Eq1 ImplementsClause where liftEq = genericLiftEq
 instance Ord1 ImplementsClause where liftCompare = genericLiftCompare
 instance Show1 ImplementsClause where liftShowsPrec = genericLiftShowsPrec
@ -802,6 +941,8 @@ instance Evaluatable ImplementsClause
 data OptionalParameter a = OptionalParameter { _optionalParameterContext :: ![a], _optionalParameterSubject :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 OptionalParameter
+
 instance Eq1 OptionalParameter where liftEq = genericLiftEq
 instance Ord1 OptionalParameter where liftCompare = genericLiftCompare
 instance Show1 OptionalParameter where liftShowsPrec = genericLiftShowsPrec
@ -810,6 +951,8 @@ instance Evaluatable OptionalParameter
 data RequiredParameter a = RequiredParameter { _requiredParameterContext :: ![a], _requiredParameterSubject :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 RequiredParameter
+
 instance Eq1 RequiredParameter where liftEq = genericLiftEq
 instance Ord1 RequiredParameter where liftCompare = genericLiftCompare
 instance Show1 RequiredParameter where liftShowsPrec = genericLiftShowsPrec
@ -818,6 +961,8 @@ instance Evaluatable RequiredParameter
 data RestParameter a = RestParameter { _restParameterContext :: ![a], _restParameterSubject :: !a }
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 RestParameter
+
 instance Eq1 RestParameter where liftEq = genericLiftEq
 instance Ord1 RestParameter where liftCompare = genericLiftCompare
 instance Show1 RestParameter where liftShowsPrec = genericLiftShowsPrec
@ -826,6 +971,8 @@ instance Evaluatable RestParameter
 newtype JsxFragment a = JsxFragment [a]
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 JsxFragment
+
 instance Eq1 JsxFragment where liftEq = genericLiftEq
 instance Ord1 JsxFragment where liftCompare = genericLiftCompare
 instance Show1 JsxFragment where liftShowsPrec = genericLiftShowsPrec
@ -834,6 +981,8 @@ instance Evaluatable JsxFragment
 data JsxNamespaceName a = JsxNamespaceName a a
  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)

+instance ToJSONFields1 JsxNamespaceName
+
 instance Eq1 JsxNamespaceName where liftEq = genericLiftEq
 instance Ord1 JsxNamespaceName where liftCompare = genericLiftCompare
 instance Show1 JsxNamespaceName where liftShowsPrec = genericLiftShowsPrec
--- a/src/Semantic/Graph.hs
+++ b/src/Semantic/Graph.hs
@ -19,6 +19,7 @@ module Semantic.Graph
 import           Analysis.Abstract.Evaluating
 import           Analysis.Abstract.Graph
 import           Control.Monad.Effect.Trace
+import           Control.Abstract
 import qualified Control.Exception as Exc
 import           Control.Monad.Effect (reinterpret)
 import           Data.Abstract.Address
@ -65,10 +66,7 @@ graph graphType project
            . resumingResolutionError
            . resumingAddressError
            . graphing
-            . constrainingTypes
-
-          constrainingTypes :: Evaluator (Located Precise) (Value (Located Precise)) effects a -> Evaluator (Located Precise) (Value (Located Precise)) effects a
-          constrainingTypes = id
+            . runTermEvaluator @_ @_ @(Value (Located Precise))

 -- | Parse a list of files into a 'Package'.
 parsePackage :: Members '[Distribute WrappedTask, Files, Resolution, Task, Trace] effs
@ -100,8 +98,8 @@ parseModule parser rootDir file = do
 withTermSpans :: ( HasField fields Span
                 , Member (Reader Span) effects
                 )
-              => SubtermAlgebra (TermF syntax (Record fields)) (Term syntax (Record fields)) (Evaluator location value effects a)
-              -> SubtermAlgebra (TermF syntax (Record fields)) (Term syntax (Record fields)) (Evaluator location value effects a)
+              => SubtermAlgebra (TermF syntax (Record fields)) term (TermEvaluator term location value effects a)
+              -> SubtermAlgebra (TermF syntax (Record fields)) term (TermEvaluator term location value effects a)
 withTermSpans recur term = withCurrentSpan (getField (termFAnnotation term)) (recur term)

 resumingResolutionError :: (Applicative (m effects), Effectful m, Member Trace effects) => m (Resumable ResolutionError ': effects) a -> m effects a
--- a/src/Semantic/Task.hs
+++ b/src/Semantic/Task.hs
@ -49,7 +49,7 @@ module Semantic.Task

 import           Analysis.Decorator (decoratorWithAlgebra)
 import qualified Assigning.Assignment as Assignment
-import qualified Control.Abstract.Evaluator as Analysis
+import qualified Control.Abstract as Analysis
 import           Control.Monad
 import           Control.Monad.Effect
 import           Control.Monad.Effect.Exception
@ -101,8 +101,8 @@ type Renderer i o = i -> o
 parse :: Member Task effs => Parser term -> Blob -> Eff effs term
 parse parser = send . Parse parser

-- | A task running some 'Analysis.MonadAnalysis' to completion.
-analyze :: Member Task effs => (Analysis.Evaluator location value effects a -> result) -> Analysis.Evaluator location value effects a -> Eff effs result
+-- | A task running some 'Analysis.TermEvaluator' to completion.
+analyze :: Member Task effs => (Analysis.TermEvaluator term location value effects a -> result) -> Analysis.TermEvaluator term location value effects a -> Eff effs result
 analyze interpret analysis = send (Analyze interpret analysis)

 -- | A task which decorates a 'Term' with values computed using the supplied 'RAlgebra' function.
@ -158,7 +158,7 @@ runTraceInTelemetry = interpret (\ (Trace str) -> writeLog Debug str [])
 -- | An effect describing high-level tasks to be performed.
 data Task output where
  Parse     :: Parser term -> Blob -> Task term
-  Analyze   :: (Analysis.Evaluator location value effects a -> result) -> Analysis.Evaluator location value effects a -> Task result
+  Analyze  :: (Analysis.TermEvaluator term location value effects a -> result) -> Analysis.TermEvaluator term location value effects a -> Task result
  Decorate  :: Functor f => RAlgebra (TermF f (Record fields)) (Term f (Record fields)) field -> Term f (Record fields) -> Task (Term f (Record (field ': fields)))
  Diff      :: (Diffable syntax, Eq1 syntax, GAlign syntax, Show1 syntax, Traversable syntax) => These (Term syntax (Record fields1)) (Term syntax (Record fields2)) -> Task (Diff syntax (Record fields1) (Record fields2))
  Render    :: Renderer input output -> input -> Task output
--- a/src/Semantic/Util.hs
+++ b/src/Semantic/Util.hs
@ -1,4 +1,4 @@
-{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators #-}
 {-# OPTIONS_GHC -Wno-missing-signatures #-}
 module Semantic.Util where

@ -6,6 +6,7 @@ import           Analysis.Abstract.Caching
 import           Analysis.Abstract.Collecting
 import           Analysis.Abstract.Evaluating as X
 import           Control.Abstract.Evaluator
+import           Control.Abstract.TermEvaluator
 import           Control.Monad.Effect.Trace (runPrintingTrace)
 import           Data.Abstract.Address
 import           Data.Abstract.Evaluatable
@ -13,7 +14,9 @@ import           Data.Abstract.Value
 import           Data.Abstract.Type
 import           Data.Blob
 import           Data.Project
+import           Data.Functor.Foldable
 import qualified Data.Language as Language
+import           Data.Term
 import qualified GHC.TypeLits as TypeLevel
 import           Language.Preluded
 import           Parsing.Parser
@ -21,6 +24,7 @@ import           Prologue
 import           Semantic.Graph
 import           Semantic.IO as IO
 import           Semantic.Task
+import           Text.Show (showListWith)

 import qualified Language.Python.Assignment as Python
 import qualified Language.Ruby.Assignment as Ruby
@ -38,7 +42,7 @@ justEvaluating
  . runEnvironmentError
  . runEvalError
  . runAddressError
-  . constrainedToValuePrecise
+  . runTermEvaluator @_ @Precise

 evaluatingWithHoles
  = runM
@ -50,15 +54,15 @@ evaluatingWithHoles
  . resumingEnvironmentError
  . resumingEvalError
  . resumingResolutionError
-  . resumingAddressError @(Value Precise) @Precise
-  . constrainedToValuePrecise
+  . resumingAddressError
+  . runTermEvaluator @_ @Precise

-- The order is significant here: caching has to run before typeChecking, or else we’ll nondeterministically produce TypeErrors as part of the result set. While this is probably actually correct, it will require us to have an Ord instance for TypeError, which we don’t have yet.
 checking
-  = runM
-  . fmap (first reassociate)
+  = runM @_ @IO
  . evaluating
  . runPrintingTrace
+  . runTermEvaluator @_ @Monovariant @Type
+  . caching @[]
  . providingLiveSet
  . runLoadError
  . runUnspecialized
@ -67,14 +71,6 @@ checking
  . runEvalError
  . runAddressError
  . runTypeError
-  . caching @[]
-  . constrainedToTypeMonovariant
-
-constrainedToValuePrecise :: Evaluator Precise (Value Precise) effects a -> Evaluator Precise (Value Precise) effects a
-constrainedToValuePrecise = id
-
-constrainedToTypeMonovariant :: Evaluator Monovariant (Type Monovariant) effects a -> Evaluator Monovariant (Type Monovariant) effects a
-constrainedToTypeMonovariant = id

 evalGoProject path = justEvaluating =<< evaluateProject goParser Language.Go Nothing path
 evalRubyProject path = justEvaluating =<< evaluateProject rubyParser Language.Ruby rubyPrelude path
@ -91,8 +87,8 @@ pythonPrelude = Just $ File (TypeLevel.symbolVal (Proxy :: Proxy (PreludePath Py
 javaScriptPrelude = Just $ File (TypeLevel.symbolVal (Proxy :: Proxy (PreludePath TypeScript.Term))) (Just Language.JavaScript)

 -- Evaluate a project, starting at a single entrypoint.
-evaluateProject parser lang prelude path = evaluatePackageWith id withTermSpans <$> runTask (readProject Nothing path lang [] >>= parsePackage parser prelude)
-evaluateProjectWithCaching parser lang prelude path = evaluatePackageWith convergingModules (withTermSpans . cachingTerms) <$> runTask (readProject Nothing path lang [] >>= parsePackage parser prelude)
+evaluateProject parser lang prelude path = evaluatePackageWith id withTermSpans . fmap quieterm <$> runTask (readProject Nothing path lang [] >>= parsePackage parser prelude)
+evaluateProjectWithCaching parser lang prelude path = evaluatePackageWith convergingModules (withTermSpans . cachingTerms) . fmap quieterm <$> runTask (readProject Nothing path lang [] >>= parsePackage parser prelude)


 parseFile :: Parser term -> FilePath -> IO term
@ -109,3 +105,33 @@ mergeExcs :: Either (SomeExc (Sum excs)) (Either (SomeExc exc) result) -> Either
 mergeExcs = either (\ (SomeExc sum) -> Left (SomeExc (weakenSum sum))) (either (\ (SomeExc exc) -> Left (SomeExc (injectSum exc))) Right)

 reassociate = mergeExcs . mergeExcs . mergeExcs . mergeExcs . mergeExcs . mergeExcs . mergeExcs . first injectConst
+reassociateTypes = mergeExcs . mergeExcs . mergeExcs . mergeExcs . mergeExcs . mergeExcs . first injectConst
+
+
+newtype Quieterm syntax ann = Quieterm { unQuieterm :: TermF syntax ann (Quieterm syntax ann) }
+  deriving (Declarations, FreeVariables)
+
+type instance Base (Quieterm syntax ann) = TermF syntax ann
+instance Functor syntax => Recursive   (Quieterm syntax ann) where project = unQuieterm
+instance Functor syntax => Corecursive (Quieterm syntax ann) where embed   =   Quieterm
+
+instance Eq1 syntax => Eq1 (Quieterm syntax) where
+  liftEq eqA = go where go t1 t2 = liftEq2 eqA go (unQuieterm t1) (unQuieterm t2)
+
+instance (Eq1 syntax, Eq ann) => Eq (Quieterm syntax ann) where
+  (==) = eq1
+
+instance Ord1 syntax => Ord1 (Quieterm syntax) where
+  liftCompare comp = go where go t1 t2 = liftCompare2 comp go (unQuieterm t1) (unQuieterm t2)
+
+instance (Ord1 syntax, Ord ann) => Ord (Quieterm syntax ann) where
+  compare = compare1
+
+instance Show1 syntax => Show1 (Quieterm syntax) where
+  liftShowsPrec _ _ = go where go d = liftShowsPrec go (showListWith (go 0)) d . termFOut . unQuieterm
+
+instance Show1 syntax => Show (Quieterm syntax ann) where
+  showsPrec = liftShowsPrec (const (const id)) (const id)
+
+quieterm :: (Recursive term, Base term ~ TermF syntax ann) => term -> Quieterm syntax ann
+quieterm = cata Quieterm
--- a/test/Analysis/Python/Spec.hs
+++ b/test/Analysis/Python/Spec.hs
@ -39,7 +39,7 @@ spec = parallel $ do
      res `shouldBe` Right [injValue (String "\"foo!\"")]

  where
-    ns n = Just . Latest . Just . injValue . Namespace n
+    ns n = Just . Latest . Last . Just . injValue . Namespace n
    addr = Address . Precise
    fixtures = "test/fixtures/python/analysis/"
    evaluate entry = evalPythonProject (fixtures <> entry)
--- a/test/Analysis/Ruby/Spec.hs
+++ b/test/Analysis/Ruby/Spec.hs
@ -76,7 +76,7 @@ spec = parallel $ do
      traces `shouldContain` [ "\"hello\"" ]

  where
-    ns n = Just . Latest . Just . injValue . Namespace n
+    ns n = Just . Latest . Last . Just . injValue . Namespace n
    addr = Address . Precise
    fixtures = "test/fixtures/ruby/analysis/"
    evaluate entry = evalRubyProject (fixtures <> entry)
--- a/test/Control/Abstract/Evaluator/Spec.hs
+++ b/test/Control/Abstract/Evaluator/Spec.hs
@ -31,7 +31,7 @@ spec = parallel $ do
 evaluate
  = runM
  . fmap (first reassociate)
-  . evaluating
+  . evaluating @Precise @(Value Precise)
  . runReader (PackageInfo (name "test") Nothing mempty)
  . runReader (ModuleInfo "test/Control/Abstract/Evaluator/Spec.hs")
  . Value.runValueError
@ -42,13 +42,9 @@ evaluate
  . fmap fst
  . runState (Gotos lowerBound)
  . runGoto Gotos getGotos
-  . constraining

 newtype Gotos effects = Gotos { getGotos :: GotoTable (State (Gotos effects) ': effects) (Value Precise) }

-constraining :: Evaluator Precise (Value Precise) effects a -> Evaluator Precise (Value Precise) effects a
-constraining = id
-
 reassociate :: Either Prelude.String (Either (SomeExc exc1) (Either (SomeExc exc2) (Either (SomeExc exc3) result))) -> Either (SomeExc (Sum '[Const Prelude.String, exc1, exc2, exc3])) result
 reassociate (Left s) = Left (SomeExc (injectSum (Const s)))
 reassociate (Right (Right (Right (Right a)))) = Right a
--- a/test/SpecHelpers.hs
+++ b/test/SpecHelpers.hs
@ -13,8 +13,7 @@ module SpecHelpers

 import Analysis.Abstract.Evaluating
 import Analysis.Abstract.Evaluating as X (EvaluatingState(..))
-import Control.Abstract.Addressable
-import Control.Abstract.Value
+import Control.Abstract
 import Control.Arrow ((&&&))
 import Control.Monad.Effect.Trace as X (runIgnoringTrace, runReturningTrace)
 import Control.Monad ((>=>))
@ -33,6 +32,7 @@ import Data.Project as X
 import Data.Functor.Listable as X
 import Data.Language as X
 import Data.List.NonEmpty as X (NonEmpty(..))
+import Data.Monoid as X (Last(..))
 import Data.Range as X
 import Data.Record as X
 import Data.Source as X
@ -88,14 +88,14 @@ testEvaluating
  . runEnvironmentError
  . runEvalError
  . runAddressError
-  . constrainedToValuePrecise
+  . runTermEvaluator @_ @Precise

 deNamespace :: Value Precise -> Maybe (Name, [Name])
 deNamespace = fmap (namespaceName &&& Env.names . namespaceScope) . prjValue @(Namespace Precise)

 derefQName :: Heap Precise (Cell Precise) (Value Precise) -> NonEmpty Name -> Environment Precise (Value Precise) -> Maybe (Value Precise)
 derefQName heap = go
-  where go (n1 :| ns) env = Env.lookup n1 env >>= flip heapLookup heap >>= unLatest >>= case ns of
+  where go (n1 :| ns) env = Env.lookup n1 env >>= flip heapLookup heap >>= getLast . unLatest >>= case ns of
          []        -> Just
          (n2 : ns) -> fmap namespaceScope . prjValue @(Namespace Precise) >=> go (n2 :| ns)