Merge branch 'master' into charliesome/value-ref-address

semantic.cabal

@@ -29,7 +29,6 @@ library
                      , Analysis.CyclomaticComplexity
                      , Analysis.Decorator
                      , Analysis.Declaration
-                     , Analysis.IdentifierName
                      , Analysis.PackageDef
                      -- Semantic assignment
                      , Assigning.Assignment
@@ -72,7 +71,6 @@ library
                      , Data.Abstract.Value
                      -- General datatype definitions & generic algorithms
                      , Data.Algebra
-                     , Data.Align.Generic
                      , Data.AST
                      , Data.Blob
                      , Data.Diff
@@ -270,7 +268,6 @@ test-suite test
                      , Data.Abstract.Path.Spec
                      , Data.Functor.Classes.Generic.Spec
                      , Data.Functor.Listable
-                     , Data.Mergeable.Spec
                      , Data.Scientific.Spec
                      , Data.Source.Spec
                      , Data.Term.Spec

src/Analysis/Abstract/Caching.hs

@@ -6,7 +6,6 @@ module Analysis.Abstract.Caching
 ) where
 
 import Control.Abstract
-import Data.Abstract.Address
 import Data.Abstract.Cache
 import Data.Abstract.Module
 import Data.Abstract.Ref
@@ -15,62 +14,60 @@ import Data.Semigroup.Reducer (Reducer)
 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
-              -> TermEvaluator term location value effects (Set (Cached location (Cell location) value))
+consultOracle :: (Cacheable term address (Cell address) value, Member (Reader (Cache term address (Cell address) value)) effects)
+              => Configuration term address (Cell address) value
+              -> TermEvaluator term address value effects (Set (Cached address (Cell address) 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
-           -> TermEvaluator term location value effects a
-           -> TermEvaluator term location value effects a
+withOracle :: Member (Reader (Cache term address (Cell address) value)) effects
+           => Cache term address (Cell address) value
+           -> TermEvaluator term address value effects a
+           -> TermEvaluator term address 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
-            -> TermEvaluator term location value effects (Maybe (Set (Cached location (Cell location) value)))
+lookupCache :: (Cacheable term address (Cell address) value, Member (State (Cache term address (Cell address) value)) effects)
+            => Configuration term address (Cell address) value
+            -> TermEvaluator term address value effects (Maybe (Set (Cached address (Cell address) 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 (Cached location (Cell location) value)
-                     -> TermEvaluator term location value effects (ValueRef location value)
-                     -> TermEvaluator term location value effects (ValueRef location value)
+cachingConfiguration :: (Cacheable term address (Cell address) value, Member (State (Cache term address (Cell address) value)) effects, Member (State (Heap address (Cell address) value)) effects)
+                     => Configuration term address (Cell address) value
+                     -> Set (Cached address (Cell address) value)
+                     -> TermEvaluator term address value effects (ValueRef address value)
+                     -> TermEvaluator term address value effects (ValueRef address value)
 cachingConfiguration configuration values action = do
   modify' (cacheSet configuration values)
   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
-         -> TermEvaluator term location value effects ()
+putCache :: Member (State (Cache term address (Cell address) value)) effects
+         => Cache term address (Cell address) value
+         -> TermEvaluator term address value effects ()
 putCache = put
 
 -- | Run an action starting from an empty out-cache, and return the out-cache afterwards.
-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 :: Member (State (Cache term address (Cell address) value)) effects
+             => TermEvaluator term address value effects a
+             -> TermEvaluator term address value effects (Cache term address (Cell address) 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.
-cachingTerms :: ( Cacheable term location (Cell location) value
+cachingTerms :: ( Cacheable term address (Cell address) value
                 , Corecursive term
-                , Members '[ Fresh
-                           , NonDet
-                           , Reader (Cache term location (Cell location) value)
-                           , Reader (Live location value)
-                           , State (Cache term location (Cell location) value)
-                           , State (Environment location)
-                           , State (Heap location (Cell location) value)
-                           ] effects
+                , Member NonDet effects
+                , Member (Reader (Cache term address (Cell address) value)) effects
+                , Member (Reader (Live address)) effects
+                , Member (State (Cache term address (Cell address) value)) effects
+                , Member (State (Environment address)) effects
+                , Member (State (Heap address (Cell address) value)) effects
                 )
-             => SubtermAlgebra (Base term) term (TermEvaluator term location value effects (ValueRef location value))
-             -> SubtermAlgebra (Base term) term (TermEvaluator term location value effects (ValueRef location value))
+             => SubtermAlgebra (Base term) term (TermEvaluator term address value effects (ValueRef address value))
+             -> SubtermAlgebra (Base term) term (TermEvaluator term address value effects (ValueRef address value))
 cachingTerms recur term = do
   c <- getConfiguration (embedSubterm term)
   cached <- lookupCache c
@@ -80,24 +77,22 @@ cachingTerms recur term = do
       pairs <- consultOracle c
       cachingConfiguration c pairs (recur term)
 
-convergingModules :: ( AbstractValue location value effects
-                     , Cacheable term location (Cell location) value
-                     , Members '[ Allocator location value
-                                , Fresh
-                                , NonDet
-                                , Reader (Cache term location (Cell location) value)
-                                , Reader (Environment location)
-                                , Reader (Live location value)
-                                , Resumable (AddressError location value)
-                                , Resumable (EnvironmentError location)
-                                , State (Cache term location (Cell location) value)
-                                , State (Environment location)
-                                , State (Heap location (Cell location) value)
-                                ] effects
-                     , Reducer value (Cell location value)
+convergingModules :: ( AbstractValue address value effects
+                     , Cacheable term address (Cell address) value
+                     , Member (Allocator address value) effects
+                     , Member Fresh effects
+                     , Member NonDet effects
+                     , Member (Reader (Cache term address (Cell address) value)) effects
+                     , Member (Reader (Environment address)) effects
+                     , Member (Reader (Live address)) effects
+                     , Member (Resumable (EnvironmentError address)) effects
+                     , Member (State (Cache term address (Cell address) value)) effects
+                     , Member (State (Environment address)) effects
+                     , Member (State (Heap address (Cell address) value)) effects
+                     , Reducer value (Cell address value)
                      )
-                  => SubtermAlgebra Module term (TermEvaluator term location value effects (Address location value))
-                  -> SubtermAlgebra Module term (TermEvaluator term location value effects (Address location value))
+                  => SubtermAlgebra Module term (TermEvaluator term address value effects address)
+                  -> SubtermAlgebra Module term (TermEvaluator term address value effects address)
 convergingModules recur m = do
   c <- getConfiguration (subterm (moduleBody m))
   -- Convergence here is predicated upon an Eq instance, not α-equivalence
@@ -131,11 +126,11 @@ converge seed f = loop seed
             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 (Cached location (Cell location) value) -> TermEvaluator term location value effects (ValueRef location value)
+scatter :: (Foldable t, Member NonDet effects, Member (State (Heap address (Cell address) value)) effects) => t (Cached address (Cell address) value) -> TermEvaluator term address value effects (ValueRef address value)
 scatter = foldMapA (\ (Cached value heap') -> TermEvaluator (putHeap heap') $> 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 :: Alternative f => TermEvaluator term address value (NonDet ': Reader (Cache term address (Cell address) value) ': State (Cache term address (Cell address) value) ': effects) a -> TermEvaluator term address value effects (f a, Cache term address (Cell address) value)
 caching
   = runState lowerBound
   . runReader lowerBound

src/Analysis/Abstract/Collecting.hs

@@ -11,38 +11,37 @@ import Data.Semilattice.Lower
 import Prologue
 
 -- | An analysis performing GC after every instruction.
-collectingTerms :: ( Foldable (Cell location)
-                   , Members '[ Reader (Live location value)
-                              , State (Heap location (Cell location) value)
-                              ] effects
-                   , Ord location
-                   , ValueRoots location value
+collectingTerms :: ( Foldable (Cell address)
+                   , Member (Reader (Live address)) effects
+                   , Member (State (Heap address (Cell address) value)) effects
+                   , Ord address
+                   , ValueRoots address value
                    )
-                => SubtermAlgebra (Base term) term (TermEvaluator term location value effects value)
-                -> SubtermAlgebra (Base term) term (TermEvaluator term location value effects value)
+                => SubtermAlgebra (Base term) term (TermEvaluator term address value effects value)
+                -> SubtermAlgebra (Base term) term (TermEvaluator term address value effects value)
 collectingTerms recur term = do
   roots <- TermEvaluator askRoots
   v <- recur term
   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
-      , Foldable (Cell location)
-      , ValueRoots location value
+gc :: ( Ord address
+      , Foldable (Cell address)
+      , ValueRoots address value
       )
-   => Live location value                 -- ^ The set of addresses to consider rooted.
-   -> Heap location (Cell location) value -- ^ A heap to collect unreachable addresses within.
-   -> Heap location (Cell location) value -- ^ A garbage-collected heap.
+   => Live address                      -- ^ The set of addresses to consider rooted.
+   -> Heap address (Cell address) value -- ^ A heap to collect unreachable addresses within.
+   -> Heap address (Cell address) value -- ^ A garbage-collected heap.
 gc roots heap = heapRestrict heap (reachable roots heap)
 
 -- | Compute the set of addresses reachable from a given root set in a given heap.
-reachable :: ( Ord location
-             , Foldable (Cell location)
-             , ValueRoots location value
+reachable :: ( Ord address
+             , Foldable (Cell address)
+             , ValueRoots address value
              )
-          => Live location value                 -- ^ The set of root addresses.
-          -> Heap location (Cell location) value -- ^ The heap to trace addresses through.
-          -> Live location value                 -- ^ The set of addresses reachable from the root set.
+          => Live address                      -- ^ The set of root addresses.
+          -> Heap address (Cell address) value -- ^ The heap to trace addresses through.
+          -> Live address                      -- ^ The set of addresses reachable from the root set.
 reachable roots heap = go mempty roots
   where go seen set = case liveSplit set of
           Nothing -> seen
@@ -51,5 +50,5 @@ reachable roots heap = go mempty roots
             _           -> seen)
 
 
-providingLiveSet :: Effectful (m location value) => m location value (Reader (Live location value) ': effects) a -> m location value effects a
+providingLiveSet :: Effectful (m address value) => m address value (Reader (Live address) ': effects) a -> m address value effects a
 providingLiveSet = runReader lowerBound

src/Analysis/Abstract/Dead.hs

@@ -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 -> TermEvaluator term location value effects ()
+killAll :: Member (State (Dead term)) effects => Dead term -> TermEvaluator term address value effects ()
 killAll = put
 
 -- | Revive a single term, removing it from the current 'Dead' set.
-revive :: (Member (State (Dead term)) effects, Ord term) => term -> TermEvaluator term location value effects ()
+revive :: (Member (State (Dead term)) effects, Ord term) => term -> TermEvaluator term address 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 (TermEvaluator term location value effects a)
-              -> SubtermAlgebra (Base term) term (TermEvaluator term location value effects a)
+              => SubtermAlgebra (Base term) term (TermEvaluator term address value effects a)
+              -> SubtermAlgebra (Base term) term (TermEvaluator term address 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 (TermEvaluator term location value effects a)
-               -> SubtermAlgebra Module term (TermEvaluator term location value effects a)
+               => SubtermAlgebra Module term (TermEvaluator term address value effects a)
+               -> SubtermAlgebra Module term (TermEvaluator term address value effects a)
 killingModules recur m = killAll (subterms (subterm (moduleBody m))) *> recur m
 
-providingDeadSet :: TermEvaluator term location value (State (Dead term) ': effects) a -> TermEvaluator term location value effects (a, Dead term)
+providingDeadSet :: TermEvaluator term address value (State (Dead term) ': effects) a -> TermEvaluator term address value effects (a, Dead term)
 providingDeadSet = runState lowerBound

src/Analysis/Abstract/Evaluating.hs

@@ -5,38 +5,37 @@ module Analysis.Abstract.Evaluating
 ) where
 
 import Control.Abstract
-import Data.Abstract.Address
 import Data.Semilattice.Lower
 
 -- | An analysis evaluating @term@s to @value@s with a list of @effects@ using 'Evaluatable', and producing incremental results of type @a@.
-data EvaluatingState location value = EvaluatingState
-  { environment :: Environment location
-  , heap        :: Heap location (Cell location) value
-  , modules     :: ModuleTable (Maybe (Environment location, Address location value))
-  , exports     :: Exports location
+data EvaluatingState address value = EvaluatingState
+  { environment :: Environment address
+  , heap        :: Heap address (Cell address) value
+  , modules     :: ModuleTable (Maybe (Environment address, address))
+  , exports     :: Exports address
   }
 
-deriving instance (Eq (Cell location value), Eq location, Eq value) => Eq (EvaluatingState location value)
-deriving instance (Ord (Cell location value), Ord location, Ord value) => Ord (EvaluatingState location value)
-deriving instance (Show (Cell location value), Show location, Show value) => Show (EvaluatingState location value)
+deriving instance (Eq (Cell address value), Eq address, Eq value) => Eq (EvaluatingState address value)
+deriving instance (Ord (Cell address value), Ord address, Ord value) => Ord (EvaluatingState address value)
+deriving instance (Show (Cell address value), Show address, Show value) => Show (EvaluatingState address value)
 
 
-evaluating :: Evaluator location value
+evaluating :: Evaluator address value
                 (  Fail
                 ': Fresh
-                ': Reader (Environment location)
-                ': State (Environment location)
-                ': State (Heap location (Cell location) value)
-                ': State (ModuleTable (Maybe (Environment location, Address location value)))
-                ': State (Exports location)
+                ': Reader (Environment address)
+                ': State (Environment address)
+                ': State (Heap address (Cell address) value)
+                ': State (ModuleTable (Maybe (Environment address, address)))
+                ': State (Exports address)
                 ': effects) result
-           -> Evaluator location value effects (Either String result, EvaluatingState location value)
+           -> Evaluator address value effects (Either String result, EvaluatingState address value)
 evaluating
   = fmap (\ ((((result, env), heap), modules), exports) -> (result, EvaluatingState env heap modules exports))
-  . runState lowerBound -- State (Exports location)
-  . runState lowerBound -- State (ModuleTable (Maybe (Environment location, Address location value)))
-  . runState lowerBound -- State (Heap location (Cell location) value)
-  . runState lowerBound -- State (Environment location)
-  . runReader lowerBound -- Reader (Environment location)
+  . runState lowerBound -- State (Exports address)
+  . runState lowerBound -- State (ModuleTable (Maybe (Environment address, Address location value)))
+  . runState lowerBound -- State (Heap address (Cell address) value)
+  . runState lowerBound -- State (Environment address)
+  . runReader lowerBound -- Reader (Environment address)
   . runFresh 0
   . runFail

src/Analysis/Abstract/Graph.hs

@@ -52,15 +52,14 @@ style = (defaultStyle (byteString . vertexName))
 
 -- | Add vertices to the graph for evaluated identifiers.
 graphingTerms :: ( Element Syntax.Identifier syntax
-                 , Members '[ Reader (Environment (Hole (Located location)))
-                            , Reader ModuleInfo
-                            , State (Environment (Hole (Located location)))
-                            , State (Graph Vertex)
-                            ] effects
+                 , Member (Reader (Environment (Hole (Located address)))) effects
+                 , Member (Reader ModuleInfo) effects
+                 , Member (State (Environment (Hole (Located address)))) effects
+                 , Member (State (Graph Vertex)) effects
                  , term ~ Term (Sum syntax) ann
                  )
-              => SubtermAlgebra (Base term) term (TermEvaluator term (Hole (Located location)) value effects a)
-              -> SubtermAlgebra (Base term) term (TermEvaluator term (Hole (Located location)) value effects a)
+              => SubtermAlgebra (Base term) term (TermEvaluator term (Hole (Located address)) value effects a)
+              -> SubtermAlgebra (Base term) term (TermEvaluator term (Hole (Located address)) value effects a)
 graphingTerms recur term@(In _ syntax) = do
   case project syntax of
     Just (Syntax.Identifier name) -> do
@@ -69,23 +68,22 @@ graphingTerms recur term@(In _ syntax) = do
     _ -> pure ()
   recur term
 
-graphingPackages :: Members '[ Reader ModuleInfo
-                             , Reader PackageInfo
-                             , State (Graph Vertex)
-                             ] effects
-                 => SubtermAlgebra Module term (TermEvaluator term location value effects a)
-                 -> SubtermAlgebra Module term (TermEvaluator term location value effects a)
+graphingPackages :: ( Member (Reader PackageInfo) effects
+                    , Member (State (Graph Vertex)) effects
+                    )
+                 => SubtermAlgebra Module term (TermEvaluator term address value effects a)
+                 -> SubtermAlgebra Module term (TermEvaluator term address value effects a)
 graphingPackages recur m = packageInclusion (moduleVertex (moduleInfo m)) *> recur m
 
 -- | Add vertices to the graph for evaluated modules and the packages containing them.
-graphingModules :: forall term location value effects a
-                .  Members '[ Modules location value
-                            , Reader ModuleInfo
-                            , State (Graph Vertex)
-                            ] effects
-               => SubtermAlgebra Module term (TermEvaluator term location value effects a)
-               -> SubtermAlgebra Module term (TermEvaluator term location value effects a)
-graphingModules recur m = interpose @(Modules location value) pure (\ m yield -> case m of
+graphingModules :: forall term address value effects a
+                .  ( Member (Modules address value) effects
+                   , Member (Reader ModuleInfo) effects
+                   , Member (State (Graph Vertex)) effects
+                   )
+               => SubtermAlgebra Module term (TermEvaluator term address value effects a)
+               -> SubtermAlgebra Module term (TermEvaluator term address value effects a)
+graphingModules recur m = interpose @(Modules address value) pure (\ m yield -> case m of
   Load   path -> moduleInclusion (moduleVertex (ModuleInfo path)) >> send m >>= yield
   Lookup path -> moduleInclusion (moduleVertex (ModuleInfo path)) >> send m >>= yield
   _ -> send m >>= yield)
@@ -100,9 +98,8 @@ moduleVertex = Module . BC.pack . modulePath
 
 -- | Add an edge from the current package to the passed vertex.
 packageInclusion :: ( Effectful m
-                    , Members '[ Reader PackageInfo
-                               , State (Graph Vertex)
-                               ] effects
+                    , Member (Reader PackageInfo) effects
+                    , Member (State (Graph Vertex)) effects
                     , Monad (m effects)
                     )
                  => Vertex
@@ -113,9 +110,8 @@ packageInclusion v = do
 
 -- | Add an edge from the current module to the passed vertex.
 moduleInclusion :: ( Effectful m
-                   , Members '[ Reader ModuleInfo
-                              , State (Graph Vertex)
-                              ] effects
+                   , Member (Reader ModuleInfo) effects
+                   , Member (State (Graph Vertex)) effects
                    , Monad (m effects)
                    )
                 => Vertex
@@ -125,14 +121,14 @@ moduleInclusion v = do
   appendGraph (vertex (moduleVertex m) `connect` vertex v)
 
 -- | Add an edge from the passed variable name to the module it originated within.
-variableDefinition :: ( Member (Reader (Environment (Hole (Located location)))) effects
-                      , Member (State (Environment (Hole (Located location)))) effects
+variableDefinition :: ( Member (Reader (Environment (Hole (Located address)))) effects
+                      , Member (State (Environment (Hole (Located address)))) effects
                       , Member (State (Graph Vertex)) effects
                       )
                    => Name
-                   -> TermEvaluator term (Hole (Located location)) value effects ()
+                   -> TermEvaluator term (Hole (Located address)) value effects ()
 variableDefinition name = do
-  graph <- maybe lowerBound (maybe lowerBound (vertex . moduleVertex . locationModule) . toMaybe . unAddress) <$> TermEvaluator (lookupEnv name)
+  graph <- maybe lowerBound (maybe lowerBound (vertex . moduleVertex . addressModule) . toMaybe) <$> TermEvaluator (lookupEnv name)
   appendGraph (vertex (Variable (unName name)) `connect` graph)
 
 appendGraph :: (Effectful m, Member (State (Graph Vertex)) effects) => Graph Vertex -> m effects ()

src/Analysis/Abstract/Tracing.hs

@@ -13,20 +13,19 @@ import Prologue
 --
 --   Instantiating @trace@ to @[]@ yields a linear trace analysis, while @Set@ yields a reachable state analysis.
 tracingTerms :: ( Corecursive term
-                , Members '[ Reader (Live location value)
-                           , State (Environment location)
-                           , State (Heap location (Cell location) value)
-                           , Writer (trace (Configuration term location (Cell location) value))
-                           ] effects
-                , Reducer (Configuration term location (Cell location) value) (trace (Configuration term location (Cell location) value))
+                , Member (Reader (Live address)) effects
+                , Member (State (Environment address)) effects
+                , Member (State (Heap address (Cell address) value)) effects
+                , Member (Writer (trace (Configuration term address (Cell address) value))) effects
+                , Reducer (Configuration term address (Cell address) value) (trace (Configuration term address (Cell address) value))
                 )
-             => trace (Configuration term location (Cell location) value)
-             -> SubtermAlgebra (Base term) term (TermEvaluator term location value effects a)
-             -> SubtermAlgebra (Base term) term (TermEvaluator term location value effects a)
+             => trace (Configuration term address (Cell address) value)
+             -> SubtermAlgebra (Base term) term (TermEvaluator term address value effects a)
+             -> SubtermAlgebra (Base term) term (TermEvaluator term address 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) -> TermEvaluator term location value effects ()
+trace :: Member (Writer (trace (Configuration term address (Cell address) value))) effects => trace (Configuration term address (Cell address) value) -> TermEvaluator term address value effects ()
 trace = tell
 
-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 :: Monoid (trace (Configuration term address (Cell address) value)) => TermEvaluator term address value (Writer (trace (Configuration term address (Cell address) value)) ': effects) a -> TermEvaluator term address value effects (a, trace (Configuration term address (Cell address) value))
 tracing = runWriter

src/Analysis/ConstructorName.hs

@@ -1,32 +1,11 @@
 {-# LANGUAGE ScopedTypeVariables, TypeFamilies, TypeOperators, UndecidableInstances #-}
 module Analysis.ConstructorName
 ( ConstructorName(..)
-, ConstructorLabel(..)
-, constructorLabel
 ) where
 
-import Data.Aeson
-import Data.ByteString.Char8 (ByteString, pack, unpack)
-import Data.JSON.Fields
 import Data.Sum
-import Data.Term
-import Data.Text.Encoding (decodeUtf8)
 import Prologue
 
--- | Compute a 'ConstructorLabel' label for a 'Term'.
-constructorLabel :: ConstructorName syntax => TermF syntax a b -> ConstructorLabel
-constructorLabel (In _ s) = ConstructorLabel $ pack (constructorName s)
-
-
-newtype ConstructorLabel = ConstructorLabel { unConstructorLabel :: ByteString }
-
-instance Show ConstructorLabel where
-  showsPrec _ (ConstructorLabel s) = showString (unpack s)
-
-instance ToJSONFields ConstructorLabel where
-  toJSONFields (ConstructorLabel s) = [ "category" .= decodeUtf8 s ]
-
-
 -- | A typeclass to retrieve the name of the data constructor for a value.
 --
 --   This typeclass employs the Advanced Overlap techniques designed by Oleg Kiselyov & Simon Peyton Jones: https://wiki.haskell.org/GHC/AdvancedOverlap; see also src/Analysis/Declaration.hs for discussion of the details of the mechanism.
@@ -40,8 +19,7 @@ instance Apply ConstructorName fs => ConstructorNameWithStrategy 'Custom (Sum fs
   constructorNameWithStrategy _ = apply @ConstructorName constructorName
 
 instance ConstructorNameWithStrategy 'Custom [] where
-  constructorNameWithStrategy _ [] = "[]"
-  constructorNameWithStrategy _ _  = ""
+  constructorNameWithStrategy _ _ = "Statements"
 
 data Strategy = Default | Custom
 

src/Analysis/IdentifierName.hs

@@ -1,60 +0,0 @@
-{-# LANGUAGE ScopedTypeVariables, TypeFamilies, TypeOperators, UndecidableInstances #-}
-module Analysis.IdentifierName
-( IdentifierName(..)
-, IdentifierLabel(..)
-, identifierLabel
-) where
-
-import           Data.Abstract.Name (unName)
-import           Data.Aeson
-import           Data.JSON.Fields
-import           Data.Sum
-import qualified Data.Syntax
-import           Data.Term
-import           Data.Text.Encoding (decodeUtf8)
-import           Prologue
-
--- | Compute a 'IdentifierLabel' label for a 'Term'.
-identifierLabel :: IdentifierName syntax => TermF syntax a b -> Maybe IdentifierLabel
-identifierLabel (In _ s) = IdentifierLabel <$> identifierName s
-
-newtype IdentifierLabel = IdentifierLabel ByteString
-  deriving (Show)
-
-instance ToJSONFields IdentifierLabel where
-  toJSONFields (IdentifierLabel s) = [ "name" .= decodeUtf8 s ]
-
-
--- | A typeclass to retrieve the name of syntax identifiers.
---
---   This typeclass employs the Advanced Overlap techniques designed by Oleg Kiselyov & Simon Peyton Jones: https://wiki.haskell.org/GHC/AdvancedOverlap; see also src/Analysis/Declaration.hs for discussion of the details of the mechanism.
-class IdentifierName syntax where
-  identifierName :: syntax a -> Maybe ByteString
-
-instance (IdentifierNameStrategy syntax ~ strategy, IdentifierNameWithStrategy strategy syntax) => IdentifierName syntax where
-  identifierName = identifierNameWithStrategy (Proxy :: Proxy strategy)
-
-class CustomIdentifierName syntax where
-  customIdentifierName :: syntax a -> Maybe ByteString
-
-instance Apply IdentifierName fs => CustomIdentifierName (Sum fs) where
-  customIdentifierName = apply @IdentifierName identifierName
-
-instance CustomIdentifierName Data.Syntax.Identifier where
-  customIdentifierName (Data.Syntax.Identifier name) = Just (unName name)
-
-data Strategy = Default | Custom
-
-type family IdentifierNameStrategy syntax where
-  IdentifierNameStrategy (Sum _) = 'Custom
-  IdentifierNameStrategy Data.Syntax.Identifier = 'Custom
-  IdentifierNameStrategy syntax = 'Default
-
-class IdentifierNameWithStrategy (strategy :: Strategy) syntax where
-  identifierNameWithStrategy :: proxy strategy -> syntax a -> Maybe ByteString
-
-instance IdentifierNameWithStrategy 'Default syntax where
-  identifierNameWithStrategy _ _ = Nothing
-
-instance (CustomIdentifierName syntax) => IdentifierNameWithStrategy 'Custom syntax where
-  identifierNameWithStrategy _ = customIdentifierName

src/Control/Abstract/Addressable.hs

@@ -10,42 +10,42 @@ import Data.Abstract.Address
 import Data.Abstract.Name
 import Prologue
 
--- | Defines allocation and dereferencing of 'Address'es in a 'Heap'.
-class (Ord location, Show location) => Addressable location effects where
-  -- | The type into which stored values will be written for a given location type.
-  type family Cell location :: * -> *
+-- | Defines allocation and dereferencing of addresses.
+class (Ord address, Show address) => Addressable address effects where
+  -- | The type into which stored values will be written for a given address type.
+  type family Cell address :: * -> *
 
-  allocCell :: Name -> Evaluator location value effects location
-  derefCell :: Address location value -> Cell location value -> Evaluator location value effects (Maybe value)
+  allocCell :: Name -> Evaluator address value effects address
+  derefCell :: address -> Cell address value -> Evaluator address value effects (Maybe value)
 
 
--- | 'Precise' locations are always allocated a fresh 'Address', and dereference to the 'Latest' value written.
+-- | 'Precise' addresses are always allocated a fresh address, and dereference to the 'Latest' value written.
 instance Member Fresh effects => Addressable Precise effects where
   type Cell Precise = Latest
 
   allocCell _ = Precise <$> fresh
   derefCell _ = pure . getLast . unLatest
 
--- | 'Monovariant' locations allocate one 'Address' per unique variable name, and dereference once per stored value, nondeterministically.
+-- | 'Monovariant' addresses allocate one address per unique variable name, and dereference once per stored value, nondeterministically.
 instance Member NonDet effects => Addressable Monovariant effects where
   type Cell Monovariant = All
 
   allocCell = pure . Monovariant
   derefCell _ = traverse (foldMapA pure) . nonEmpty . toList
 
--- | 'Located' locations allocate & dereference using the underlying location, contextualizing locations with the current 'PackageInfo' & 'ModuleInfo'.
-instance (Addressable location effects, Members '[Reader ModuleInfo, Reader PackageInfo] effects) => Addressable (Located location) effects where
-  type Cell (Located location) = Cell location
+-- | 'Located' addresses allocate & dereference using the underlying address, contextualizing addresses with the current 'PackageInfo' & 'ModuleInfo'.
+instance (Addressable address effects, Member (Reader ModuleInfo) effects, Member (Reader PackageInfo) effects) => Addressable (Located address) effects where
+  type Cell (Located address) = Cell address
 
   allocCell name = relocate (Located <$> allocCell name <*> currentPackage <*> currentModule)
-  derefCell (Address (Located loc _ _)) = relocate . derefCell (Address loc)
+  derefCell (Located loc _ _) = relocate . derefCell loc
 
-instance Addressable location effects => Addressable (Hole location) effects where
-  type Cell (Hole location) = Cell location
+instance Addressable address effects => Addressable (Hole address) effects where
+  type Cell (Hole address) = Cell address
 
   allocCell name = relocate (Total <$> allocCell name)
-  derefCell (Address (Total loc)) = relocate . derefCell (Address loc)
-  derefCell (Address Partial)     = const (pure Nothing)
+  derefCell (Total loc) = relocate . derefCell loc
+  derefCell Partial     = const (pure Nothing)
 
-relocate :: Evaluator location1 value effects a -> Evaluator location2 value effects a
+relocate :: Evaluator address1 value effects a -> Evaluator address2 value effects a
 relocate = raiseEff . lowerEff

src/Control/Abstract/Configuration.hs

@@ -12,5 +12,5 @@ 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), State (Heap location (Cell location) value)] effects => term -> TermEvaluator term location value effects (Configuration term location (Cell location) value)
+getConfiguration :: (Member (Reader (Live address)) effects, Member (State (Environment address)) effects, Member (State (Heap address (Cell address) value)) effects) => term -> TermEvaluator term address value effects (Configuration term address (Cell address) value)
 getConfiguration term = Configuration term <$> TermEvaluator askRoots <*> TermEvaluator getEnv <*> TermEvaluator getHeap

src/Control/Abstract/Context.hs

@@ -45,11 +45,11 @@ withCurrentSpan = local . const
 
 
 -- | Run an action with locally-replaced 'ModuleInfo' & 'Span' derived from the passed 'SrcLoc'.
-withCurrentSrcLoc :: (Effectful m, Members '[Reader ModuleInfo, Reader Span] effects) => SrcLoc -> m effects a -> m effects a
+withCurrentSrcLoc :: (Effectful m, Member (Reader ModuleInfo) effects, Member (Reader Span) effects) => SrcLoc -> m effects a -> m effects a
 withCurrentSrcLoc loc = withCurrentModule (moduleInfoFromSrcLoc loc) . withCurrentSpan (spanFromSrcLoc loc)
 
 -- | Run an action with locally replaced 'ModuleInfo' & 'Span' derived from the Haskell call stack.
 --
 --   This is suitable for contextualizing builtins & other functionality intended for use from client code but defined in Haskell source.
-withCurrentCallStack :: (Effectful m, Members '[Reader ModuleInfo, Reader Span] effects) => CallStack -> m effects a -> m effects a
+withCurrentCallStack :: (Effectful m, Member (Reader ModuleInfo) effects, Member (Reader Span) effects) => CallStack -> m effects a -> m effects a
 withCurrentCallStack = maybe id (withCurrentSrcLoc . snd) . listToMaybe . getCallStack

src/Control/Abstract/Environment.hs

@@ -3,14 +3,12 @@ module Control.Abstract.Environment
 ( Environment
 , getEnv
 , putEnv
-, modifyEnv
 , withEnv
-, defaultEnvironment
 , withDefaultEnvironment
-, fullEnvironment
-, localEnv
-, localize
 , lookupEnv
+, bind
+, bindAll
+, locally
 , EnvironmentError(..)
 , freeVariableError
 , runEnvironmentError
@@ -18,72 +16,70 @@ module Control.Abstract.Environment
 ) where
 
 import Control.Abstract.Evaluator
-import Data.Abstract.Address
 import Data.Abstract.Environment as Env
 import Data.Abstract.Name
 import Prologue
 
 -- | Retrieve the environment.
-getEnv :: Member (State (Environment location)) effects => Evaluator location value effects (Environment location)
+getEnv :: Member (State (Environment address)) effects => Evaluator address value effects (Environment address)
 getEnv = get
 
 -- | Set the environment.
-putEnv :: Member (State (Environment location)) effects => Environment location -> Evaluator location value effects ()
+putEnv :: Member (State (Environment address)) effects => Environment address -> Evaluator address value effects ()
 putEnv = put
 
 -- | Update the global environment.
-modifyEnv :: Member (State (Environment location)) effects => (Environment location -> Environment location) -> Evaluator location value effects ()
+modifyEnv :: Member (State (Environment address)) effects => (Environment address -> Environment address) -> Evaluator address value effects ()
 modifyEnv = modify'
 
 -- | Sets the environment for the lifetime of the given action.
-withEnv :: Member (State (Environment location)) effects => Environment location -> Evaluator location value effects a -> Evaluator location value effects a
+withEnv :: Member (State (Environment address)) effects => Environment address -> Evaluator address value effects a -> Evaluator address value effects a
 withEnv = localState . const
 
 
 -- | Retrieve the default environment.
-defaultEnvironment :: Member (Reader (Environment location)) effects => Evaluator location value effects (Environment location)
+defaultEnvironment :: Member (Reader (Environment address)) effects => Evaluator address value effects (Environment address)
 defaultEnvironment = ask
 
 -- | Set the default environment for the lifetime of an action.
 --   Usually only invoked in a top-level evaluation function.
-withDefaultEnvironment :: Member (Reader (Environment location)) effects => Environment location -> Evaluator location value effects a -> Evaluator location value effects a
+withDefaultEnvironment :: Member (Reader (Environment address)) effects => Environment address -> Evaluator address value effects a -> Evaluator address value effects a
 withDefaultEnvironment e = local (const e)
 
--- | Obtain an environment that is the composition of the current and default environments.
---   Useful for debugging.
-fullEnvironment :: Members '[Reader (Environment location), State (Environment location)] effects => Evaluator location value effects (Environment location)
-fullEnvironment = mergeEnvs <$> getEnv <*> defaultEnvironment
-
--- | Run an action with a locally-modified environment.
-localEnv :: Member (State (Environment location)) effects => (Environment location -> Environment location) -> Evaluator location value effects a -> Evaluator location value effects a
-localEnv f a = do
-  modifyEnv (f . Env.push)
-  result <- a
-  result <$ modifyEnv Env.pop
-
--- | Run a computation in a new local environment.
-localize :: Member (State (Environment location)) effects => Evaluator location value effects a -> Evaluator location value effects a
-localize = localEnv id
-
 -- | Look a 'Name' up in the current environment, trying the default environment if no value is found.
-lookupEnv :: Members '[Reader (Environment location), State (Environment location)] effects => Name -> Evaluator location value effects (Maybe (Address location value))
+lookupEnv :: (Member (Reader (Environment address)) effects, Member (State (Environment address)) effects) => Name -> Evaluator address value effects (Maybe address)
 lookupEnv name = (<|>) <$> (Env.lookup name <$> getEnv) <*> (Env.lookup name <$> defaultEnvironment)
 
+-- | Bind a 'Name' to an 'Address' in the current scope.
+bind :: Member (State (Environment address)) effects => Name -> address -> Evaluator address value effects ()
+bind name = modifyEnv . Env.insert name
+
+-- | Bind all of the names from an 'Environment' in the current scope.
+bindAll :: Member (State (Environment address)) effects => Environment address -> Evaluator address value effects ()
+bindAll = foldr ((>>) . uncurry bind) (pure ()) . pairs
+
+-- | Run an action in a new local environment.
+locally :: Member (State (Environment address)) effects => Evaluator address value effects a -> Evaluator address value effects a
+locally a = do
+  modifyEnv Env.push
+  a' <- a
+  a' <$ modifyEnv Env.pop
+
 
 -- | Errors involving the environment.
-data EnvironmentError location return where
-  FreeVariable :: Name -> EnvironmentError location location
+data EnvironmentError address return where
+  FreeVariable :: Name -> EnvironmentError address address
 
-deriving instance Eq (EnvironmentError location return)
-deriving instance Show (EnvironmentError location return)
-instance Show1 (EnvironmentError location) where liftShowsPrec _ _ = showsPrec
-instance Eq1 (EnvironmentError location) where liftEq _ (FreeVariable n1) (FreeVariable n2) = n1 == n2
+deriving instance Eq (EnvironmentError address return)
+deriving instance Show (EnvironmentError address return)
+instance Show1 (EnvironmentError address) where liftShowsPrec _ _ = showsPrec
+instance Eq1 (EnvironmentError address) where liftEq _ (FreeVariable n1) (FreeVariable n2) = n1 == n2
 
-freeVariableError :: Member (Resumable (EnvironmentError location)) effects => Name -> Evaluator location value effects location
+freeVariableError :: Member (Resumable (EnvironmentError address)) effects => Name -> Evaluator address value effects address
 freeVariableError = throwResumable . FreeVariable
 
-runEnvironmentError :: Effectful (m location value) => m location value (Resumable (EnvironmentError location) ': effects) a -> m location value effects (Either (SomeExc (EnvironmentError location)) a)
+runEnvironmentError :: Effectful (m address value) => m address value (Resumable (EnvironmentError address) ': effects) a -> m address value effects (Either (SomeExc (EnvironmentError address)) a)
 runEnvironmentError = runResumable
 
-runEnvironmentErrorWith :: Effectful (m location value) => (forall resume . EnvironmentError location resume -> m location value effects resume) -> m location value (Resumable (EnvironmentError location) ': effects) a -> m location value effects a
+runEnvironmentErrorWith :: Effectful (m address value) => (forall resume . EnvironmentError address resume -> m address value effects resume) -> m address value (Resumable (EnvironmentError address) ': effects) a -> m address value effects a
 runEnvironmentErrorWith = runResumableWith

src/Control/Abstract/Evaluator.hs

@@ -22,67 +22,64 @@ 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 Data.Abstract.Address
 import Prologue
 
--- | An 'Evaluator' is a thin wrapper around 'Eff' with (phantom) type parameters for the location, term, and value types.
+-- | An 'Evaluator' is a thin wrapper around 'Eff' with (phantom) type parameters for the address, term, and value types.
 --
 --   These parameters enable us to constrain the types of effects using them s.t. we can avoid both ambiguous types when they aren’t mentioned outside of the context, and lengthy, redundant annotations on the use sites of functions employing these effects.
 --
 --   These effects will typically include the environment, heap, module table, etc. effects necessary for evaluation of modules and terms, but may also include any other effects so long as they’re eventually handled.
-newtype Evaluator location value effects a = Evaluator { runEvaluator :: Eff effects a }
+newtype Evaluator address value effects a = Evaluator { runEvaluator :: Eff effects a }
   deriving (Applicative, Effectful, Functor, Monad)
 
-deriving instance Member NonDet effects => Alternative (Evaluator location value effects)
+deriving instance Member NonDet effects => Alternative (Evaluator address value effects)
 
 -- Effects
 
 -- | An effect for explicitly returning out of a function/method body.
-data Return location value resume where
-  Return :: Address location value -> Return location value (Address location value)
+data Return address value resume where
+  Return :: address -> Return address value address
 
-deriving instance (Eq location, Eq value) => Eq (Return location value a)
-deriving instance (Show location, Eq value) => Show (Return location value a)
+deriving instance (Eq address, Eq value) => Eq (Return address value a)
+deriving instance (Show address, Eq value) => Show (Return address value a)
 
-earlyReturn :: Member (Return location value) effects => Address location value -> Evaluator location value effects (Address location value)
-earlyReturn = send . Return
+earlyReturn :: forall address value effects
+            .  Member (Return address value) effects
+            => address
+            -> Evaluator address value effects address
+earlyReturn = send . Return @address @value
 
-catchReturn :: Member (Return location value) effects => Evaluator location value effects a -> (forall x . Return location value x -> Evaluator location value effects a) -> Evaluator location value effects a
+catchReturn :: Member (Return address value) effects => Evaluator address value effects a -> (forall x . Return address value x -> Evaluator address value effects a) -> Evaluator address value effects a
 catchReturn action handler = interpose pure (\ ret _ -> handler ret) action
 
-runReturn :: Effectful (m location value)
-          => m location value (Return location value ': effects) (Address location value)
-          -> m location value effects (Address location value)
+runReturn :: Effectful (m address value) => m address value (Return address value ': effects) (address) -> m address value effects (address)
 runReturn = raiseHandler (relay pure (\ (Return value) _ -> pure value))
 
 
 -- | Effects for control flow around loops (breaking and continuing).
-data LoopControl location value resume where
-  Break    :: Address location value -> LoopControl location value (Address location value)
-  Continue :: Address location value -> LoopControl location value (Address location value)
+data LoopControl address value resume where
+  Break    :: address -> LoopControl address value address
+  Continue :: address -> LoopControl address value address
 
-deriving instance (Eq location, Eq value) => Eq (LoopControl location value a)
-deriving instance (Show location, Show value) => Show (LoopControl location value a)
+deriving instance (Eq address, Eq value) => Eq (LoopControl address value a)
+deriving instance (Show address, Show value) => Show (LoopControl address value a)
 
-throwBreak :: Member (LoopControl location value) effects
-           => Address location value
-           -> Evaluator location value effects (Address location value)
-throwBreak = send . Break
+throwBreak :: forall address value effects
+           .  Member (LoopControl address value) effects
+           => address
+           -> Evaluator address value effects address
+throwBreak = send . Break @address @value
 
-throwContinue :: Member (LoopControl location value) effects
-              => Address location value
-              -> Evaluator location value effects (Address location value)
-throwContinue = send . Continue
+throwContinue :: forall address value effects
+              .  Member (LoopControl address value) effects
+              => address
+              -> Evaluator address value effects address
+throwContinue = send . Continue @address @value
 
-catchLoopControl :: Member (LoopControl location value) effects
-                 => Evaluator location value effects a
-                 -> (forall x . LoopControl location value x -> Evaluator location value effects a)
-                 -> Evaluator location value effects a
+catchLoopControl :: Member (LoopControl address value) effects => Evaluator address value effects a -> (forall x . LoopControl address value x -> Evaluator address value effects a) -> Evaluator address value effects a
 catchLoopControl action handler = interpose pure (\ control _ -> handler control) action
 
-runLoopControl :: Effectful (m location value)
-               => m location value (LoopControl location value ': effects) (Address location value)
-               -> m location value effects (Address location value)
+runLoopControl :: Effectful (m address value) => m address value (LoopControl address value ': effects) address -> m address value effects address
 runLoopControl = raiseHandler (relay pure (\ eff _ -> case eff of
   Break    value -> pure value
   Continue value -> pure value))

src/Control/Abstract/Exports.hs

@@ -8,26 +8,25 @@ module Control.Abstract.Exports
 ) where
 
 import Control.Abstract.Evaluator
-import Data.Abstract.Address
 import Data.Abstract.Exports
 import Data.Abstract.Name
 
 -- | Get the global export state.
-getExports :: Member (State (Exports location)) effects => Evaluator location value effects (Exports location)
+getExports :: Member (State (Exports address)) effects => Evaluator address value effects (Exports address)
 getExports = get
 
 -- | Set the global export state.
-putExports :: Member (State (Exports location)) effects => Exports location -> Evaluator location value effects ()
+putExports :: Member (State (Exports address)) effects => Exports address -> Evaluator address value effects ()
 putExports = put
 
 -- | Update the global export state.
-modifyExports :: Member (State (Exports location)) effects => (Exports location -> Exports location) -> Evaluator location value effects ()
+modifyExports :: Member (State (Exports address)) effects => (Exports address -> Exports address) -> Evaluator address value effects ()
 modifyExports = modify'
 
 -- | Add an export to the global export state.
-addExport :: Member (State (Exports location)) effects => Name -> Name -> Maybe (Address location value) -> Evaluator location value effects ()
+addExport :: Member (State (Exports address)) effects => Name -> Name -> Maybe address -> Evaluator address value effects ()
 addExport name alias = modifyExports . insert name alias
 
 -- | Sets the global export state for the lifetime of the given action.
-withExports :: Member (State (Exports location)) effects => Exports location -> Evaluator location value effects a -> Evaluator location value effects a
+withExports :: Member (State (Exports address)) effects => Exports address -> Evaluator address value effects a -> Evaluator address value effects a
 withExports = localState . const

src/Control/Abstract/Heap.hs

@@ -1,4 +1,4 @@
-{-# LANGUAGE GADTs, RankNTypes, TypeFamilies, TypeOperators, UndecidableInstances #-}
+{-# LANGUAGE GADTs, RankNTypes, ScopedTypeVariables, TypeFamilies, TypeOperators, UndecidableInstances #-}
 module Control.Abstract.Heap
 ( Heap
 , getHeap
@@ -24,140 +24,133 @@ import Control.Abstract.Addressable
 import Control.Abstract.Environment
 import Control.Abstract.Evaluator
 import Control.Monad.Effect.Internal
-import Data.Abstract.Address
-import Data.Abstract.Environment
 import Data.Abstract.Heap
 import Data.Abstract.Name
 import Data.Semigroup.Reducer
 import Prologue
 
 -- | Retrieve the heap.
-getHeap :: Member (State (Heap location (Cell location) value)) effects => Evaluator location value effects (Heap location (Cell location) value)
+getHeap :: Member (State (Heap address (Cell address) value)) effects => Evaluator address value effects (Heap address (Cell address) value)
 getHeap = get
 
 -- | Set the heap.
-putHeap :: Member (State (Heap location (Cell location) value)) effects => Heap location (Cell location) value -> Evaluator location value effects ()
+putHeap :: Member (State (Heap address (Cell address) value)) effects => Heap address (Cell address) value -> Evaluator address value effects ()
 putHeap = put
 
 -- | Update the heap.
-modifyHeap :: Member (State (Heap location (Cell location) value)) effects => (Heap location (Cell location) value -> Heap location (Cell location) value) -> Evaluator location value effects ()
+modifyHeap :: Member (State (Heap address (Cell address) value)) effects => (Heap address (Cell address) value -> Heap address (Cell address) value) -> Evaluator address value effects ()
 modifyHeap = modify'
 
-box :: ( Members '[ Allocator location value
-                  , State (Heap location (Cell location) value)
-                  ] effects
-       , Ord location
-       , Reducer value (Cell location value)
+box :: ( Member (Allocator address value) effects
+       , Member (State (Heap address (Cell address) value)) effects
+       , Ord address
+       , Reducer value (Cell address value)
        )
     => value
-    -> Evaluator location value effects (Address location value)
+    -> Evaluator address value effects address
 box val = do
   addr <- alloc "<box>"
   assign addr val
   pure addr
 
-alloc :: Member (Allocator location value) effects => Name -> Evaluator location value effects (Address location value)
-alloc = send . Alloc
+alloc :: forall address value effects . Member (Allocator address value) effects => Name -> Evaluator address value effects address
+alloc = send . Alloc @address @value
 
--- | Dereference the given 'Address'in the heap, or fail if the address is uninitialized.
-deref :: Member (Allocator location value) effects => Address location value -> Evaluator location value effects value
+-- | Dereference the given address in the heap, or fail if the address is uninitialized.
+deref :: Member (Allocator address value) effects => address -> Evaluator address value effects value
 deref = send . Deref
 
 
--- | Write a value to the given 'Address' in the 'Store'.
-assign :: ( Member (State (Heap location (Cell location) value)) effects
-          , Ord location
-          , Reducer value (Cell location value)
+-- | Write a value to the given address in the 'Store'.
+assign :: ( Member (State (Heap address (Cell address) value)) effects
+          , Ord address
+          , Reducer value (Cell address value)
           )
-       => Address location value
+       => address
        -> value
-       -> Evaluator location value effects ()
+       -> Evaluator address value effects ()
 assign address = modifyHeap . heapInsert address
 
 
 -- | Look up or allocate an address for a 'Name'.
-lookupOrAlloc :: Members '[ Allocator location value
-                          , Reader (Environment location)
-                          , State (Environment location)
-                          ] effects
+lookupOrAlloc :: ( Member (Allocator address value) effects
+                 , Member (Reader (Environment address)) effects
+                 , Member (State (Environment address)) effects
+                 )
               => Name
-              -> Evaluator location value effects (Address location value)
+              -> Evaluator address value effects address
 lookupOrAlloc name = lookupEnv name >>= maybe (alloc name) pure
 
 
-letrec :: ( Members '[ Allocator location value
-                     , Reader (Environment location)
-                     , State (Environment location)
-                     , State (Heap location (Cell location) value)
-                     ] effects
-          , Ord location
-          , Reducer value (Cell location value)
+letrec :: ( Member (Allocator address value) effects
+          , Member (Reader (Environment address)) effects
+          , Member (State (Environment address)) effects
+          , Member (State (Heap address (Cell address) value)) effects
+          , Ord address
+          , Reducer value (Cell address value)
           )
        => Name
-       -> Evaluator location value effects value
-       -> Evaluator location value effects (value, Address location value)
+       -> Evaluator address value effects value
+       -> Evaluator address value effects (value, address)
 letrec name body = do
   addr <- lookupOrAlloc name
-  v <- localEnv (insert name addr) body
+  v <- locally (bind name addr *> body)
   assign addr v
   pure (v, addr)
 
 -- Lookup/alloc a name passing the address to a body evaluated in a new local environment.
-letrec' :: Members '[ Allocator location value
-                    , Reader (Environment location)
-                    , State (Environment location)
-                    ] effects
+letrec' :: ( Member (Allocator address value) effects
+           , Member (Reader (Environment address)) effects
+           , Member (State (Environment address)) effects
+           )
         => Name
-        -> (Address location value -> Evaluator location value effects a)
-        -> Evaluator location value effects a
+        -> (address -> Evaluator address value effects a)
+        -> Evaluator address value effects a
 letrec' name body = do
   addr <- lookupOrAlloc name
-  v <- localEnv id (body addr)
-  v <$ modifyEnv (insert name addr)
+  v <- locally (body addr)
+  v <$ bind name addr
 
 
 -- | Look up and dereference the given 'Name', throwing an exception for free variables.
-variable :: Members '[ Allocator location value
-                     , Reader (Environment location)
-                     , Resumable (EnvironmentError location)
-                     , State (Environment location)
-                     , State (Heap location (Cell location) value)
-                     ] effects
+variable :: ( Member (Allocator address value) effects
+            , Member (Reader (Environment address)) effects
+            , Member (Resumable (EnvironmentError address)) effects
+            , Member (State (Environment address)) effects
+            )
          => Name
-         -> Evaluator location value effects value
-variable name = lookupEnv name >>= maybeM (Address <$> freeVariableError name) >>= deref
+         -> Evaluator address value effects value
+variable name = lookupEnv name >>= maybeM (freeVariableError name) >>= deref
 
 
 -- Effects
 
-data Allocator location value return where
-  Alloc :: Name                   -> Allocator location value (Address location value)
-  Deref :: Address location value -> Allocator location value value
+data Allocator address value return where
+  Alloc :: Name     -> Allocator address value address
+  Deref :: address -> Allocator address value value
 
-runAllocator :: (Addressable location effects, Effectful (m location value), Members '[Resumable (AddressError location value), State (Heap location (Cell location) value)] effects)
-             => m location value (Allocator location value ': effects) a
-             -> m location value effects a
+runAllocator :: (Addressable address effects, Effectful (m address value), Member (Resumable (AddressError address value)) effects, Member (State (Heap address (Cell address) value)) effects) => m address value (Allocator address value ': effects) a -> m address value effects a
 runAllocator = raiseHandler (interpret (\ eff -> case eff of
-  Alloc name -> lowerEff $ Address <$> allocCell name
+  Alloc name -> lowerEff $ allocCell name
   Deref addr -> lowerEff $ heapLookup addr <$> get >>= maybeM (throwResumable (UnallocatedAddress addr)) >>= derefCell addr >>= maybeM (throwResumable (UninitializedAddress addr))))
 
 
-data AddressError location value resume where
-  UnallocatedAddress   :: Address location value -> AddressError location value (Cell location value)
-  UninitializedAddress :: Address location value -> AddressError location value value
+data AddressError address value resume where
+  UnallocatedAddress   :: address -> AddressError address value (Cell address value)
+  UninitializedAddress :: address -> AddressError address value value
 
-deriving instance Eq location => Eq (AddressError location value resume)
-deriving instance Show location => Show (AddressError location value resume)
-instance Show location => Show1 (AddressError location value) where
+deriving instance Eq address => Eq (AddressError address value resume)
+deriving instance Show address => Show (AddressError address value resume)
+instance Show address => Show1 (AddressError address value) where
   liftShowsPrec _ _ = showsPrec
-instance Eq location => Eq1 (AddressError location value) where
+instance Eq address => Eq1 (AddressError address value) where
   liftEq _ (UninitializedAddress a) (UninitializedAddress b) = a == b
   liftEq _ (UnallocatedAddress a)   (UnallocatedAddress b)   = a == b
   liftEq _ _                        _                        = False
 
 
-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 :: Effectful (m address value) => m address value (Resumable (AddressError address value) ': effects) a -> m address value effects (Either (SomeExc (AddressError address value)) a)
 runAddressError = runResumable
 
-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 :: Effectful (m address value) => (forall resume . AddressError address value resume -> m address value effects resume) -> m address value (Resumable (AddressError address value) ': effects) a -> m address value effects a
 runAddressErrorWith = runResumableWith

src/Control/Abstract/Modules.hs

@@ -27,49 +27,49 @@ import Data.Language
 import Prologue
 
 -- | Retrieve an evaluated module, if any. The outer 'Maybe' indicates whether we’ve begun loading the module or not, while the inner 'Maybe' indicates whether we’ve completed loading it or not. Thus, @Nothing@ means we’ve never tried to load it, @Just Nothing@ means we’ve started but haven’t yet finished loading it, and @Just (Just (env, value))@ indicates the result of a completed load.
-lookupModule :: Member (Modules location value) effects => ModulePath -> Evaluator location value effects (Maybe (Maybe (Environment location, Address location value)))
-lookupModule = send . Lookup
+lookupModule :: forall address value effects . Member (Modules address value) effects => ModulePath -> Evaluator address value effects (Maybe (Maybe (Environment address, address)))
+lookupModule = send . Lookup @address @value
 
 -- | Resolve a list of module paths to a possible module table entry.
-resolve :: Member (Modules location value) effects => [FilePath] -> Evaluator location value effects (Maybe ModulePath)
-resolve = sendModules . Resolve
+resolve :: forall address value effects . Member (Modules address value) effects => [FilePath] -> Evaluator address value effects (Maybe ModulePath)
+resolve = sendModules . Resolve @address @value
 
-listModulesInDir :: Member (Modules location value) effects => FilePath -> Evaluator location value effects [ModulePath]
-listModulesInDir = sendModules . List
+listModulesInDir :: forall address value effects . Member (Modules address value) effects => FilePath -> Evaluator address value effects [ModulePath]
+listModulesInDir = sendModules . List @address @value
 
 
 -- | Require/import another module by name and return its environment and value.
 --
 -- Looks up the module's name in the cache of evaluated modules first, returns if found, otherwise loads/evaluates the module.
-require :: Member (Modules location value) effects => ModulePath -> Evaluator location value effects (Maybe (Environment location, Address location value))
+require :: Member (Modules address value) effects => ModulePath -> Evaluator address value effects (Maybe (Environment address, address))
 require path = lookupModule path >>= maybeM (load path)
 
 -- | Load another module by name and return its environment and value.
 --
 -- Always loads/evaluates.
-load :: Member (Modules location value) effects => ModulePath -> Evaluator location value effects (Maybe (Environment location, Address location value))
-load = send . Load
+load :: forall address value effects . Member (Modules address value) effects => ModulePath -> Evaluator address value effects (Maybe (Environment address, address))
+load = send . Load @address @value
 
 
-data Modules location value return where
-  Load    :: ModulePath -> Modules location value (Maybe (Environment location, Address location value))
-  Lookup  :: ModulePath -> Modules location value (Maybe (Maybe (Environment location, Address location value)))
-  Resolve :: [FilePath] -> Modules location value (Maybe ModulePath)
-  List    :: FilePath   -> Modules location value [ModulePath]
+data Modules address value return where
+  Load    :: ModulePath -> Modules address value (Maybe (Environment address, address))
+  Lookup  :: ModulePath -> Modules address value (Maybe (Maybe (Environment address, address)))
+  Resolve :: [FilePath] -> Modules address value (Maybe ModulePath)
+  List    :: FilePath   -> Modules address value [ModulePath]
 
-sendModules :: Member (Modules location value) effects => Modules location value return -> Evaluator location value effects return
+sendModules :: Member (Modules address value) effects => Modules address value return -> Evaluator address value effects return
 sendModules = send
 
-runModules :: forall term location value effects a
-           .  Members '[ Resumable (LoadError location value)
-                       , State (ModuleTable (Maybe (Environment location, Address location value)))
-                       , Trace
-                       ] effects
-           => (Module term -> Evaluator location value (Modules location value ': effects) (Environment location, Address location value))
-           -> Evaluator location value (Modules location value ': effects) a
-           -> Evaluator location value (Reader (ModuleTable [Module term]) ': effects) a
+runModules :: forall term address value effects a
+           .  ( Member (Resumable (LoadError address value)) effects
+              , Member (State (ModuleTable (Maybe (Environment address, address)))) effects
+              , Member Trace effects
+              )
+           => (Module term -> Evaluator address value (Modules address value ': effects) (Environment address, address))
+           -> Evaluator address value (Modules address value ': effects) a
+           -> Evaluator address value (Reader (ModuleTable [Module term]) ': effects) a
 runModules evaluateModule = go
-  where go :: forall a . Evaluator location value (Modules location value ': effects) a -> Evaluator location value (Reader (ModuleTable [Module term]) ': effects) a
+  where go :: forall a . Evaluator address value (Modules address value ': effects) a -> Evaluator address value (Reader (ModuleTable [Module term]) ': effects) a
         go = reinterpret (\ m -> case m of
           Load name -> askModuleTable @term >>= maybe (moduleNotFound name) (runMerging . foldMap (Merging . evalAndCache)) . ModuleTable.lookup name
             where
@@ -90,49 +90,49 @@ runModules evaluateModule = go
             pure (find isMember names)
           List dir -> modulePathsInDir dir <$> askModuleTable @term)
 
-getModuleTable :: Member (State (ModuleTable (Maybe (Environment location, Address location value)))) effects => Evaluator location value effects (ModuleTable (Maybe (Environment location, Address location value)))
+getModuleTable :: Member (State (ModuleTable (Maybe (Environment address, address)))) effects => Evaluator address value effects (ModuleTable (Maybe (Environment address, address)))
 getModuleTable = get
 
-cacheModule :: Member (State (ModuleTable (Maybe (Environment location, Address location value)))) effects => ModulePath -> Maybe (Environment location, Address location value) -> Evaluator location value effects (Maybe (Environment location, Address location value))
+cacheModule :: Member (State (ModuleTable (Maybe (Environment address, address)))) effects => ModulePath -> Maybe (Environment address, address) -> Evaluator address value effects (Maybe (Environment address, address))
 cacheModule path result = modify' (ModuleTable.insert path result) $> result
 
-askModuleTable :: Member (Reader (ModuleTable [Module term])) effects => Evaluator location value effects (ModuleTable [Module term])
+askModuleTable :: Member (Reader (ModuleTable [Module term])) effects => Evaluator address value effects (ModuleTable [Module term])
 askModuleTable = ask
 
 
-newtype Merging m location value = Merging { runMerging :: m (Maybe (Environment location, Address location value)) }
+newtype Merging m address value = Merging { runMerging :: m (Maybe (Environment address, address)) }
 
-instance Applicative m => Semigroup (Merging m location value) where
+instance Applicative m => Semigroup (Merging m address value) where
   Merging a <> Merging b = Merging (merge <$> a <*> b)
     where merge a b = mergeJusts <$> a <*> b <|> a <|> b
           mergeJusts (env1, _) (env2, v) = (mergeEnvs env1 env2, v)
 
-instance Applicative m => Monoid (Merging m location value) where
+instance Applicative m => Monoid (Merging m address value) where
   mappend = (<>)
   mempty = Merging (pure Nothing)
 
 
 -- | An error thrown when loading a module from the list of provided modules. Indicates we weren't able to find a module with the given name.
-data LoadError location value resume where
-  ModuleNotFound :: ModulePath -> LoadError location value (Maybe (Environment location, Address location value))
+data LoadError address value resume where
+  ModuleNotFound :: ModulePath -> LoadError address value (Maybe (Environment address, address))
 
-deriving instance Eq (LoadError location value resume)
-deriving instance Show (LoadError location value resume)
-instance Show1 (LoadError location value) where
+deriving instance Eq (LoadError address value resume)
+deriving instance Show (LoadError address value resume)
+instance Show1 (LoadError address value) where
   liftShowsPrec _ _ = showsPrec
-instance Eq1 (LoadError location value) where
+instance Eq1 (LoadError address value) where
   liftEq _ (ModuleNotFound a) (ModuleNotFound b) = a == b
 
-moduleNotFound :: Member (Resumable (LoadError location value)) effects => ModulePath -> Evaluator location value effects (Maybe (Environment location, Address location value))
-moduleNotFound = throwResumable . ModuleNotFound
+moduleNotFound :: forall address value effects . Member (Resumable (LoadError address value)) effects => ModulePath -> Evaluator address value effects (Maybe (Environment address, address))
+moduleNotFound = throwResumable . ModuleNotFound @address @value
 
-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 :: Member (Resumable (LoadError address value)) effects => Evaluator address value effects a -> (forall resume . LoadError address value resume -> Evaluator address value effects resume) -> Evaluator address value effects a
 resumeLoadError = catchResumable
 
-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 :: Effectful (m address value) => m address value (Resumable (LoadError address value) ': effects) a -> m address value effects (Either (SomeExc (LoadError address value)) a)
 runLoadError = runResumable
 
-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 :: Effectful (m address value) => (forall resume . LoadError address value resume -> m address value effects resume) -> m address value (Resumable (LoadError address value) ': effects) a -> m address value effects a
 runLoadErrorWith = runResumableWith
 
 

src/Control/Abstract/Primitive.hs

@@ -7,7 +7,6 @@ import Control.Abstract.Evaluator
 import Control.Abstract.Heap
 import Control.Abstract.Value
 import Data.Abstract.Address
-import Data.Abstract.Environment
 import Data.Abstract.Name
 import Data.ByteString.Char8 (pack, unpack)
 import Data.Semigroup.Reducer hiding (unit)
@@ -15,47 +14,44 @@ import Data.Semilattice.Lower
 import Prologue
 
 builtin :: ( HasCallStack
-           , Members '[ Allocator location value
-                      , Reader (Environment location)
-                      , Reader ModuleInfo
-                      , Reader Span
-                      , State (Environment location)
-                      , State (Heap location (Cell location) value)
-                      ] effects
-           , Ord location
-           , Reducer value (Cell location value)
+           , Member (Allocator address value) effects
+           , Member (Reader ModuleInfo) effects
+           , Member (Reader Span) effects
+           , Member (State (Environment address)) effects
+           , Member (State (Heap address (Cell address) value)) effects
+           , Ord address
+           , Reducer value (Cell address value)
            )
         => String
-        -> Evaluator location value effects value
-        -> Evaluator location value effects ()
+        -> Evaluator address value effects value
+        -> Evaluator address value effects ()
 builtin s def = withCurrentCallStack callStack $ do
   let name' = name (pack ("__semantic_" <> s))
   addr <- alloc name'
-  modifyEnv (insert name' addr)
+  bind name' addr
   def >>= assign addr
 
-lambda :: (AbstractFunction location value effects, Member Fresh effects)
-       => (Name -> Evaluator location value effects (Address location value))
-       -> Evaluator location value effects (Address location value)
+lambda :: (AbstractFunction address value effects, Member Fresh effects)
+       => (Name -> Evaluator address value effects address)
+       -> Evaluator address value effects value
 lambda body = do
   var <- nameI <$> fresh
   closure [var] lowerBound (body var)
 
-defineBuiltins :: ( AbstractValue location value effects
+defineBuiltins :: ( AbstractValue address value effects
                   , HasCallStack
-                  , Members '[ Allocator location value
-                             , Fresh
-                             , Reader (Environment location)
-                             , Reader ModuleInfo
-                             , Reader Span
-                             , Resumable (EnvironmentError location)
-                             , State (Environment location)
-                             , State (Heap location (Cell location) value)
-                             , Trace
-                             ] effects
-                  , Ord location
-                  , Reducer value (Cell location value)
+                  , Member (Allocator address value) effects
+                  , Member Fresh effects
+                  , Member (Reader (Environment address)) effects
+                  , Member (Reader ModuleInfo) effects
+                  , Member (Reader Span) effects
+                  , Member (Resumable (EnvironmentError address)) effects
+                  , Member (State (Environment address)) effects
+                  , Member (State (Heap address (Cell address) value)) effects
+                  , Member Trace effects
+                  , Ord address
+                  , Reducer value (Cell address value)
                   )
-               => Evaluator location value effects ()
+               => Evaluator address value effects ()
 defineBuiltins =
-  builtin "print" (lambda (\ v -> variable v >>= asString >>= trace . unpack >> box unit) >>= deref)
+  builtin "print" (lambda (\ v -> variable v >>= asString >>= trace . unpack >> box unit))

src/Control/Abstract/Roots.hs

@@ -9,9 +9,9 @@ import Data.Abstract.Live
 import Prologue
 
 -- | Retrieve the local 'Live' set.
-askRoots :: Member (Reader (Live location value)) effects => Evaluator location value effects (Live location value)
+askRoots :: Member (Reader (Live address)) effects => Evaluator address value effects (Live address)
 askRoots = ask
 
 -- | Run a computation with the given 'Live' set added to the local root set.
-extraRoots :: (Member (Reader (Live location value)) effects, Ord location) => Live location value -> Evaluator location value effects a -> Evaluator location value effects a
+extraRoots :: (Member (Reader (Live address)) effects, Ord address) => Live address -> Evaluator address value effects a -> Evaluator address value effects a
 extraRoots roots = local (<> roots)

src/Control/Abstract/TermEvaluator.hs

@@ -19,11 +19,11 @@ 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 }
+newtype TermEvaluator term address value effects a = TermEvaluator { runTermEvaluator :: Evaluator address value effects a }
   deriving (Applicative, Effectful, Functor, Monad)
 
-deriving instance Member NonDet effects => Alternative (TermEvaluator term location value effects)
+deriving instance Member NonDet effects => Alternative (TermEvaluator term address 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 :: (Evaluator address value effects a -> Evaluator address value effects' a') -> (TermEvaluator term address value effects a -> TermEvaluator term address value effects' a')
 raiseHandler f = TermEvaluator . f . runTermEvaluator

src/Control/Abstract/Value.hs

@@ -22,7 +22,6 @@ import Control.Abstract.Addressable
 import Control.Abstract.Environment
 import Control.Abstract.Evaluator
 import Control.Abstract.Heap
-import Data.Abstract.Address (Address)
 import Data.Abstract.Environment as Env
 import Data.Abstract.Live (Live)
 import Data.Abstract.Name
@@ -44,16 +43,14 @@ data Comparator
   = Concrete (forall a . Ord a => a -> a -> Bool)
   | Generalized
 
-class Show value => AbstractFunction location value effects where
+class Show value => AbstractFunction address value effects where
   -- | Build a closure (a binder like a lambda or method definition).
-  closure :: [Name]                                                    -- ^ The parameter names.
-          -> Set Name                                                  -- ^ The set of free variables to close over.
-          -> Evaluator location value effects (Address location value) -- ^ The evaluator for the body of the closure.
-          -> Evaluator location value effects (Address location value)
+  closure :: [Name]                                 -- ^ The parameter names.
+          -> Set Name                               -- ^ The set of free variables to close over.
+          -> Evaluator address value effects (address) -- ^ The evaluator for the body of the closure.
+          -> Evaluator address value effects value
   -- | Evaluate an application (like a function call).
-  call :: value
-       -> [Evaluator location value effects (Address location value)]
-       -> Evaluator location value effects (Address location value)
+  call :: value -> [Evaluator address value effects (address)] -> Evaluator address value effects (address)
 
 
 class Show value => AbstractIntro value where
@@ -96,112 +93,112 @@ class Show value => AbstractIntro value where
 -- | A 'Monad' abstracting the evaluation of (and under) binding constructs (functions, methods, etc).
 --
 --   This allows us to abstract the choice of whether to evaluate under binders for different value types.
-class (AbstractFunction location value effects, AbstractIntro value) => AbstractValue location value effects where
+class (AbstractFunction address value effects, AbstractIntro value) => AbstractValue address value effects where
   -- | Lift a unary operator over a 'Num' to a function on 'value's.
   liftNumeric  :: (forall a . Num a => a -> a)
-               -> (value -> Evaluator location value effects value)
+               -> (value -> Evaluator address value effects value)
 
   -- | Lift a pair of binary operators to a function on 'value's.
   --   You usually pass the same operator as both arguments, except in the cases where
   --   Haskell provides different functions for integral and fractional operations, such
   --   as division, exponentiation, and modulus.
   liftNumeric2 :: (forall a b. Number a -> Number b -> SomeNumber)
-               -> (value -> value -> Evaluator location value effects value)
+               -> (value -> value -> Evaluator address value effects value)
 
   -- | Lift a Comparator (usually wrapping a function like == or <=) to a function on values.
-  liftComparison :: Comparator -> (value -> value -> Evaluator location value effects value)
+  liftComparison :: Comparator -> (value -> value -> Evaluator address value effects value)
 
   -- | Lift a unary bitwise operator to values. This is usually 'complement'.
   liftBitwise :: (forall a . Bits a => a -> a)
-              -> (value -> Evaluator location value effects value)
+              -> (value -> Evaluator address value effects value)
 
   -- | Lift a binary bitwise operator to values. The Integral constraint is
   --   necessary to satisfy implementation details of Haskell left/right shift,
   --   but it's fine, since these are only ever operating on integral values.
   liftBitwise2 :: (forall a . (Integral a, Bits a) => a -> a -> a)
-               -> (value -> value -> Evaluator location value effects value)
+               -> (value -> value -> Evaluator address value effects value)
 
   -- | Construct an array of zero or more values.
-  array :: [value] -> Evaluator location value effects value
+  array :: [value] -> Evaluator address value effects value
 
   -- | Extract the contents of a key-value pair as a tuple.
-  asPair :: value -> Evaluator location value effects (value, value)
+  asPair :: value -> Evaluator address value effects (value, value)
 
   -- | Extract a 'ByteString' from a given value.
-  asString :: value -> Evaluator location value effects ByteString
+  asString :: value -> Evaluator address value effects ByteString
 
   -- | Eliminate boolean values. TODO: s/boolean/truthy
-  ifthenelse :: value -> Evaluator location value effects a -> Evaluator location value effects a -> Evaluator location value effects a
+  ifthenelse :: value -> Evaluator address value effects a -> Evaluator address value effects a -> Evaluator address value effects a
 
   -- | @index x i@ computes @x[i]@, with zero-indexing.
-  index :: value -> value -> Evaluator location value effects value
+  index :: value -> value -> Evaluator address value effects value
 
   -- | Build a class value from a name and environment.
   klass :: Name                 -- ^ The new class's identifier
         -> [value]              -- ^ A list of superclasses
-        -> Environment location -- ^ The environment to capture
-        -> Evaluator location value effects value
+        -> Environment address -- ^ The environment to capture
+        -> Evaluator address value effects value
 
   -- | Build a namespace value from a name and environment stack
   --
   -- Namespaces model closures with monoidal environments.
   namespace :: Name                 -- ^ The namespace's identifier
-            -> Environment location -- ^ The environment to mappend
-            -> Evaluator location value effects value
+            -> Environment address -- ^ The environment to mappend
+            -> Evaluator address value effects value
 
   -- | Extract the environment from any scoped object (e.g. classes, namespaces, etc).
-  scopedEnvironment :: value -> Evaluator location value effects (Maybe (Environment location))
+  scopedEnvironment :: value -> Evaluator address value effects (Maybe (Environment address))
 
   -- | Primitive looping combinator, approximately equivalent to 'fix'. This should be used in place of direct recursion, as it allows abstraction over recursion.
   --
   --   The function argument takes an action which recurs through the loop.
-  loop :: (Evaluator location value effects value -> Evaluator location value effects value) -> Evaluator location value effects value
+  loop :: (Evaluator address value effects value -> Evaluator address value effects value) -> Evaluator address value effects value
 
 
 -- | Extract a 'Bool' from a given value.
-asBool :: AbstractValue location value effects => value -> Evaluator location value effects Bool
+asBool :: AbstractValue address value effects => value -> Evaluator address value effects Bool
 asBool value = ifthenelse value (pure True) (pure False)
 
 -- | C-style for loops.
-forLoop :: ( AbstractValue location value effects
-           , Member (State (Environment location)) effects
+forLoop :: ( AbstractValue address value effects
+           , Member (State (Environment address)) effects
            )
-        => Evaluator location value effects value -- ^ Initial statement
-        -> Evaluator location value effects value -- ^ Condition
-        -> Evaluator location value effects value -- ^ Increment/stepper
-        -> Evaluator location value effects value -- ^ Body
-        -> Evaluator location value effects value
+        => Evaluator address value effects value -- ^ Initial statement
+        -> Evaluator address value effects value -- ^ Condition
+        -> Evaluator address value effects value -- ^ Increment/stepper
+        -> Evaluator address value effects value -- ^ Body
+        -> Evaluator address value effects value
 forLoop initial cond step body =
-  localize (initial *> while cond (body *> step))
+  locally (initial *> while cond (body *> step))
 
 -- | The fundamental looping primitive, built on top of 'ifthenelse'.
-while :: AbstractValue location value effects
-      => Evaluator location value effects value
-      -> Evaluator location value effects value
-      -> Evaluator location value effects value
+while :: AbstractValue address value effects
+      => Evaluator address value effects value
+      -> Evaluator address value effects value
+      -> Evaluator address value effects value
 while cond body = loop $ \ continue -> do
   this <- cond
   ifthenelse this (body *> continue) (pure unit)
 
 -- | Do-while loop, built on top of while.
-doWhile :: AbstractValue location value effects
-        => Evaluator location value effects value
-        -> Evaluator location value effects value
-        -> Evaluator location value effects value
+doWhile :: AbstractValue address value effects
+        => Evaluator address value effects value
+        -> Evaluator address value effects value
+        -> Evaluator address value effects value
 doWhile body cond = loop $ \ continue -> body *> do
   this <- cond
   ifthenelse this continue (pure unit)
 
-makeNamespace :: ( AbstractValue location value effects
-                 , Member (State (Environment location)) effects
-                 , Member (State (Heap location (Cell location) value)) effects
-                 , Ord location
-                 , Reducer value (Cell location value)
+makeNamespace :: ( AbstractValue address value effects
+                 , Member (State (Environment address)) effects
+                 , Member (State (Heap address (Cell address) value)) effects
+                 , Ord address
+                 , Reducer value (Cell address value)
                  )
               => Name
-              -> Address location value
+              -> address
               -> Maybe value
-              -> Evaluator location value effects value
+              -> Evaluator address value effects value
 makeNamespace name addr super = do
   superEnv <- maybe (pure (Just lowerBound)) scopedEnvironment super
   let env' = fromMaybe lowerBound superEnv
@@ -211,69 +208,69 @@ makeNamespace name addr super = do
 
 
 -- | Evaluate a term within the context of the scoped environment of 'scopedEnvTerm'.
-evaluateInScopedEnv :: ( AbstractValue location value effects
-                       , Member (State (Environment location)) effects
+evaluateInScopedEnv :: ( AbstractValue address value effects
+                       , Member (State (Environment address)) effects
                        )
-                    => Evaluator location value effects value
-                    -> Evaluator location value effects a
-                    -> Evaluator location value effects a
+                    => Evaluator address value effects value
+                    -> Evaluator address value effects a
+                    -> Evaluator address value effects a
 evaluateInScopedEnv scopedEnvTerm term = do
   scopedEnv <- scopedEnvTerm >>= scopedEnvironment
-  maybe term (flip localEnv term . mergeEnvs) scopedEnv
+  maybe term (\ env -> locally (bindAll env *> term)) scopedEnv
 
 
 -- | Evaluates a 'Value' returning the referenced value
-value :: ( AbstractValue location value effects
-         , Member (Allocator location value) effects
-         , Member (Reader (Environment location)) effects
-         , Member (State (Environment location)) effects
+value :: ( AbstractValue address value effects
+         , Member (Allocator address value) effects
+         , Member (Reader (Environment address)) effects
+         , Member (State (Environment address)) effects
          )
-      => ValueRef location value
-      -> Evaluator location value effects value
+      => ValueRef address value
+      -> Evaluator address value effects value
 value = deref <=< address
 
 -- | Evaluates a 'Subterm' to its rval
-subtermValue :: ( AbstractValue location value effects
-                , Member (Allocator location value) effects
-                , Member (Reader (Environment location)) effects
-                , Member (State (Environment location)) effects
+subtermValue :: ( AbstractValue address value effects
+                , Member (Allocator address value) effects
+                , Member (Reader (Environment address)) effects
+                , Member (Resumable (EnvironmentError address)) effects
+                , Member (State (Environment address)) effects
                 )
-             => Subterm term (Evaluator location value effects (ValueRef location value))
-             -> Evaluator location value effects value
+             => Subterm term (Evaluator address value effects (ValueRef address value))
+             -> Evaluator address value effects value
 subtermValue = value <=< subtermRef
 
-address :: ( AbstractValue location value effects
-           , Member (Allocator location value) effects
-           , Member (Reader (Environment location)) effects
-           , Member (State (Environment location)) effects
+address :: ( AbstractValue address value effects
+           , Member (Allocator address value) effects
+           , Member (Reader (Environment address)) effects
+           , Member (State (Environment address)) effects
            )
-        => ValueRef location value
-        -> Evaluator location value effects (Address location value)
+        => ValueRef address value
+        -> Evaluator address value effects address
 address (LvalLocal var) = fromJust <$> lookupEnv var
 address (LvalMember obj prop) = evaluateInScopedEnv (deref obj) (fromJust <$> lookupEnv prop)
 address (Rval addr) = pure addr
 
-subtermAddress :: ( AbstractValue location value effects
-                  , Member (Allocator location value) effects
-                  , Member (Reader (Environment location)) effects
-                  , Member (State (Environment location)) effects
+subtermAddress :: ( AbstractValue address value effects
+                  , Member (Allocator address value) effects
+                  , Member (Reader (Environment address)) effects
+                  , Member (State (Environment address)) effects
                   )
-               => Subterm term (Evaluator location value effects (ValueRef location value))
-               -> Evaluator location value effects (Address location value)
+               => Subterm term (Evaluator address value effects (ValueRef address value))
+               -> Evaluator address value effects address
 subtermAddress = address <=< subtermRef
 
-rvalBox :: ( Members '[ Allocator location value
-                      , State (Heap location (Cell location) value)
-                      ] effects
-           , Ord location
-           , Reducer value (Cell location value)
+rvalBox :: ( Member (Allocator address value) effects
+           , Member (State (Heap address (Cell address) value)) effects
+           , Ord address
+           , Reducer value (Cell address value)
            )
         => value
-        -> Evaluator location value effects (ValueRef location value)
+        -> Evaluator address value effects (ValueRef address value)
 rvalBox val = Rval <$> (box val)
 
 
 -- | Value types, e.g. closures, which can root a set of addresses.
-class ValueRoots location value where
+class ValueRoots address value where
   -- | Compute the set of addresses rooted by a given value.
-  valueRoots :: value -> Live location value
+  valueRoots :: value -> Live address

src/Data/Abstract/Address.hs

@@ -10,18 +10,6 @@ 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 { 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
-
-
 -- | '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 { unPrecise :: Int }
   deriving (Eq, Ord)
@@ -38,10 +26,10 @@ instance Show Monovariant where
   showsPrec d = showsUnaryWith showsPrec "Monovariant" d . unMonovariant
 
 
-data Located location = Located
-  { location        :: location
-  , locationPackage :: {-# UNPACK #-} !PackageInfo
-  , locationModule  :: !ModuleInfo
+data Located address = Located
+  { address        :: address
+  , addressPackage :: {-# UNPACK #-} !PackageInfo
+  , addressModule  :: !ModuleInfo
   }
   deriving (Eq, Ord, Show)
 

src/Data/Abstract/Cache.hs

@@ -9,30 +9,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 (Cached location cell value)) }
-  deriving (Eq, Lower, Monoid, Ord, Reducer (Configuration term location cell value, Cached location cell value), Semigroup)
+newtype Cache term address cell value = Cache { unCache :: Monoidal.Map (Configuration term address cell value) (Set (Cached address cell value)) }
+  deriving (Eq, Lower, Monoid, Ord, Reducer (Configuration term address cell value, Cached address cell value), Semigroup)
 
-data Cached location cell value = Cached
-  { cachedValue :: ValueRef location value
-  , cachedHeap  :: Heap location cell value
+data Cached address cell value = Cached
+  { cachedValue :: ValueRef address value
+  , cachedHeap  :: Heap address cell value
   }
   deriving (Eq, Ord, Show)
 
 
-type Cacheable term location cell value = (Ord (cell value), Ord location, Ord term, Ord value)
+type Cacheable term address cell value = (Ord (cell value), Ord address, 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 (Cached location cell value))
+cacheLookup :: Cacheable term address cell value => Configuration term address cell value -> Cache term address cell value -> Maybe (Set (Cached address 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 (Cached location cell value) -> Cache term location cell value -> Cache term location cell value
+cacheSet :: Cacheable term address cell value => Configuration term address cell value -> Set (Cached address cell value) -> Cache term address cell value -> Cache term address 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 -> Cached location cell value -> Cache term location cell value -> Cache term location cell value
+cacheInsert :: Cacheable term address cell value => Configuration term address cell value -> Cached address cell value -> Cache term address cell value -> Cache term address cell value
 cacheInsert = curry cons
 
 
-instance (Show term, Show location, Show (cell value), Show value) => Show (Cache term location cell value) where
+instance (Show term, Show address, Show (cell value), Show value) => Show (Cache term address cell value) where
   showsPrec d = showsUnaryWith showsPrec "Cache" d . map (second toList) . Monoidal.pairs . unCache

src/Data/Abstract/Configuration.hs

@@ -5,10 +5,10 @@ import Data.Abstract.Heap
 import Data.Abstract.Live
 
 -- | A single point in a program’s execution.
-data Configuration term location cell value = Configuration
-  { configurationTerm        :: term                     -- ^ The “instruction,” i.e. the current term to evaluate.
-  , configurationRoots       :: Live location value      -- ^ The set of rooted addresses.
-  , configurationEnvironment :: Environment location     -- ^ The environment binding any free variables in 'configurationTerm'.
-  , configurationHeap        :: Heap location cell value -- ^ The heap of values.
+data Configuration term address cell value = Configuration
+  { configurationTerm        :: term                    -- ^ The “instruction,” i.e. the current term to evaluate.
+  , configurationRoots       :: Live address            -- ^ The set of rooted addresses.
+  , configurationEnvironment :: Environment address     -- ^ The environment binding any free variables in 'configurationTerm'.
+  , configurationHeap        :: Heap address cell value -- ^ The heap of values.
   }
   deriving (Eq, Ord, Show)

src/Data/Abstract/Environment.hs

@@ -1,7 +1,7 @@
 module Data.Abstract.Environment
   ( Environment(..)
   , addresses
-  , bind
+  , intersect
   , delete
   , head
   , emptyEnv
@@ -18,7 +18,6 @@ module Data.Abstract.Environment
   , roots
   ) where
 
-import           Data.Abstract.Address
 import           Data.Abstract.Live
 import           Data.Abstract.Name
 import           Data.Align
@@ -29,38 +28,39 @@ import           Prelude hiding (head, lookup)
 import           Prologue
 
 -- $setup
--- >>> let bright = push (insert (name "foo") (Address (Precise 0)) emptyEnv)
--- >>> let shadowed = insert (name "foo") (Address (Precise 1)) bright
+-- >>> import Data.Abstract.Address
+-- >>> let bright = push (insert (name "foo") (Precise 0) emptyEnv)
+-- >>> let shadowed = insert (name "foo") (Precise 1) bright
 
 -- | 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 = Environment { unEnvironment :: NonEmpty (Map.Map Name location) }
+newtype Environment address = Environment { unEnvironment :: NonEmpty (Map.Map Name address) }
   deriving (Eq, Ord)
 
-mergeEnvs :: Environment location -> Environment location -> Environment location
+mergeEnvs :: Environment address -> Environment address -> Environment address
 mergeEnvs (Environment (a :| as)) (Environment (b :| bs)) =
   Environment ((<>) a b :| alignWith (mergeThese (<>)) as bs)
 
-emptyEnv :: Environment location
+emptyEnv :: Environment address
 emptyEnv = Environment (lowerBound :| [])
 
 -- | Make and enter a new empty scope in the given environment.
-push :: Environment location -> Environment location
+push :: Environment address -> Environment address
 push (Environment (a :| as)) = Environment (mempty :| a : as)
 
 -- | Remove the frontmost scope.
-pop :: Environment location -> Environment location
+pop :: Environment address -> Environment address
 pop (Environment (_ :| []))     = emptyEnv
 pop (Environment (_ :| a : as)) = Environment (a :| as)
 
 -- | Drop all scopes save for the frontmost one.
-head :: Environment location -> Environment location
+head :: Environment address -> Environment address
 head (Environment (a :| _)) = Environment (a :| [])
 
 -- | Take the union of two environments. When duplicate keys are found in the
 --   name to address map, the second definition wins.
-mergeNewer :: Environment location -> Environment location -> Environment location
+mergeNewer :: Environment address -> Environment address -> Environment address
 mergeNewer (Environment a) (Environment b) =
     Environment (NonEmpty.fromList . reverse $ alignWith (mergeThese combine) (reverse as) (reverse bs))
     where
@@ -72,45 +72,45 @@ mergeNewer (Environment a) (Environment b) =
 --
 -- >>> pairs shadowed
 -- [("foo",Precise 1)]
-pairs :: Environment location -> [(Name, Address location value)]
-pairs = map (second Address) . Map.toList . fold . unEnvironment
+pairs :: Environment address -> [(Name, address)]
+pairs = Map.toList . fold . unEnvironment
 
-unpairs :: [(Name, Address location value)] -> Environment location
-unpairs = Environment . pure . Map.fromList . map (second unAddress)
+unpairs :: [(Name, address)] -> Environment address
+unpairs = Environment . pure . Map.fromList
 
 -- | Lookup a 'Name' in the environment.
 --
 -- >>> lookup (name "foo") shadowed
 -- Just (Precise 1)
-lookup :: Name -> Environment location -> Maybe (Address location value)
-lookup k = fmap Address . foldMapA (Map.lookup k) . unEnvironment
+lookup :: Name -> Environment address -> Maybe address
+lookup name = foldMapA (Map.lookup name) . unEnvironment
 
 -- | Insert a 'Name' in the environment.
-insert :: Name -> Address location value -> Environment location -> Environment location
-insert name (Address value) (Environment (a :| as)) = Environment (Map.insert name value a :| as)
+insert :: Name -> address -> Environment address -> Environment address
+insert name addr (Environment (a :| as)) = Environment (Map.insert name addr a :| as)
 
 -- | Remove a 'Name' from the environment.
 --
 -- >>> delete (name "foo") shadowed
 -- Environment []
-delete :: Name -> Environment location -> Environment location
+delete :: Name -> Environment address -> Environment address
 delete name = trim . Environment . fmap (Map.delete name) . unEnvironment
 
-trim :: Environment location -> Environment location
+trim :: Environment address -> Environment address
 trim (Environment (a :| as)) = Environment (a :| filtered)
   where filtered = filter (not . Map.null) as
 
-bind :: Foldable t => t Name -> Environment location -> Environment location
-bind names env = unpairs (mapMaybe lookupName (toList names))
+intersect :: Foldable t => t Name -> Environment address -> Environment address
+intersect names env = unpairs (mapMaybe lookupName (toList names))
   where
     lookupName name = (,) name <$> lookup name env
 
 -- | Get all bound 'Name's in an environment.
-names :: Environment location -> [Name]
+names :: Environment address -> [Name]
 names = fmap fst . pairs
 
 -- | Lookup and alias name-value bindings from an environment.
-overwrite :: [(Name, Name)] -> Environment location -> Environment location
+overwrite :: [(Name, Name)] -> Environment address -> Environment address
 overwrite pairs env = unpairs $ mapMaybe lookupAndAlias pairs
   where
     lookupAndAlias (oldName, newName) = (,) newName <$> lookup oldName env
@@ -118,14 +118,14 @@ overwrite pairs env = unpairs $ mapMaybe lookupAndAlias pairs
 -- | Retrieve the 'Live' set of addresses to which the given free variable names are bound.
 --
 --   Unbound names are silently dropped.
-roots :: (Ord location, Foldable t) => Environment location -> t Name -> Live location value
-roots env = foldMap (maybe mempty liveSingleton . flip lookup env)
+roots :: (Ord address, Foldable t) => Environment address -> t Name -> Live address
+roots env names = addresses (names `intersect` env)
 
-addresses :: Ord location => Environment location -> Live location value
+addresses :: Ord address => Environment address -> Live address
 addresses = fromAddresses . map snd . pairs
 
 
-instance Lower (Environment location) where lowerBound = emptyEnv
+instance Lower (Environment address) where lowerBound = emptyEnv
 
-instance Show location => Show (Environment location) where
+instance Show address => Show (Environment address) where
   showsPrec d = showsUnaryWith showsPrec "Environment" d . pairs

src/Data/Abstract/Evaluatable.hs

@@ -24,7 +24,6 @@ import Control.Abstract.Exports as X
 import Control.Abstract.Heap as X hiding (AddressError(..), runAddressError, runAddressErrorWith)
 import Control.Abstract.Modules as X (Modules, ResolutionError(..), load, lookupModule, listModulesInDir, require, resolve)
 import Control.Abstract.Value as X
-import Data.Abstract.Address as X
 import Data.Abstract.Declarations as X
 import Data.Abstract.Environment as X
 import Data.Abstract.Exports as Exports
@@ -45,71 +44,68 @@ import Prologue
 
 -- | The 'Evaluatable' class defines the necessary interface for a term to be evaluated. While a default definition of 'eval' is given, instances with computational content must implement 'eval' to perform their small-step operational semantics.
 class Evaluatable constr where
-  eval :: ( EvaluatableConstraints location term value effects
+  eval :: ( EvaluatableConstraints address term value effects
           , Member Fail effects
           )
-       => SubtermAlgebra constr term (Evaluator location value effects (ValueRef location value))
-  default eval :: ( Members '[ Resumable (Unspecialized value)
-                             , Allocator location value
-                             , State (Heap location (Cell location) value)
-                             ] effects
+       => SubtermAlgebra constr term (Evaluator address value effects (ValueRef address value))
+  default eval :: ( Member (Resumable (Unspecialized value)) effects
+                  , Member (Allocator address value) effects
+                  , Member (State (Heap address (Cell address) value)) effects
                   , Show1 constr
-                  , Ord location
-                  , Reducer value (Cell location value)
+                  , Ord address
+                  , Reducer value (Cell address value)
                   )
-               => SubtermAlgebra constr term (Evaluator location value effects (ValueRef location value))
+               => SubtermAlgebra constr term (Evaluator address value effects (ValueRef address value))
   eval expr = rvalBox =<< throwResumable (Unspecialized ("Eval unspecialized for " ++ liftShowsPrec (const (const id)) (const id) 0 expr ""))
 
-type EvaluatableConstraints location term value effects =
-  ( AbstractValue location value effects
+type EvaluatableConstraints address term value effects =
+  ( AbstractValue address value effects
   , Declarations term
   , FreeVariables term
-  , Members '[ Allocator location value
-             , LoopControl location value
-             , Modules location value
-             , Reader (Environment location)
-             , Reader ModuleInfo
-             , Reader PackageInfo
-             , Reader Span
-             , Resumable (EnvironmentError location)
-             , Resumable EvalError
-             , Resumable ResolutionError
-             , Resumable (Unspecialized value)
-             , Return location value
-             , State (Environment location)
-             , State (Exports location)
-             , State (Heap location (Cell location) value)
-             , Trace
-             ] effects
-  , Ord location
-  , Reducer value (Cell location value)
+  , Member (Allocator address value) effects
+  , Member (LoopControl address value) effects
+  , Member (Modules address value) effects
+  , Member (Reader (Environment address)) effects
+  , Member (Reader ModuleInfo) effects
+  , Member (Reader PackageInfo) effects
+  , Member (Reader Span) effects
+  , Member (Resumable (EnvironmentError address)) effects
+  , Member (Resumable EvalError) effects
+  , Member (Resumable ResolutionError) effects
+  , Member (Resumable (Unspecialized value)) effects
+  , Member (Return address value) effects
+  , Member (State (Environment address)) effects
+  , Member (State (Exports address)) effects
+  , Member (State (Heap address (Cell address) value)) effects
+  , Member Trace effects
+  , Ord address
+  , Reducer value (Cell address value)
   )
 
 
 -- | Evaluate a given package.
-evaluatePackageWith :: forall location term value inner outer
-                    -- FIXME: It’d be nice if we didn’t have to mention 'Addressable' here at all, but 'Located' locations require knowledge of 'currentModule' to run. Can we fix that? If not, can we factor this effect list out?
-                    .  ( Addressable location (Reader ModuleInfo ': Modules location value ': Reader Span ': Reader PackageInfo ': outer)
+evaluatePackageWith :: forall address term value inner outer
+                    -- FIXME: It’d be nice if we didn’t have to mention 'Addressable' here at all, but 'Located' addresses require knowledge of 'currentModule' to run. Can we fix that? If not, can we factor this effect list out?
+                    .  ( Addressable address (Reader ModuleInfo ': Modules address value ': Reader Span ': Reader PackageInfo ': outer)
                        , Evaluatable (Base term)
-                       , EvaluatableConstraints location term value inner
-                       , Members '[ Fail
-                                  , Fresh
-                                  , Reader (Environment location)
-                                  , Resumable (AddressError location value)
-                                  , Resumable (LoadError location value)
-                                  , State (Environment location)
-                                  , State (Exports location)
-                                  , State (Heap location (Cell location) value)
-                                  , State (ModuleTable (Maybe (Environment location, Address location value)))
-                                  , Trace
-                                  ] outer
+                       , EvaluatableConstraints address term value inner
+                       , Member Fail outer
+                       , Member Fresh outer
+                       , Member (Reader (Environment address)) outer
+                       , Member (Resumable (AddressError address value)) outer
+                       , Member (Resumable (LoadError address value)) outer
+                       , Member (State (Environment address)) outer
+                       , Member (State (Exports address)) outer
+                       , Member (State (Heap address (Cell address) value)) outer
+                       , Member (State (ModuleTable (Maybe (Environment address, address)))) outer
+                       , Member Trace outer
                        , Recursive term
-                       , inner ~ (LoopControl location value ': Return location value ': Allocator location value ': Reader ModuleInfo ': Modules location value ': Reader Span ': Reader PackageInfo ': outer)
+                       , inner ~ (LoopControl address value ': Return address value ': Allocator address value ': Reader ModuleInfo ': Modules address value ': Reader Span ': Reader PackageInfo ': outer)
                        )
-                    => (SubtermAlgebra Module      term (TermEvaluator term location value inner (Address location value))            -> SubtermAlgebra Module      term (TermEvaluator term location value inner (Address location value)))
-                    -> (SubtermAlgebra (Base term) term (TermEvaluator term location value inner (ValueRef location value)) -> SubtermAlgebra (Base term) term (TermEvaluator term location value inner (ValueRef location value)))
+                    => (SubtermAlgebra Module      term (TermEvaluator term address value inner (address))            -> SubtermAlgebra Module      term (TermEvaluator term address value inner (address)))
+                    -> (SubtermAlgebra (Base term) term (TermEvaluator term address value inner (ValueRef address value)) -> SubtermAlgebra (Base term) term (TermEvaluator term address value inner (ValueRef address value)))
                     -> Package term
-                    -> TermEvaluator term location value outer [(Address location value)]
+                    -> TermEvaluator term address value outer [address]
 evaluatePackageWith analyzeModule analyzeTerm package
   = runReader (packageInfo package)
   . runReader lowerBound
@@ -131,7 +127,7 @@ evaluatePackageWith analyzeModule analyzeTerm package
           . raiseHandler runReturn
           . raiseHandler runLoopControl
 
-        evaluateEntryPoint :: ModulePath -> Maybe Name -> TermEvaluator term location value (Modules location value ': Reader Span ': Reader PackageInfo ': outer) (Address location value)
+        evaluateEntryPoint :: ModulePath -> Maybe Name -> TermEvaluator term address value (Modules address value ': Reader Span ': Reader PackageInfo ': outer) (address)
         evaluateEntryPoint m sym = runInModule (ModuleInfo m) . TermEvaluator $ do
           reqResult <- require m
           v <- maybe (box unit) (pure . snd) reqResult
@@ -155,10 +151,10 @@ evaluatePackageWith analyzeModule analyzeTerm package
         pairValueWithEnv action = flip (,) <$> action <*> (filterEnv <$> TermEvaluator getExports <*> TermEvaluator getEnv)
 
 -- | Isolate the given action with an empty global environment and exports.
-isolate :: Members '[State (Environment location), State (Exports location)] effects => Evaluator location value effects a -> Evaluator location value effects a
+isolate :: (Member (State (Environment address)) effects, Member (State (Exports address)) effects) => Evaluator address value effects a -> Evaluator address value effects a
 isolate = withEnv lowerBound . withExports lowerBound
 
-traceResolve :: (Show a, Show b, Member Trace effects) => a -> b -> Evaluator location value effects ()
+traceResolve :: (Show a, Show b, Member Trace effects) => a -> b -> Evaluator address value effects ()
 traceResolve name path = trace ("resolved " <> show name <> " -> " <> show path)
 
 

src/Data/Abstract/Exports.hs

@@ -7,31 +7,30 @@ module Data.Abstract.Exports
     , toEnvironment
     ) where
 
-import Prelude hiding (null)
-import Prologue hiding (null)
-import Data.Abstract.Address
 import Data.Abstract.Environment (Environment, unpairs)
 import Data.Abstract.Name
 import qualified Data.Map as Map
 import Data.Semilattice.Lower
+import Prelude hiding (null)
+import Prologue hiding (null)
 
 -- | A map of export names to an alias & address tuple.
-newtype Exports location = Exports { unExports :: Map.Map Name (Name, Maybe location) }
+newtype Exports address = Exports { unExports :: Map.Map Name (Name, Maybe address) }
   deriving (Eq, Lower, Monoid, Ord, Semigroup)
 
-null :: Exports location -> Bool
+null :: Exports address -> Bool
 null = Map.null . unExports
 
-toEnvironment :: Exports location -> Environment location
-toEnvironment exports = unpairs (mapMaybe (traverse (fmap Address)) (toList (unExports exports)))
+toEnvironment :: Exports address -> Environment address
+toEnvironment exports = unpairs (mapMaybe sequenceA (toList (unExports exports)))
 
-insert :: Name -> Name -> Maybe (Address location value) -> Exports location -> Exports location
-insert name alias address = Exports . Map.insert name (alias, unAddress <$> address) . unExports
+insert :: Name -> Name -> Maybe address -> Exports address -> Exports address
+insert name alias address = Exports . Map.insert name (alias, address) . unExports
 
 -- TODO: Should we filter for duplicates here?
-aliases :: Exports location -> [(Name, Name)]
+aliases :: Exports address -> [(Name, Name)]
 aliases = Map.toList . fmap fst . unExports
 
 
-instance Show location => Show (Exports location) where
+instance Show address => Show (Exports address) where
   showsPrec d = showsUnaryWith showsPrec "Exports" d . Map.toList . unExports

src/Data/Abstract/Heap.hs

@@ -1,7 +1,6 @@
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 module Data.Abstract.Heap where
 
-import Data.Abstract.Address
 import Data.Abstract.Live
 import qualified Data.Map.Monoidal as Monoidal
 import Data.Semigroup.Reducer
@@ -9,38 +8,38 @@ import Data.Semilattice.Lower
 import Prologue
 
 -- | A map of addresses onto cells holding their values.
-newtype Heap location cell value = Heap { unHeap :: Monoidal.Map location (cell value) }
+newtype Heap address cell value = Heap { unHeap :: Monoidal.Map address (cell value) }
   deriving (Eq, Foldable, Functor, Lower, Monoid, Ord, Semigroup, Traversable)
 
 -- | Look up the cell of values for an 'Address' in a 'Heap', if any.
-heapLookup :: Ord location => Address location value -> Heap location cell value -> Maybe (cell value)
-heapLookup (Address address) = Monoidal.lookup address . unHeap
+heapLookup :: Ord address => address -> Heap address cell value -> Maybe (cell value)
+heapLookup address = Monoidal.lookup address . unHeap
 
 -- | Look up the list of values stored for a given address, if any.
-heapLookupAll :: (Ord location, Foldable cell) => Address location value -> Heap location cell value -> Maybe [value]
+heapLookupAll :: (Ord address, Foldable cell) => address -> Heap address cell value -> Maybe [value]
 heapLookupAll address = fmap toList . heapLookup address
 
 -- | Append a value onto the cell for a given address, inserting a new cell if none existed.
-heapInsert :: (Ord location, Reducer value (cell value)) => Address location value -> value -> Heap location cell value -> Heap location cell value
+heapInsert :: (Ord address, Reducer value (cell value)) => address -> value -> Heap address cell value -> Heap address cell value
 heapInsert address value = flip snoc (address, value)
 
 -- | Manually insert a cell into the heap at a given address.
-heapInit :: Ord location => Address location value -> cell value -> Heap location cell value -> Heap location cell value
-heapInit (Address address) cell (Heap h) = Heap (Monoidal.insert address cell h)
+heapInit :: Ord address => address -> cell value -> Heap address cell value -> Heap address cell value
+heapInit address cell (Heap h) = Heap (Monoidal.insert address cell h)
 
 -- | The number of addresses extant in a 'Heap'.
-heapSize :: Heap location cell value -> Int
+heapSize :: Heap address cell value -> Int
 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)
+-- | Restrict a 'Heap' to only those addresses in the given 'Live' set (in essence garbage collecting the rest).
+heapRestrict :: Ord address => Heap address cell value -> Live address -> Heap address cell value
+heapRestrict (Heap m) roots = Heap (Monoidal.filterWithKey (\ address _ -> address `liveMember` roots) m)
 
 
-instance (Ord location, Reducer value (cell value)) => Reducer (Address location value, value) (Heap location cell value) where
-  unit = Heap . unit . first unAddress
-  cons (Address key, a) (Heap heap) = Heap (cons (key, a) heap)
-  snoc (Heap heap) (Address key, a) = Heap (snoc heap (key, a))
+instance (Ord address, Reducer value (cell value)) => Reducer (address, value) (Heap address cell value) where
+  unit = Heap . unit
+  cons (addr, a) (Heap heap) = Heap (cons (addr, a) heap)
+  snoc (Heap heap) (addr, a) = Heap (snoc heap (addr, a))
 
-instance (Show location, Show (cell value)) => Show (Heap location cell value) where
+instance (Show address, Show (cell value)) => Show (Heap address cell value) where
   showsPrec d = showsUnaryWith showsPrec "Heap" d . Monoidal.pairs . unHeap

src/Data/Abstract/Live.hs

@@ -1,42 +1,41 @@
 {-# LANGUAGE DataKinds, GeneralizedNewtypeDeriving, TypeFamilies, TypeOperators #-}
 module Data.Abstract.Live where
 
-import Data.Abstract.Address
 import Data.Semilattice.Lower
 import Data.Set as Set
 import Prologue
 
 -- | A set of live addresses (whether roots or reachable).
-newtype Live location value = Live { unLive :: Set location }
+newtype Live address = Live { unLive :: Set address }
   deriving (Eq, Lower, Monoid, Ord, Semigroup)
 
-fromAddresses :: (Foldable t, Ord location) => t (Address location value) -> Live location value
+fromAddresses :: (Foldable t, Ord address) => t address -> Live address
 fromAddresses = Prologue.foldr liveInsert lowerBound
 
 -- | Construct a 'Live' set containing only the given address.
-liveSingleton :: Address location value -> Live location value
-liveSingleton = Live . Set.singleton . unAddress
+liveSingleton :: address -> Live address
+liveSingleton = Live . Set.singleton
 
 -- | Insert an address into a 'Live' set.
-liveInsert :: Ord location => Address location value -> Live location value -> Live location value
-liveInsert addr = Live . Set.insert (unAddress addr) . unLive
+liveInsert :: Ord address => address -> Live address -> Live address
+liveInsert addr = Live . Set.insert addr . unLive
 
 -- | Delete an address from a 'Live' set, if present.
-liveDelete :: Ord location => Address location value -> Live location value -> Live location value
-liveDelete addr = Live . Set.delete (unAddress addr) . unLive
+liveDelete :: Ord address => address -> Live address -> Live address
+liveDelete addr = Live . Set.delete addr . unLive
 
 -- | Compute the (asymmetric) difference of two 'Live' sets, i.e. delete every element of the second set from the first set.
-liveDifference :: Ord location => Live location value -> Live location value -> Live location value
+liveDifference :: Ord address => Live address -> Live address -> Live address
 liveDifference = fmap Live . (Set.difference `on` unLive)
 
--- | Test whether an 'Address' is in a 'Live' set.
-liveMember :: Ord location => Address location value -> Live location value -> Bool
-liveMember addr = Set.member (unAddress addr) . unLive
+-- | Test whether an address is in a 'Live' set.
+liveMember :: Ord address => address -> Live address -> Bool
+liveMember addr = Set.member 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
+liveSplit :: Live address -> Maybe (address, Live address)
+liveSplit = fmap (fmap Live) . Set.minView . unLive
 
 
-instance Show location => Show (Live location value) where
+instance Show address => Show (Live address) where
   showsPrec d = showsUnaryWith showsPrec "Live" d . Set.toList . unLive

src/Data/Abstract/Name.hs

@@ -6,11 +6,12 @@ module Data.Abstract.Name
 , unName
 ) where
 
+import           Data.Aeson
 import qualified Data.ByteString.Char8 as BC
 import qualified Data.Char as Char
+import           Data.String
 import qualified Data.Text as Text
 import qualified Data.Text.Encoding as Text
-import           Data.String
 import           Prologue
 
 -- | The type of variable names.
@@ -53,3 +54,7 @@ instance Show Name where
 instance Hashable Name where
   hashWithSalt salt (Name name) = hashWithSalt salt name
   hashWithSalt salt (I i)       = salt `hashWithSalt` (1 :: Int) `hashWithSalt` i
+
+instance ToJSON Name where
+  toJSON = toJSON . Text.decodeUtf8 . unName
+  toEncoding = toEncoding . Text.decodeUtf8 . unName

src/Data/Abstract/Ref.hs

@@ -5,11 +5,11 @@ import Data.Abstract.Address
 import Data.Abstract.Name
 
 -- | 'ValueRef' is the type subterms evaluate to and can represent either values directly ('Rval'), or references to values (lvals - such as local variables or object members)
-data ValueRef location value where
+data ValueRef address value where
   -- | A value.
-  Rval       :: Address location value -> ValueRef location value
+  Rval       :: address -> ValueRef address value
   -- | A local variable. No environment is attached—it’s assumed that 'LvalLocal' will be evaluated in the same scope it was constructed in.
-  LvalLocal  :: Name -> ValueRef location value
+  LvalLocal  :: Name -> ValueRef address value
   -- | An object member.
-  LvalMember :: Address location value -> Name -> ValueRef location value
+  LvalMember :: address -> Name -> ValueRef address value
   deriving (Eq, Ord, Show)

src/Data/Abstract/Type.hs

@@ -94,7 +94,7 @@ unify t1 t2
   | t1 == t2  = pure t2
   | otherwise = throwResumable (UnificationError t1 t2)
 
-instance Ord location => ValueRoots location Type where
+instance Ord address => ValueRoots address Type where
   valueRoots _ = mempty
 
 
@@ -116,26 +116,23 @@ instance AbstractIntro Type where
   null        = Null
 
 
-instance ( Members '[ Allocator location Type
-                    , Fresh
-                    , NonDet
-                    , Reader (Environment location)
-                    , Resumable TypeError
-                    , Return location Type
-                    , State (Environment location)
-                    , State (Heap location (Cell location) Type)
-                    ] effects
-         , Ord location
-         , Reducer Type (Cell location Type)
+instance ( Member (Allocator address Type) effects
+         , Member Fresh effects
+         , Member (Resumable TypeError) effects
+         , Member (Return address Type) effects
+         , Member (State (Environment address)) effects
+         , Member (State (Heap address (Cell address) Type)) effects
+         , Ord address
+         , Reducer Type (Cell address Type)
          )
-      => AbstractFunction location Type effects where
+      => AbstractFunction address Type effects where
   closure names _ body = do
     (env, tvars) <- foldr (\ name rest -> do
       a <- alloc name
       tvar <- Var <$> fresh
       assign a tvar
       bimap (Env.insert name a) (tvar :) <$> rest) (pure (emptyEnv, [])) names
-    (box . (zeroOrMoreProduct tvars :->) =<< deref =<< localEnv (mergeEnvs env) (body `catchReturn` \ (Return value) -> pure value))
+    (zeroOrMoreProduct tvars :->) <$> (deref =<< locally (bindAll env *> body `catchReturn` \ (Return ptr) -> pure ptr))
 
   call op params = do
     tvar <- fresh
@@ -148,19 +145,17 @@ instance ( Members '[ Allocator location Type
 
 
 -- | Discard the value arguments (if any), constructing a 'Type' instead.
-instance ( Members '[ Allocator location Type
-                    , Fresh
-                    , NonDet
-                    , Reader (Environment location)
-                    , Resumable TypeError
-                    , Return location Type
-                    , State (Environment location)
-                    , State (Heap location (Cell location) Type)
-                    ] effects
-         , Ord location
-         , Reducer Type (Cell location Type)
+instance ( Member (Allocator address Type) effects
+         , Member Fresh effects
+         , Member NonDet effects
+         , Member (Resumable TypeError) effects
+         , Member (Return address Type) effects
+         , Member (State (Environment address)) effects
+         , Member (State (Heap address (Cell address) Type)) effects
+         , Ord address
+         , Reducer Type (Cell address Type)
          )
-      => AbstractValue location Type effects where
+      => AbstractValue address Type effects where
   array fields = do
     var <- fresh
     Array <$> foldr (\ t1 -> (unify t1 =<<)) (pure (Var var)) fields

src/Data/Abstract/Value.hs

@@ -15,8 +15,8 @@ import Data.Semigroup.Reducer
 import qualified Data.Set as Set
 import Prologue
 
-data Value location body
-  = Closure PackageInfo ModuleInfo [Name] (ClosureBody location body) (Environment location)
+data Value address body
+  = Closure PackageInfo ModuleInfo [Name] (ClosureBody address body) (Environment address)
   | Unit
   | Boolean Bool
   | Integer  (Number.Number Integer)
@@ -24,57 +24,56 @@ data Value location body
   | Float    (Number.Number Scientific)
   | String ByteString
   | Symbol ByteString
-  | Tuple [Value location body]
-  | Array [Value location body]
-  | Class Name (Environment location)
-  | Namespace Name (Environment location)
-  | KVPair (Value location body) (Value location body)
-  | Hash [Value location body]
+  | Tuple [Value address body]
+  | Array [Value address body]
+  | Class Name (Environment address)
+  | Namespace Name (Environment address)
+  | KVPair (Value address body) (Value address body)
+  | Hash [Value address body]
   | Null
   | Hole
   deriving (Eq, Ord, Show)
 
-data ClosureBody location body = ClosureBody { closureBodyId :: Int, closureBody :: body (Address location (Value location body)) }
+data ClosureBody address body = ClosureBody { closureBodyId :: Int, closureBody :: body address }
 
-instance Eq   (ClosureBody location body) where
+instance Eq   (ClosureBody address body) where
   (==) = (==) `on` closureBodyId
 
-instance Ord  (ClosureBody location body) where
+instance Ord  (ClosureBody address body) where
   compare = compare `on` closureBodyId
 
-instance Show (ClosureBody location body) where
+instance Show (ClosureBody address body) where
   showsPrec d (ClosureBody i _) = showsBinaryWith showsPrec (const showChar) "ClosureBody" d i '_'
 
 
-instance Ord location => ValueRoots location (Value location body) where
+instance Ord address => ValueRoots address (Value address body) where
   valueRoots v
     | Closure _ _ _ _ env <- v = Env.addresses env
     | otherwise                = mempty
 
 
-instance AbstractHole (Value location body) where
+instance AbstractHole (Value address body) where
   hole = Hole
 
 instance ( Coercible body (Eff effects)
-         , Members '[ Allocator location (Value location body)
-                    , Fresh
-                    , Reader ModuleInfo
-                    , Reader PackageInfo
-                    , Resumable (ValueError location body)
-                    , Return location (Value location body)
-                    , State (Environment location)
-                    , State (Heap location (Cell location) (Value location body))
-                    ] effects
-         , Ord location
-         , Reducer (Value location body) (Cell location (Value location body))
-         , Show location
+         , Member (Allocator address (Value address body)) effects
+         , Member Fresh effects
+         , Member (Reader ModuleInfo) effects
+         , Member (Reader PackageInfo) effects
+         , Member (Resumable (ValueError address body)) effects
+         , Member (Return address (Value address body)) effects
+         , Member (State (Environment address)) effects
+         , Member (State (Heap address (Cell address) (Value address body))) effects
+         , Ord address
+         , Reducer (Value address body) (Cell address (Value address body))
+         , Show address
          )
-      => AbstractFunction location (Value location body) effects where
+      => AbstractFunction address (Value address body) effects where
   closure parameters freeVariables body = do
     packageInfo <- currentPackage
     moduleInfo <- currentModule
     i <- fresh
-    box =<< Closure packageInfo moduleInfo parameters (ClosureBody i (coerce (lowerEff body))) . Env.bind (foldr Set.delete freeVariables parameters) <$> getEnv
+    Closure packageInfo moduleInfo parameters (ClosureBody i (coerce (lowerEff body))) . Env.intersect (foldr Set.delete freeVariables parameters) <$> getEnv
 
   call op params = do
     case op of
@@ -85,11 +84,11 @@ instance ( Coercible body (Eff effects)
           bindings <- foldr (\ (name, param) rest -> do
             a <- param
             Env.insert name a <$> rest) (pure env) (zip names params)
-          localEnv (mergeEnvs bindings) (raiseEff (coerce body) `catchReturn` \ (Return value) -> pure value)
+          locally (bindAll bindings *> raiseEff (coerce body) `catchReturn` \ (Return ptr) -> pure ptr)
       _ -> box =<< throwValueError (CallError op)
 
 
-instance Show location => AbstractIntro (Value location body) where
+instance Show address => AbstractIntro (Value address body) where
   unit     = Unit
   integer  = Integer . Number.Integer
   boolean  = Boolean
@@ -108,22 +107,21 @@ instance Show location => AbstractIntro (Value location body) where
 
 -- | Construct a 'Value' wrapping the value arguments (if any).
 instance ( Coercible body (Eff effects)
-         , Members '[ Allocator location (Value location body)
-                    , Fresh
-                    , LoopControl location (Value location body)
-                    , Reader (Environment location)
-                    , Reader ModuleInfo
-                    , Reader PackageInfo
-                    , Resumable (ValueError location body)
-                    , Return location (Value location body)
-                    , State (Environment location)
-                    , State (Heap location (Cell location) (Value location body))
-                    ] effects
-         , Ord location
-         , Reducer (Value location body) (Cell location (Value location body))
-         , Show location
+         , Member (Allocator address (Value address body)) effects
+         , Member Fresh effects
+         , Member (LoopControl address (Value address body)) effects
+         , Member (Reader (Environment address)) effects
+         , Member (Reader ModuleInfo) effects
+         , Member (Reader PackageInfo) effects
+         , Member (Resumable (ValueError address body)) effects
+         , Member (Return address (Value address body)) effects
+         , Member (State (Environment address)) effects
+         , Member (State (Heap address (Cell address) (Value address body))) effects
+         , Ord address
+         , Reducer (Value address body) (Cell address (Value address body))
+         , Show address
          )
-      => AbstractValue location (Value location body) effects where
+      => AbstractValue address (Value address body) effects where
   asPair val
     | KVPair k v <- val = pure (k, v)
     | otherwise = throwValueError $ KeyValueError val
@@ -186,7 +184,7 @@ instance ( Coercible body (Eff effects)
         tentative x i j = attemptUnsafeArithmetic (x i j)
 
         -- Dispatch whatever's contained inside a 'Number.SomeNumber' to its appropriate 'MonadValue' ctor
-        specialize :: (AbstractValue location (Value location body) effects, Member (Resumable (ValueError location body)) effects) => Either ArithException Number.SomeNumber -> Evaluator location (Value location body) effects (Value location body)
+        specialize :: (AbstractValue address (Value address body) effects, Member (Resumable (ValueError address body)) effects) => Either ArithException Number.SomeNumber -> Evaluator address (Value address body) effects (Value address body)
         specialize (Left exc) = throwValueError (ArithmeticError exc)
         specialize (Right (Number.SomeNumber (Number.Integer i))) = pure $ integer i
         specialize (Right (Number.SomeNumber (Number.Ratio r)))   = pure $ rational r
@@ -205,7 +203,7 @@ instance ( Coercible body (Eff effects)
       where
         -- Explicit type signature is necessary here because we're passing all sorts of things
         -- to these comparison functions.
-        go :: (AbstractValue location (Value location body) effects, Ord a) => a -> a -> Evaluator location (Value location body) effects (Value location body)
+        go :: (AbstractValue address (Value address body) effects, Ord a) => a -> a -> Evaluator address (Value address body) effects (Value address body)
         go l r = case comparator of
           Concrete f  -> pure $ boolean (f l r)
           Generalized -> pure $ integer (orderingToInt (compare l r))
@@ -233,25 +231,25 @@ instance ( Coercible body (Eff effects)
 
 
 -- | The type of exceptions that can be thrown when constructing values in 'Value'’s 'MonadValue' instance.
-data ValueError location body resume where
-  StringError            :: Value location body                        -> ValueError location body ByteString
-  BoolError              :: Value location body                        -> ValueError location body Bool
-  IndexError             :: Value location body -> Value location body -> ValueError location body (Value location body)
-  NamespaceError         :: Prelude.String                             -> ValueError location body (Environment location)
-  CallError              :: Value location body                        -> ValueError location body (Value location body)
-  NumericError           :: Value location body                        -> ValueError location body (Value location body)
-  Numeric2Error          :: Value location body -> Value location body -> ValueError location body (Value location body)
-  ComparisonError        :: Value location body -> Value location body -> ValueError location body (Value location body)
-  BitwiseError           :: Value location body                        -> ValueError location body (Value location body)
-  Bitwise2Error          :: Value location body -> Value location body -> ValueError location body (Value location body)
-  KeyValueError          :: Value location body                        -> ValueError location body (Value location body, Value location body)
+data ValueError address body resume where
+  StringError            :: Value address body                       -> ValueError address body ByteString
+  BoolError              :: Value address body                       -> ValueError address body Bool
+  IndexError             :: Value address body -> Value address body -> ValueError address body (Value address body)
+  NamespaceError         :: Prelude.String                           -> ValueError address body (Environment address)
+  CallError              :: Value address body                       -> ValueError address body (Value address body)
+  NumericError           :: Value address body                       -> ValueError address body (Value address body)
+  Numeric2Error          :: Value address body -> Value address body -> ValueError address body (Value address body)
+  ComparisonError        :: Value address body -> Value address body -> ValueError address body (Value address body)
+  BitwiseError           :: Value address body                       -> ValueError address body (Value address body)
+  Bitwise2Error          :: Value address body -> Value address body -> ValueError address body (Value address body)
+  KeyValueError          :: Value address body                       -> ValueError address body (Value address body, Value address body)
   -- Indicates that we encountered an arithmetic exception inside Haskell-native number crunching.
-  ArithmeticError        :: ArithException                             -> ValueError location body (Value location body)
+  ArithmeticError        :: ArithException                           -> ValueError address body (Value address body)
   -- Out-of-bounds error
-  BoundsError            :: [Value location body] -> Prelude.Integer   -> ValueError location body (Value location body)
+  BoundsError            :: [Value address body] -> Prelude.Integer  -> ValueError address body (Value address body)
 
 
-instance Eq location => Eq1 (ValueError location body) where
+instance Eq address => Eq1 (ValueError address body) where
   liftEq _ (StringError a) (StringError b)                       = a == b
   liftEq _ (NamespaceError a) (NamespaceError b)                 = a == b
   liftEq _ (CallError a) (CallError b)                           = a == b
@@ -265,15 +263,15 @@ instance Eq location => Eq1 (ValueError location body) where
   liftEq _ (BoundsError a b) (BoundsError c d)                   = (a == c) && (b == d)
   liftEq _ _             _                                       = False
 
-deriving instance Show location => Show (ValueError location body resume)
-instance Show location => Show1 (ValueError location body) where
+deriving instance Show address => Show (ValueError address body resume)
+instance Show address => Show1 (ValueError address body) where
   liftShowsPrec _ _ = showsPrec
 
-throwValueError :: Member (Resumable (ValueError location body)) effects => ValueError location body resume -> Evaluator location (Value location body) effects resume
+throwValueError :: Member (Resumable (ValueError address body)) effects => ValueError address body resume -> Evaluator address (Value address body) effects resume
 throwValueError = throwResumable
 
-runValueError :: Effectful (m location (Value location body)) => m location (Value location body) (Resumable (ValueError location body) ': effects) a -> m location (Value location body) effects (Either (SomeExc (ValueError location body)) a)
+runValueError :: Effectful (m address (Value address body)) => m address (Value address body) (Resumable (ValueError address body) ': effects) a -> m address (Value address body) effects (Either (SomeExc (ValueError address body)) a)
 runValueError = runResumable
 
-runValueErrorWith :: Effectful (m location (Value location body)) => (forall resume . ValueError location body resume -> m location (Value location body) effects resume) -> m location (Value location body) (Resumable (ValueError location body) ': effects) a -> m location (Value location body) effects a
+runValueErrorWith :: Effectful (m address (Value address body)) => (forall resume . ValueError address body resume -> m address (Value address body) effects resume) -> m address (Value address body) (Resumable (ValueError address body) ': effects) a -> m address (Value address body) effects a
 runValueErrorWith = runResumableWith

src/Data/Align/Generic.hs

@@ -1,78 +0,0 @@
-{-# LANGUAGE DataKinds, DefaultSignatures, TypeOperators, UndecidableInstances #-}
-module Data.Align.Generic where
-
-import Control.Applicative
-import Control.Monad
-import Data.Functor (($>))
-import Data.List.NonEmpty (NonEmpty(..))
-import Data.Maybe (fromMaybe)
-import Data.Sum
-import Data.These
-import GHC.Generics
-
--- | Functors which can be aligned (structure-unioning-ly zipped). The default implementation will operate generically over the constructors in the aligning type.
-class GAlign f where
-  -- | Perform generic alignment of values of some functor, applying the given function to alignments of elements.
-  galignWith :: Alternative g => (These a1 a2 -> g b) -> f a1 -> f a2 -> g (f b)
-  default galignWith :: (Alternative g, Generic1 f, GAlign (Rep1 f)) => (These a1 a2 -> g b) -> f a1 -> f a2 -> g (f b)
-  galignWith f a b = to1 <$> galignWith f (from1 a) (from1 b)
-
-galign :: (Alternative g, GAlign f) => f a1 -> f a2 -> g (f (These a1 a2))
-galign = galignWith pure
-
--- 'Data.Align.Align' instances
-
-instance GAlign Maybe where
-  galignWith f (Just a1) (Just a2) = Just <$> f (These a1 a2)
-  galignWith f (Just a1) Nothing   = Just <$> f (This a1)
-  galignWith f Nothing   (Just a2) = Just <$> f (That a2)
-  galignWith _ Nothing   Nothing   = pure Nothing
-
-instance GAlign [] where
-  galignWith f (a1:as1) (a2:as2) = (:) <$> f (These a1 a2) <*> galignWith f as1 as2
-  galignWith f []       as2      = traverse (f . That) as2
-  galignWith f as1      []       = traverse (f . This) as1
-
-instance GAlign NonEmpty where
-  galignWith f (a1:|as1) (a2:|as2) = (:|) <$> f (These a1 a2) <*> galignWith f as1 as2
-
-instance Apply GAlign fs => GAlign (Sum fs) where
-  galignWith f = (fromMaybe empty .) . apply2' @GAlign (\ inj -> (fmap inj .) . galignWith f)
-
-
--- Generics
-
--- | 'GAlign' over unit constructors.
-instance GAlign U1 where
-  galignWith _ _ _ = pure U1
-
--- | 'GAlign' over parameters.
-instance GAlign Par1 where
-  galignWith f (Par1 a) (Par1 b) = Par1 <$> f (These a b)
-
--- | 'GAlign' over non-parameter fields. Only equal values are aligned.
-instance Eq c => GAlign (K1 i c) where
-  galignWith _ (K1 a) (K1 b) = guard (a == b) $> K1 b
-
--- | 'GAlign' over applications over parameters.
-instance GAlign f => GAlign (Rec1 f) where
-  galignWith f (Rec1 a) (Rec1 b) = Rec1 <$> galignWith f a b
-
--- | 'GAlign' over metainformation (constructor names, etc).
-instance GAlign f => GAlign (M1 i c f) where
-  galignWith f (M1 a) (M1 b) = M1 <$> galignWith f a b
-
--- | 'GAlign' over sums. Returns 'Nothing' for disjoint constructors.
-instance (GAlign f, GAlign g) => GAlign (f :+: g) where
-  galignWith f a b = case (a, b) of
-    (L1 a, L1 b) -> L1 <$> galignWith f a b
-    (R1 a, R1 b) -> R1 <$> galignWith f a b
-    _ -> empty
-
--- | 'GAlign' over products.
-instance (GAlign f, GAlign g) => GAlign (f :*: g) where
-  galignWith f (a1 :*: b1) (a2 :*: b2) = (:*:) <$> galignWith f a1 a2 <*> galignWith f b1 b2
-
--- | 'GAlign' over type compositions.
-instance (Traversable f, Applicative f, GAlign g) => GAlign (f :.: g) where
-  galignWith f (Comp1 a) (Comp1 b) = Comp1 <$> sequenceA (galignWith f <$> a <*> b)

src/Data/Diff.hs

@@ -89,13 +89,13 @@ diffPatches = para $ \ diff -> case diff of
 
 
 -- | Recover the before state of a diff.
-beforeTerm :: (Mergeable syntax, Traversable syntax) => Diff syntax ann1 ann2 -> Maybe (Term syntax ann1)
+beforeTerm :: (Foldable syntax, Mergeable syntax) => Diff syntax ann1 ann2 -> Maybe (Term syntax ann1)
 beforeTerm = cata $ \ diff -> case diff of
   Patch patch -> (before patch >>= \ (In  a     l) -> termIn a <$> sequenceAlt l) <|> (after patch >>= asum)
   Merge                              (In (a, _) l) -> termIn a <$> sequenceAlt l
 
 -- | Recover the after state of a diff.
-afterTerm :: (Mergeable syntax, Traversable syntax) => Diff syntax ann1 ann2 -> Maybe (Term syntax ann2)
+afterTerm :: (Foldable syntax, Mergeable syntax) => Diff syntax ann1 ann2 -> Maybe (Term syntax ann2)
 afterTerm = cata $ \ diff -> case diff of
   Patch patch -> (after patch >>= \ (In     b  r) -> termIn b <$> sequenceAlt r) <|> (before patch >>= asum)
   Merge                             (In (_, b) r) -> termIn b <$> sequenceAlt r

src/Data/JSON/Fields.hs

@@ -1,4 +1,5 @@
-{-# LANGUAGE DefaultSignatures, MultiParamTypeClasses, TypeOperators, UndecidableInstances #-}
+{-# LANGUAGE DefaultSignatures, MultiParamTypeClasses, TypeOperators, UndecidableInstances, GADTs #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-} -- FIXME
 module Data.JSON.Fields
   ( JSONFields (..)
   , JSONFields1 (..)
@@ -9,17 +10,20 @@ module Data.JSON.Fields
   , withChildren
   ) where
 
-import Data.Aeson
-import Data.Sum (Apply(..), Sum)
-import Prologue
+import           Data.Aeson
+import           Data.Sum (Apply (..), Sum)
+import qualified Data.Text as Text
+import qualified Data.Text.Encoding as Text
+import           Prologue
 
 class ToJSONFields a where
   toJSONFields :: KeyValue kv => a -> [kv]
 
 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]
+  default toJSONFields1 :: (KeyValue kv, ToJSON a, GToJSONFields1 (Rep1 f), GConstructorName1 (Rep1 f), Generic1 f) => f a -> [kv]
+  toJSONFields1 s = let r = from1 s in
+    "term" .= gconstructorName1 r : gtoJSONFields1 r
 
 withChildren :: (KeyValue kv, ToJSON a, Foldable f) => f a -> [kv] -> [kv]
 withChildren f ks = ("children" .= toList f) : ks
@@ -67,3 +71,82 @@ instance (ToJSON a, ToJSONFields1 f) => ToJSONFields (JSONFields1 f a) where
 instance (ToJSON a, ToJSONFields1 f) => ToJSON (JSONFields1 f a) where
   toJSON = object . toJSONFields1 . unJSONFields1
   toEncoding = pairs . mconcat . toJSONFields1 . unJSONFields1
+
+
+-- | A typeclass to retrieve the name of a data constructor.
+class GConstructorName1 f where
+  gconstructorName1 :: f a -> String
+
+instance Apply GConstructorName1 fs => GConstructorName1 (Sum fs) where
+  gconstructorName1 = apply @GConstructorName1 gconstructorName1
+
+instance GConstructorName1 f => GConstructorName1 (M1 D c f) where
+  gconstructorName1 = gconstructorName1 . unM1
+
+instance Constructor c => GConstructorName1 (M1 C c f) where
+  gconstructorName1 = conName
+
+instance (GConstructorName1 f, GConstructorName1 g) => GConstructorName1 (f :+: g) where
+  gconstructorName1 (L1 l) = gconstructorName1 l
+  gconstructorName1 (R1 r) = gconstructorName1 r
+
+
+-- | A typeclass to calculate a list of 'KeyValue's describing the record selector names and associated values on a datatype.
+class GToJSONFields1 f where
+  gtoJSONFields1 :: (KeyValue kv, ToJSON a) => f a -> [kv]
+
+instance GToJSONFields1 f => GToJSONFields1 (M1 D c f) where
+  gtoJSONFields1 = gtoJSONFields1 . unM1
+
+instance GToJSONFields1 f => GToJSONFields1 (M1 C c f) where
+  gtoJSONFields1 = gtoJSONFields1 . unM1
+
+instance GToJSONFields1 U1 where
+  gtoJSONFields1 _ = []
+
+instance (Selector c, GSelectorJSONValue1 f) => GToJSONFields1 (M1 S c f) where
+  gtoJSONFields1 m1 = case selName m1 of
+    "" -> [ "children" .= json ]
+    n ->  [ Text.pack n .= json ]
+    where json = gselectorJSONValue1 (unM1 m1)
+
+instance (GToJSONFields1 f, GToJSONFields1 g) => GToJSONFields1 (f :+: g) where
+  gtoJSONFields1 (L1 l) = gtoJSONFields1 l
+  gtoJSONFields1 (R1 r) = gtoJSONFields1 r
+
+instance (GToJSONFields1 f, GToJSONFields1 g) => GToJSONFields1 (f :*: g) where
+  gtoJSONFields1 (x :*: y) = gtoJSONFields1 x <> gtoJSONFields1 y
+
+-- | A typeclass to retrieve the JSON 'Value' of a record selector.
+class GSelectorJSONValue1 f where
+  gselectorJSONValue1 :: ToJSON a => f a -> SomeJSON
+
+instance GSelectorJSONValue1 Par1 where
+  gselectorJSONValue1 = SomeJSON . unPar1
+
+instance ToJSON1 f => GSelectorJSONValue1 (Rec1 f) where
+  gselectorJSONValue1 = SomeJSON . SomeJSON1 . unRec1
+
+instance ToJSON k => GSelectorJSONValue1 (K1 r k) where
+  gselectorJSONValue1 = SomeJSON . unK1
+
+
+-- TODO: Fix this orphan instance.
+instance ToJSON ByteString where
+  toJSON = toJSON . Text.decodeUtf8
+  toEncoding = toEncoding . Text.decodeUtf8
+
+
+data SomeJSON where
+  SomeJSON :: ToJSON a => a -> SomeJSON
+
+instance ToJSON SomeJSON where
+  toJSON (SomeJSON a) = toJSON a
+  toEncoding (SomeJSON a) = toEncoding a
+
+data SomeJSON1 where
+  SomeJSON1 :: (ToJSON1 f, ToJSON a) => f a -> SomeJSON1
+
+instance ToJSON SomeJSON1 where
+  toJSON (SomeJSON1 fa) = toJSON1 fa
+  toEncoding (SomeJSON1 fa) = toEncoding1 fa

src/Data/Mergeable.hs

@@ -13,71 +13,62 @@ import GHC.Generics
 --
 -- This is a kind of distributive law which produces (at least) the union of the two functors’ shapes; i.e. unlike 'Traversable', an 'empty' value in the inner functor does not produce an 'empty' result, and unlike 'Crosswalk', an 'empty' value in the outer functor does not produce an 'empty' result.
 --
--- For example, we can use 'merge' to select one side or the other of a diff node in 'Syntax', while correctly handling the fact that some patches don’t have any content for that side:
---
--- @
--- let before = iter (\ (a :< s) -> cofree . (fst a :<) <$> sequenceAlt syntax) . fmap (maybeFst . unPatch)
--- @
+-- For example, 'Data.Diff' uses 'sequenceAlt' to select one side or the other of a diff node, while correctly handling the fact that some patches don’t have any content for that side.
 class Functor t => Mergeable t where
-  -- | Merge a functor by mapping its elements into an 'Alternative' functor, combining them, and pushing the 'Mergeable' functor inside.
-  merge :: Alternative f => (a -> f b) -> t a -> f (t b)
-  default merge :: (Generic1 t, GMergeable (Rep1 t), Alternative f) => (a -> f b) -> t a -> f (t b)
-  merge = genericMerge
-
-  -- | Sequnce a 'Mergeable' functor by 'merge'ing the 'Alternative' values.
+  -- | Sequence a 'Mergeable' functor by merging the 'Alternative' values.
   sequenceAlt :: Alternative f => t (f a) -> f (t a)
-  sequenceAlt = merge id
+  default sequenceAlt :: (Generic1 t, GMergeable (Rep1 t), Alternative f) => t (f a) -> f (t a)
+  sequenceAlt = genericSequenceAlt
 
 
 -- Instances
 
 instance Mergeable [] where
-  merge f (x:xs) = ((:) <$> f x <|> pure id) <*> merge f xs
-  merge _ [] = pure []
+  sequenceAlt = foldr (\ x -> (((:) <$> x <|> pure id) <*>)) (pure [])
 
 instance Mergeable NonEmpty where
-  merge f (x:|[]) = (:|) <$> f x <*> pure []
-  merge f (x1:|x2:xs) = (:|) <$> f x1 <*> merge f (x2 : xs) <|> merge f (x2:|xs)
+  sequenceAlt (x :|[])    = (:|) <$> x  <*> pure []
+  sequenceAlt (x1:|x2:xs) = (:|) <$> x1 <*> sequenceAlt (x2 : xs) <|> sequenceAlt (x2:|xs)
 
 instance Mergeable Maybe where
-  merge f (Just a) = Just <$> f a
-  merge _ Nothing = pure empty
+  sequenceAlt = maybe (pure empty) (fmap Just)
 
-instance Mergeable Identity where merge f = fmap Identity . f . runIdentity
+instance Mergeable Identity where
+  sequenceAlt = fmap Identity . runIdentity
 
 instance (Apply Functor fs, Apply Mergeable fs) => Mergeable (Sum fs) where
-  merge f = apply' @Mergeable (\ reinj g -> reinj <$> merge f g)
+  sequenceAlt = apply' @Mergeable (\ reinj t -> reinj <$> sequenceAlt t)
 
 
 -- Generics
 
 class GMergeable t where
-  gmerge :: Alternative f => (a -> f b) -> t a -> f (t b)
+  gsequenceAlt :: Alternative f => t (f a) -> f (t a)
 
-genericMerge :: (Generic1 t, GMergeable (Rep1 t), Alternative f) => (a -> f b) -> t a -> f (t b)
-genericMerge f = fmap to1 . gmerge f . from1
+genericSequenceAlt :: (Generic1 t, GMergeable (Rep1 t), Alternative f) => t (f a) -> f (t a)
+genericSequenceAlt = fmap to1 . gsequenceAlt . from1
 
 
 -- Instances
 
 instance GMergeable U1 where
-  gmerge _ _ = pure U1
+  gsequenceAlt _ = pure U1
 
 instance GMergeable Par1 where
-  gmerge f (Par1 a) = Par1 <$> f a
+  gsequenceAlt (Par1 a) = Par1 <$> a
 
 instance GMergeable (K1 i c) where
-  gmerge _ (K1 a) = pure (K1 a)
+  gsequenceAlt (K1 a) = pure (K1 a)
 
 instance Mergeable f => GMergeable (Rec1 f) where
-  gmerge f (Rec1 a) = Rec1 <$> merge f a
+  gsequenceAlt (Rec1 a) = Rec1 <$> sequenceAlt a
 
 instance GMergeable f => GMergeable (M1 i c f) where
-  gmerge f (M1 a) = M1 <$> gmerge f a
+  gsequenceAlt (M1 a) = M1 <$> gsequenceAlt a
 
 instance (GMergeable f, GMergeable g) => GMergeable (f :+: g) where
-  gmerge f (L1 a) = L1 <$> gmerge f a
-  gmerge f (R1 b) = R1 <$> gmerge f b
+  gsequenceAlt (L1 a) = L1 <$> gsequenceAlt a
+  gsequenceAlt (R1 a) = R1 <$> gsequenceAlt a
 
 instance (GMergeable f, GMergeable g) => GMergeable (f :*: g) where
-  gmerge f (a :*: b) = (:*:) <$> gmerge f a <*> gmerge f b
+  gsequenceAlt (a :*: b) = (:*:) <$> gsequenceAlt a <*> gsequenceAlt b

src/Data/Syntax.hs

@@ -101,16 +101,13 @@ infixContext context left right operators = uncurry (&) <$> postContextualizeThr
 -- Common
 
 -- | An identifier of some other construct, whether a containing declaration (e.g. a class name) or a reference (e.g. a variable).
-newtype Identifier a = Identifier Name
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+newtype Identifier a = Identifier { name :: Name }
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, ToJSONFields1)
 
 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) = pure (LvalLocal name)
 
@@ -120,28 +117,26 @@ instance FreeVariables1 Identifier where
 instance Declarations1 Identifier where
   liftDeclaredName _ (Identifier x) = pure x
 
+
 newtype Program a = Program [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1, ToJSONFields1)
 
 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
 
+
 -- | An accessibility modifier, e.g. private, public, protected, etc.
 newtype AccessibilityModifier a = AccessibilityModifier ByteString
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1, ToJSONFields1)
 
 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
 
@@ -149,7 +144,7 @@ instance Evaluatable AccessibilityModifier
 --
 --   This can be used to represent an implicit no-op, e.g. the alternative in an 'if' statement without an 'else'.
 data Empty a = Empty
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Empty
 
@@ -163,7 +158,7 @@ instance Evaluatable Empty where
 
 -- | Syntax representing a parsing or assignment error.
 data Error a = Error { errorCallStack :: ErrorStack, errorExpected :: [String], errorActual :: Maybe String, errorChildren :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Error where liftEq = genericLiftEq
 instance Ord1 Error where liftCompare = genericLiftCompare
@@ -216,7 +211,7 @@ 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)
+  deriving (Eq, Foldable, Functor, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Context
 

src/Data/Syntax/Comment.hs

@@ -9,7 +9,7 @@ import Diffing.Algorithm
 
 -- | An unnested comment (line or block).
 newtype Comment a = Comment { commentContent :: ByteString }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Comment where liftEq = genericLiftEq
 instance Ord1 Comment where liftCompare = genericLiftCompare

src/Data/Syntax/Declaration.hs

@@ -9,7 +9,7 @@ import Diffing.Algorithm
 import Prologue
 
 data Function a = Function { functionContext :: ![a], functionName :: !a, functionParameters :: ![a], functionBody :: !a }
-  deriving (Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Diffable Function where
   equivalentBySubterm = Just . functionName
@@ -27,7 +27,7 @@ instance Evaluatable Function where
   eval Function{..} = do
     name <- either (throwEvalError . FreeVariablesError) pure (freeVariable $ subterm functionName)
     (v, addr) <- letrec name (closure (paramNames functionParameters) (Set.fromList (freeVariables functionBody)) (subtermAddress functionBody))
-    modifyEnv (Env.insert name addr)
+    bind name addr
     rvalBox v
     where paramNames = foldMap (freeVariables . subterm)
 
@@ -36,7 +36,7 @@ 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, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Method where liftEq = genericLiftEq
 instance Ord1 Method where liftCompare = genericLiftCompare
@@ -53,14 +53,14 @@ instance Evaluatable Method where
   eval Method{..} = do
     name <- either (throwEvalError . FreeVariablesError) pure (freeVariable $ subterm methodName)
     (v, addr) <- letrec name (closure (paramNames methodParameters) (Set.fromList (freeVariables methodBody)) (subtermAddress methodBody))
-    modifyEnv (Env.insert name addr)
+    bind name addr
     rvalBox v
     where paramNames = foldMap (freeVariables . subterm)
 
 
 -- | A method signature in TypeScript or a method spec in Go.
 data MethodSignature a = MethodSignature { _methodSignatureContext :: ![a], _methodSignatureName :: !a, _methodSignatureParameters :: ![a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 MethodSignature where liftEq = genericLiftEq
 instance Ord1 MethodSignature where liftCompare = genericLiftCompare
@@ -73,7 +73,7 @@ instance Evaluatable MethodSignature
 
 
 newtype RequiredParameter a = RequiredParameter { requiredParameter :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 RequiredParameter where liftEq = genericLiftEq
 instance Ord1 RequiredParameter where liftCompare = genericLiftCompare
@@ -86,7 +86,7 @@ instance Evaluatable RequiredParameter
 
 
 newtype OptionalParameter a = OptionalParameter { optionalParameter :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 OptionalParameter where liftEq = genericLiftEq
 instance Ord1 OptionalParameter where liftCompare = genericLiftCompare
@@ -103,7 +103,7 @@ instance Evaluatable OptionalParameter
 -- TODO: It would be really nice to have a more meaningful type contained in here than [a]
 -- | A declaration of possibly many variables such as var foo = 5, bar = 6 in JavaScript.
 newtype VariableDeclaration a = VariableDeclaration { variableDeclarations :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 VariableDeclaration where liftEq = genericLiftEq
 instance Ord1 VariableDeclaration where liftCompare = genericLiftCompare
@@ -123,7 +123,7 @@ instance Declarations a => Declarations (VariableDeclaration a) where
 
 -- | A TypeScript/Java style interface declaration to implement.
 data InterfaceDeclaration a = InterfaceDeclaration { interfaceDeclarationContext :: ![a], interfaceDeclarationIdentifier :: !a, interfaceDeclarationBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 InterfaceDeclaration where liftEq = genericLiftEq
 instance Ord1 InterfaceDeclaration where liftCompare = genericLiftCompare
@@ -140,7 +140,7 @@ instance Declarations a => Declarations (InterfaceDeclaration a) where
 
 -- | A public field definition such as a field definition in a JavaScript class.
 data PublicFieldDefinition a = PublicFieldDefinition { publicFieldContext :: ![a], publicFieldPropertyName :: !a, publicFieldValue :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 PublicFieldDefinition where liftEq = genericLiftEq
 instance Ord1 PublicFieldDefinition where liftCompare = genericLiftCompare
@@ -153,7 +153,7 @@ instance Evaluatable PublicFieldDefinition
 
 
 data Variable a = Variable { variableName :: !a, variableType :: !a, variableValue :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Variable where liftEq = genericLiftEq
 instance Ord1 Variable where liftCompare = genericLiftCompare
@@ -165,7 +165,7 @@ instance ToJSONFields1 Variable
 instance Evaluatable Variable
 
 data Class a = Class { classContext :: ![a], classIdentifier :: !a, classSuperclasses :: ![a], classBody :: !a }
-  deriving (Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Declarations a => Declarations (Class a) where
   declaredName (Class _ name _ _) = declaredName name
@@ -187,11 +187,11 @@ instance Evaluatable Class where
       void $ subtermValue classBody
       classEnv <- Env.head <$> getEnv
       klass name supers classEnv
-    rvalBox =<< (v <$ modifyEnv (Env.insert name addr))
+    rvalBox =<< (v <$ bind name addr)
 
 -- | A decorator in Python
 data Decorator a = Decorator { decoratorIdentifier :: !a, decoratorParamaters :: ![a], decoratorBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Decorator where liftEq = genericLiftEq
 instance Ord1 Decorator where liftCompare = genericLiftCompare
@@ -207,7 +207,7 @@ instance Evaluatable Decorator
 
 -- | An ADT, i.e. a disjoint sum of products, like 'data' in Haskell, or 'enum' in Rust or Swift.
 data Datatype a = Datatype { datatypeName :: !a, datatypeConstructors :: ![a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Data.Syntax.Declaration.Datatype where liftEq = genericLiftEq
 instance Ord1 Data.Syntax.Declaration.Datatype where liftCompare = genericLiftCompare
@@ -221,7 +221,7 @@ instance Evaluatable Data.Syntax.Declaration.Datatype
 
 -- | A single constructor in a datatype, or equally a 'struct' in C, Rust, or Swift.
 data Constructor a = Constructor { constructorName :: !a, constructorFields :: ![a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Data.Syntax.Declaration.Constructor where liftEq = genericLiftEq
 instance Ord1 Data.Syntax.Declaration.Constructor where liftCompare = genericLiftCompare
@@ -235,7 +235,7 @@ instance Evaluatable Data.Syntax.Declaration.Constructor
 
 -- | Comprehension (e.g. ((a for b in c if a()) in Python)
 data Comprehension a = Comprehension { comprehensionValue :: !a, comprehensionBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Comprehension where liftEq = genericLiftEq
 instance Ord1 Comprehension where liftCompare = genericLiftCompare
@@ -249,7 +249,7 @@ instance Evaluatable Comprehension
 
 -- | A declared type (e.g. `a []int` in Go).
 data Type a = Type { typeName :: !a, typeKind :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Type where liftEq = genericLiftEq
 instance Ord1 Type where liftCompare = genericLiftCompare
@@ -263,7 +263,7 @@ instance Evaluatable Type
 
 -- | Type alias declarations in Javascript/Haskell, etc.
 data TypeAlias a = TypeAlias { typeAliasContext :: ![a], typeAliasIdentifier :: !a, typeAliasKind :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 TypeAlias where liftEq = genericLiftEq
 instance Ord1 TypeAlias where liftCompare = genericLiftCompare
@@ -278,7 +278,7 @@ instance Evaluatable TypeAlias where
     v <- subtermValue typeAliasKind
     addr <- lookupOrAlloc name
     assign addr v
-    rvalBox =<< (modifyEnv (Env.insert name addr) $> v)
+    rvalBox =<< (v <$ bind name addr)
 
 instance Declarations a => Declarations (TypeAlias a) where
   declaredName TypeAlias{..} = declaredName typeAliasIdentifier

src/Data/Syntax/Directive.hs

@@ -11,7 +11,7 @@ import           Prologue
 
 -- A file directive like the Ruby constant `__FILE__`.
 data File a = File
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 File where liftEq = genericLiftEq
 instance Ord1 File where liftCompare = genericLiftCompare
@@ -25,7 +25,7 @@ instance Evaluatable File where
 
 -- A line directive like the Ruby constant `__LINE__`.
 data Line a = Line
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Line where liftEq = genericLiftEq
 instance Ord1 Line where liftCompare = genericLiftCompare

src/Data/Syntax/Expression.hs

@@ -10,7 +10,7 @@ import Prologue hiding (index)
 
 -- | Typical prefix function application, like `f(x)` in many languages, or `f x` in Haskell.
 data Call a = Call { callContext :: ![a], callFunction :: !a, callParams :: ![a], callBlock :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Call where liftEq = genericLiftEq
 instance Ord1 Call where liftCompare = genericLiftCompare
@@ -31,7 +31,7 @@ data Comparison a
   | Equal !a !a
   | StrictEqual !a !a
   | Comparison !a !a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Comparison where liftEq = genericLiftEq
 instance Ord1 Comparison where liftCompare = genericLiftCompare
@@ -62,7 +62,7 @@ data Arithmetic a
   | Modulo !a !a
   | Power !a !a
   | Negate !a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Arithmetic where liftEq = genericLiftEq
 instance Ord1 Arithmetic where liftCompare = genericLiftCompare
@@ -85,7 +85,7 @@ instance Evaluatable Arithmetic where
 data Match a
   = Matches !a !a
   | NotMatches !a !a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Match where liftEq = genericLiftEq
 instance Ord1 Match where liftCompare = genericLiftCompare
@@ -102,7 +102,7 @@ data Boolean a
   | And !a !a
   | Not !a
   | XOr !a !a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Boolean where liftEq = genericLiftEq
 instance Ord1 Boolean where liftCompare = genericLiftCompare
@@ -124,7 +124,7 @@ instance Evaluatable Boolean where
 
 -- | Javascript delete operator
 newtype Delete a = Delete a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Delete where liftEq = genericLiftEq
 instance Ord1 Delete where liftCompare = genericLiftCompare
@@ -138,7 +138,7 @@ instance Evaluatable Delete
 
 -- | A sequence expression such as Javascript or C's comma operator.
 data SequenceExpression a = SequenceExpression { _firstExpression :: !a, _secondExpression :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 SequenceExpression where liftEq = genericLiftEq
 instance Ord1 SequenceExpression where liftCompare = genericLiftCompare
@@ -152,7 +152,7 @@ instance Evaluatable SequenceExpression
 
 -- | Javascript void operator
 newtype Void a = Void a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Void where liftEq = genericLiftEq
 instance Ord1 Void where liftCompare = genericLiftCompare
@@ -166,7 +166,7 @@ instance Evaluatable Void
 
 -- | Javascript typeof operator
 newtype Typeof a = Typeof a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Typeof where liftEq = genericLiftEq
 instance Ord1 Typeof where liftCompare = genericLiftCompare
@@ -187,7 +187,7 @@ data Bitwise a
   | RShift !a !a
   | UnsignedRShift !a !a
   | Complement a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Bitwise where liftEq = genericLiftEq
 instance Ord1 Bitwise where liftCompare = genericLiftCompare
@@ -211,7 +211,7 @@ instance Evaluatable Bitwise where
 -- | Member Access (e.g. a.b)
 data MemberAccess a
   = MemberAccess !a !a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 MemberAccess where liftEq = genericLiftEq
 instance Ord1 MemberAccess where liftCompare = genericLiftCompare
@@ -231,7 +231,7 @@ instance Evaluatable MemberAccess where
 data Subscript a
   = Subscript !a ![a]
   | Member !a !a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Subscript where liftEq = genericLiftEq
 instance Ord1 Subscript where liftCompare = genericLiftCompare
@@ -249,7 +249,7 @@ instance Evaluatable Subscript where
 
 -- | Enumeration (e.g. a[1:10:1] in Python (start at index 1, stop at index 10, step 1 element from start to stop))
 data Enumeration a = Enumeration { enumerationStart :: !a, enumerationEnd :: !a, enumerationStep :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Enumeration where liftEq = genericLiftEq
 instance Ord1 Enumeration where liftCompare = genericLiftCompare
@@ -263,7 +263,7 @@ instance Evaluatable Enumeration
 
 -- | InstanceOf (e.g. a instanceof b in JavaScript
 data InstanceOf a = InstanceOf { instanceOfSubject :: !a, instanceOfObject :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 InstanceOf where liftEq = genericLiftEq
 instance Ord1 InstanceOf where liftCompare = genericLiftCompare
@@ -277,7 +277,7 @@ instance Evaluatable InstanceOf
 
 -- | ScopeResolution (e.g. import a.b in Python or a::b in C++)
 newtype ScopeResolution a = ScopeResolution [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 ScopeResolution where liftEq = genericLiftEq
 instance Ord1 ScopeResolution where liftCompare = genericLiftCompare
@@ -291,7 +291,7 @@ instance Evaluatable ScopeResolution
 
 -- | A non-null expression such as Typescript or Swift's ! expression.
 newtype NonNullExpression a = NonNullExpression { nonNullExpression :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 NonNullExpression where liftEq = genericLiftEq
 instance Ord1 NonNullExpression where liftCompare = genericLiftCompare
@@ -305,7 +305,7 @@ instance Evaluatable NonNullExpression
 
 -- | An await expression in Javascript or C#.
 newtype Await a = Await { awaitSubject :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Await where liftEq = genericLiftEq
 instance Ord1 Await where liftCompare = genericLiftCompare
@@ -319,7 +319,7 @@ instance Evaluatable Await
 
 -- | An object constructor call in Javascript, Java, etc.
 newtype New a = New { newSubject :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 New where liftEq = genericLiftEq
 instance Ord1 New where liftCompare = genericLiftCompare
@@ -333,7 +333,7 @@ instance Evaluatable New
 
 -- | A cast expression to a specified type.
 data Cast a =  Cast { castSubject :: !a, castType :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Cast where liftEq = genericLiftEq
 instance Ord1 Cast where liftCompare = genericLiftCompare

src/Data/Syntax/Literal.hs

@@ -14,7 +14,7 @@ import Text.Read (readMaybe)
 -- Boolean
 
 newtype Boolean a = Boolean Bool
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 true :: Boolean a
 true = Boolean True
@@ -36,7 +36,7 @@ instance ToJSONFields1 Boolean where
 
 -- | A literal integer of unspecified width. No particular base is implied.
 newtype Integer a = Integer { integerContent :: ByteString }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Data.Syntax.Literal.Integer where liftEq = genericLiftEq
 instance Ord1 Data.Syntax.Literal.Integer where liftCompare = genericLiftCompare
@@ -57,7 +57,7 @@ instance ToJSONFields1 Data.Syntax.Literal.Integer where
 
 -- | A literal float of unspecified width.
 newtype Float a = Float { floatContent  :: ByteString }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Data.Syntax.Literal.Float where liftEq = genericLiftEq
 instance Ord1 Data.Syntax.Literal.Float where liftCompare = genericLiftCompare
@@ -72,7 +72,7 @@ instance ToJSONFields1 Float where
 
 -- Rational literals e.g. `2/3r`
 newtype Rational a = Rational ByteString
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Data.Syntax.Literal.Rational where liftEq = genericLiftEq
 instance Ord1 Data.Syntax.Literal.Rational where liftCompare = genericLiftCompare
@@ -90,7 +90,7 @@ instance ToJSONFields1 Data.Syntax.Literal.Rational where
 
 -- Complex literals e.g. `3 + 2i`
 newtype Complex a = Complex ByteString
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Data.Syntax.Literal.Complex where liftEq = genericLiftEq
 instance Ord1 Data.Syntax.Literal.Complex where liftCompare = genericLiftCompare
@@ -105,7 +105,7 @@ instance ToJSONFields1 Complex where
 -- Strings, symbols
 
 newtype String a = String { stringElements :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Data.Syntax.Literal.String where liftEq = genericLiftEq
 instance Ord1 Data.Syntax.Literal.String where liftCompare = genericLiftCompare
@@ -120,7 +120,7 @@ instance ToJSONFields1 Data.Syntax.Literal.String
 
 -- | An interpolation element within a string literal.
 newtype InterpolationElement a = InterpolationElement { interpolationBody :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 InterpolationElement where liftEq = genericLiftEq
 instance Ord1 InterpolationElement where liftCompare = genericLiftCompare
@@ -133,7 +133,7 @@ instance ToJSONFields1 InterpolationElement
 
 -- | A sequence of textual contents within a string literal.
 newtype TextElement a = TextElement { textElementContent :: ByteString }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 TextElement where liftEq = genericLiftEq
 instance Ord1 TextElement where liftCompare = genericLiftCompare
@@ -146,7 +146,7 @@ instance Evaluatable TextElement where
   eval (TextElement x) = rvalBox (string x)
 
 data Null a = Null
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Null where liftEq = genericLiftEq
 instance Ord1 Null where liftCompare = genericLiftCompare
@@ -157,7 +157,7 @@ instance Evaluatable Null where eval _ = rvalBox null
 instance ToJSONFields1 Null
 
 newtype Symbol a = Symbol { symbolContent :: ByteString }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Symbol where liftEq = genericLiftEq
 instance Ord1 Symbol where liftCompare = genericLiftCompare
@@ -169,7 +169,7 @@ instance Evaluatable Symbol where
   eval (Symbol s) = rvalBox (symbol s)
 
 newtype Regex a = Regex { regexContent :: ByteString }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Regex where liftEq = genericLiftEq
 instance Ord1 Regex where liftCompare = genericLiftCompare
@@ -189,7 +189,7 @@ instance Evaluatable Regex
 -- Collections
 
 newtype Array a = Array { arrayElements :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Array where liftEq = genericLiftEq
 instance Ord1 Array where liftCompare = genericLiftCompare
@@ -201,7 +201,7 @@ instance Evaluatable Array where
   eval (Array a) = rvalBox =<< (array =<< traverse subtermValue a)
 
 newtype Hash a = Hash { hashElements :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Hash where liftEq = genericLiftEq
 instance Ord1 Hash where liftCompare = genericLiftCompare
@@ -213,7 +213,7 @@ instance Evaluatable Hash where
   eval t = rvalBox =<< (hash <$> traverse (subtermValue >=> asPair) (hashElements t))
 
 data KeyValue a = KeyValue { key :: !a, value :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 KeyValue where liftEq = genericLiftEq
 instance Ord1 KeyValue where liftCompare = genericLiftCompare
@@ -228,7 +228,7 @@ instance Evaluatable KeyValue where
 instance ToJSONFields1 Tuple
 
 newtype Tuple a = Tuple { tupleContents :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Tuple where liftEq = genericLiftEq
 instance Ord1 Tuple where liftCompare = genericLiftCompare
@@ -238,7 +238,7 @@ instance Evaluatable Tuple where
   eval (Tuple cs) = rvalBox =<< (multiple <$> traverse subtermValue cs)
 
 newtype Set a = Set { setElements :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Set where liftEq = genericLiftEq
 instance Ord1 Set where liftCompare = genericLiftCompare
@@ -254,7 +254,7 @@ instance Evaluatable Set
 
 -- | A declared pointer (e.g. var pointer *int in Go)
 newtype Pointer a = Pointer a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Pointer where liftEq = genericLiftEq
 instance Ord1 Pointer where liftCompare = genericLiftCompare
@@ -268,7 +268,7 @@ instance Evaluatable Pointer
 
 -- | A reference to a pointer's address (e.g. &pointer in Go)
 newtype Reference a = Reference a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Reference where liftEq = genericLiftEq
 instance Ord1 Reference where liftCompare = genericLiftCompare

src/Data/Syntax/Statement.hs

@@ -1,7 +1,6 @@
 {-# LANGUAGE DeriveAnyClass, MultiParamTypeClasses, ScopedTypeVariables, UndecidableInstances, ViewPatterns #-}
 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
@@ -11,7 +10,7 @@ import Prologue
 
 -- | Conditional. This must have an else block, which can be filled with some default value when omitted in the source, e.g. 'pure ()' for C-style if-without-else or 'pure Nothing' for Ruby-style, in both cases assuming some appropriate Applicative context into which the If will be lifted.
 data If a = If { ifCondition :: !a, ifThenBody :: !a, ifElseBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 If where liftEq = genericLiftEq
 instance Ord1 If where liftCompare = genericLiftCompare
@@ -26,7 +25,7 @@ instance Evaluatable If where
 
 -- | Else statement. The else condition is any term, that upon successful completion, continues evaluation to the elseBody, e.g. `for ... else` in Python.
 data Else a = Else { elseCondition :: !a, elseBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Else where liftEq = genericLiftEq
 instance Ord1 Else where liftCompare = genericLiftCompare
@@ -41,7 +40,7 @@ instance Evaluatable Else
 
 -- | Goto statement (e.g. `goto a` in Go).
 newtype Goto a = Goto { gotoLocation :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Goto where liftEq = genericLiftEq
 instance Ord1 Goto where liftCompare = genericLiftCompare
@@ -55,7 +54,7 @@ instance Evaluatable Goto
 
 -- | A pattern-matching or computed jump control-flow statement, like 'switch' in C or JavaScript, or 'case' in Ruby or Haskell.
 data Match a = Match { matchSubject :: !a, matchPatterns :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Match where liftEq = genericLiftEq
 instance Ord1 Match where liftCompare = genericLiftCompare
@@ -69,7 +68,7 @@ instance Evaluatable Match
 
 -- | A pattern in a pattern-matching or computed jump control-flow statement, like 'case' in C or JavaScript, 'when' in Ruby, or the left-hand side of '->' in the body of Haskell 'case' expressions.
 data Pattern a = Pattern { _pattern :: !a, patternBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Pattern where liftEq = genericLiftEq
 instance Ord1 Pattern where liftCompare = genericLiftCompare
@@ -83,7 +82,7 @@ instance Evaluatable Pattern
 
 -- | A let statement or local binding, like 'a as b' or 'let a = b'.
 data Let a  = Let { letVariable :: !a, letValue :: !a, letBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Let where liftEq = genericLiftEq
 instance Ord1 Let where liftCompare = genericLiftCompare
@@ -95,14 +94,14 @@ instance Evaluatable Let where
   eval Let{..} = do
     name <- either (throwEvalError . FreeVariablesError) pure (freeVariable $ subterm letVariable)
     addr <- snd <$> letrec name (subtermValue letValue)
-    rvalBox =<< localEnv (Env.insert name addr) (subtermValue letBody)
+    rvalBox =<< locally (bind name addr *> subtermValue letBody)
 
 
 -- Assignment
 
 -- | Assignment to a variable or other lvalue.
 data Assignment a = Assignment { assignmentContext :: ![a], assignmentTarget :: !a, assignmentValue :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Assignment where liftEq = genericLiftEq
 instance Ord1 Assignment where liftCompare = genericLiftCompare
@@ -119,7 +118,7 @@ instance Evaluatable Assignment where
       LvalLocal nam -> do
         addr <- lookupOrAlloc nam
         assign addr rhs
-        modifyEnv (Env.insert nam addr)
+        bind nam addr
       LvalMember _ _ ->
         -- we don't yet support mutable object properties:
         pure ()
@@ -131,7 +130,7 @@ instance Evaluatable Assignment where
 
 -- | Post increment operator (e.g. 1++ in Go, or i++ in C).
 newtype PostIncrement a = PostIncrement a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 PostIncrement where liftEq = genericLiftEq
 instance Ord1 PostIncrement where liftCompare = genericLiftCompare
@@ -145,7 +144,7 @@ instance Evaluatable PostIncrement
 
 -- | Post decrement operator (e.g. 1-- in Go, or i-- in C).
 newtype PostDecrement a = PostDecrement a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 PostDecrement where liftEq = genericLiftEq
 instance Ord1 PostDecrement where liftCompare = genericLiftCompare
@@ -160,7 +159,7 @@ instance Evaluatable PostDecrement
 -- Returns
 
 newtype Return a = Return a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Return where liftEq = genericLiftEq
 instance Ord1 Return where liftCompare = genericLiftCompare
@@ -172,7 +171,7 @@ instance Evaluatable Return where
   eval (Return x) = Rval <$> (subtermAddress x >>= earlyReturn)
 
 newtype Yield a = Yield a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Yield where liftEq = genericLiftEq
 instance Ord1 Yield where liftCompare = genericLiftCompare
@@ -185,7 +184,7 @@ instance Evaluatable Yield
 
 
 newtype Break a = Break a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Break where liftEq = genericLiftEq
 instance Ord1 Break where liftCompare = genericLiftCompare
@@ -197,7 +196,7 @@ instance Evaluatable Break where
   eval (Break x) = Rval <$> (subtermAddress x >>= throwBreak)
 
 newtype Continue a = Continue a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Continue where liftEq = genericLiftEq
 instance Ord1 Continue where liftCompare = genericLiftCompare
@@ -209,7 +208,7 @@ instance Evaluatable Continue where
   eval (Continue x) = Rval <$> (subtermAddress x >>= throwContinue)
 
 newtype Retry a = Retry a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Retry where liftEq = genericLiftEq
 instance Ord1 Retry where liftCompare = genericLiftCompare
@@ -222,7 +221,7 @@ instance Evaluatable Retry
 
 
 newtype NoOp a = NoOp a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 NoOp where liftEq = genericLiftEq
 instance Ord1 NoOp where liftCompare = genericLiftCompare
@@ -236,7 +235,7 @@ instance Evaluatable NoOp where
 -- Loops
 
 data For a = For { forBefore :: !a, forCondition :: !a, forStep :: !a, forBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 For where liftEq = genericLiftEq
 instance Ord1 For where liftCompare = genericLiftCompare
@@ -249,7 +248,7 @@ instance Evaluatable For where
 
 
 data ForEach a = ForEach { forEachBinding :: !a, forEachSubject :: !a, forEachBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 ForEach where liftEq = genericLiftEq
 instance Ord1 ForEach where liftCompare = genericLiftCompare
@@ -262,7 +261,7 @@ instance Evaluatable ForEach
 
 
 data While a = While { whileCondition :: !a, whileBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 While where liftEq = genericLiftEq
 instance Ord1 While where liftCompare = genericLiftCompare
@@ -274,7 +273,7 @@ instance Evaluatable While where
   eval While{..} = rvalBox =<< while (subtermValue whileCondition) (subtermValue whileBody)
 
 data DoWhile a = DoWhile { doWhileCondition :: !a, doWhileBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 DoWhile where liftEq = genericLiftEq
 instance Ord1 DoWhile where liftCompare = genericLiftCompare
@@ -288,7 +287,7 @@ instance Evaluatable DoWhile where
 -- Exception handling
 
 newtype Throw a = Throw a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Throw where liftEq = genericLiftEq
 instance Ord1 Throw where liftCompare = genericLiftCompare
@@ -301,7 +300,7 @@ instance Evaluatable Throw
 
 
 data Try a = Try { tryBody :: !a, tryCatch :: ![a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Try where liftEq = genericLiftEq
 instance Ord1 Try where liftCompare = genericLiftCompare
@@ -314,7 +313,7 @@ instance Evaluatable Try
 
 
 data Catch a = Catch { catchException :: !a, catchBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Catch where liftEq = genericLiftEq
 instance Ord1 Catch where liftCompare = genericLiftCompare
@@ -327,7 +326,7 @@ instance Evaluatable Catch
 
 
 newtype Finally a = Finally a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Finally where liftEq = genericLiftEq
 instance Ord1 Finally where liftCompare = genericLiftCompare
@@ -343,7 +342,7 @@ instance Evaluatable Finally
 
 -- | ScopeEntry (e.g. `BEGIN {}` block in Ruby or Perl).
 newtype ScopeEntry a = ScopeEntry [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 ScopeEntry where liftEq = genericLiftEq
 instance Ord1 ScopeEntry where liftCompare = genericLiftCompare
@@ -357,7 +356,7 @@ instance Evaluatable ScopeEntry
 
 -- | ScopeExit (e.g. `END {}` block in Ruby or Perl).
 newtype ScopeExit a = ScopeExit [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 ScopeExit where liftEq = genericLiftEq
 instance Ord1 ScopeExit where liftCompare = genericLiftCompare
@@ -370,7 +369,7 @@ instance Evaluatable ScopeExit
 
 -- | HashBang line (e.g. `#!/usr/bin/env node`)
 newtype HashBang a = HashBang ByteString
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 HashBang where liftEq = genericLiftEq
 instance Ord1 HashBang where liftCompare = genericLiftCompare

src/Data/Syntax/Type.hs

@@ -7,7 +7,7 @@ import Diffing.Algorithm
 import Prologue hiding (Map)
 
 data Array a = Array { arraySize :: Maybe a, arrayElementType :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Array where liftEq = genericLiftEq
 instance Ord1 Array where liftCompare = genericLiftCompare
@@ -21,7 +21,7 @@ instance Evaluatable Array
 
 -- TODO: What about type variables? re: FreeVariables1
 data Annotation a = Annotation { annotationSubject :: !a, annotationType :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Annotation where liftEq = genericLiftEq
 instance Ord1 Annotation where liftCompare = genericLiftCompare
@@ -35,7 +35,7 @@ instance Evaluatable Annotation where
 
 
 data Function a = Function { functionParameters :: [a], functionReturn :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Function where liftEq = genericLiftEq
 instance Ord1 Function where liftCompare = genericLiftCompare
@@ -48,7 +48,7 @@ instance Evaluatable Function
 
 
 newtype Interface a = Interface [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Interface where liftEq = genericLiftEq
 instance Ord1 Interface where liftCompare = genericLiftCompare
@@ -61,7 +61,7 @@ instance Evaluatable Interface
 
 
 data Map a = Map { mapKeyType :: a, mapElementType :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Map where liftEq = genericLiftEq
 instance Ord1 Map where liftCompare = genericLiftCompare
@@ -74,7 +74,7 @@ instance Evaluatable Map
 
 
 newtype Parenthesized a = Parenthesized a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Parenthesized where liftEq = genericLiftEq
 instance Ord1 Parenthesized where liftCompare = genericLiftCompare
@@ -87,7 +87,7 @@ instance Evaluatable Parenthesized
 
 
 newtype Pointer a = Pointer a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Pointer where liftEq = genericLiftEq
 instance Ord1 Pointer where liftCompare = genericLiftCompare
@@ -100,7 +100,7 @@ instance Evaluatable Pointer
 
 
 newtype Product a = Product [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Product where liftEq = genericLiftEq
 instance Ord1 Product where liftCompare = genericLiftCompare
@@ -113,7 +113,7 @@ instance Evaluatable Product
 
 
 data Readonly a = Readonly
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Readonly where liftEq = genericLiftEq
 instance Ord1 Readonly where liftCompare = genericLiftCompare
@@ -126,7 +126,7 @@ instance Evaluatable Readonly
 
 
 newtype Slice a = Slice a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Slice where liftEq = genericLiftEq
 instance Ord1 Slice where liftCompare = genericLiftCompare
@@ -139,7 +139,7 @@ instance Evaluatable Slice
 
 
 newtype TypeParameters a = TypeParameters [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 TypeParameters where liftEq = genericLiftEq
 instance Ord1 TypeParameters where liftCompare = genericLiftCompare

src/Data/Term.hs

@@ -121,7 +121,7 @@ instance (ToJSONFields a, ToJSONFields1 f) => ToJSONFields (Term f a) where
   toJSONFields = toJSONFields . unTerm
 
 instance (ToJSON b, ToJSONFields a, ToJSONFields1 f) => ToJSONFields (TermF f a b) where
-  toJSONFields (In a f) = toJSONFields a <> toJSONFields1 f
+  toJSONFields (In a f) = toJSONFields1 f <> toJSONFields a
 
 instance (ToJSON b, ToJSONFields a, ToJSONFields1 f) => ToJSON (TermF f a b) where
   toJSON = object . toJSONFields

src/Diffing/Algorithm.hs

@@ -1,5 +1,4 @@
-{-# LANGUAGE DataKinds, DefaultSignatures, GADTs, RankNTypes, TypeOperators, UndecidableInstances #-}
-{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-} -- FIXME
+{-# LANGUAGE DefaultSignatures, GADTs, TypeOperators, UndecidableInstances #-}
 module Diffing.Algorithm where
 
 import Control.Monad.Free.Freer
@@ -143,6 +142,10 @@ class Diffable f where
                  -> Algorithm term1 term2 result (f result)
   algorithmFor = genericAlgorithmFor
 
+  tryAlignWith :: Alternative g => (These a1 a2 -> g b) -> f a1 -> f a2 -> g (f b)
+  default tryAlignWith :: (Alternative g, Generic1 f, GDiffable (Rep1 f)) => (These a1 a2 -> g b) -> f a1 -> f a2 -> g (f b)
+  tryAlignWith f a b = to1 <$> gtryAlignWith f (from1 a) (from1 b)
+
   -- | Construct an algorithm to diff against positions inside an @f@.
   --
   --   This is very like 'traverse', with two key differences:
@@ -190,6 +193,8 @@ genericComparableTo a1 a2 = gcomparableTo (from1 a1) (from1 a2)
 instance Apply Diffable fs => Diffable (Sum fs) where
   algorithmFor u1 u2 = fromMaybe empty (apply2' @Diffable (\ inj f1 f2 -> inj <$> algorithmFor f1 f2) u1 u2)
 
+  tryAlignWith f u1 u2 = fromMaybe empty (apply2' @Diffable (\ inj t1 t2 -> inj <$> tryAlignWith f t1 t2) u1 u2)
+
   subalgorithmFor blur focus = apply' @Diffable (\ inj f -> inj <$> subalgorithmFor blur focus f)
 
   equivalentBySubterm = apply @Diffable equivalentBySubterm
@@ -201,18 +206,31 @@ instance Apply Diffable fs => Diffable (Sum fs) where
 instance Diffable Maybe where
   algorithmFor = diffMaybe
 
+  tryAlignWith f (Just a1) (Just a2) = Just <$> f (These a1 a2)
+  tryAlignWith f (Just a1) Nothing   = Just <$> f (This a1)
+  tryAlignWith f Nothing   (Just a2) = Just <$> f (That a2)
+  tryAlignWith _ Nothing   Nothing   = pure Nothing
+
 -- | Diff two lists using RWS.
 instance Diffable [] where
   algorithmFor = byRWS
 
+  tryAlignWith f (a1:as1) (a2:as2) = (:) <$> f (These a1 a2) <*> tryAlignWith f as1 as2
+  tryAlignWith f []       as2      = traverse (f . That) as2
+  tryAlignWith f as1      []       = traverse (f . This) as1
+
 -- | Diff two non-empty lists using RWS.
 instance Diffable NonEmpty where
-  algorithmFor (a1:|as1) (a2:|as2) = (\ (a:as) -> a:|as) <$> byRWS (a1:as1) (a2:as2)
+  algorithmFor (a1:|as1) (a2:|as2) = nonEmpty <$> byRWS (a1:as1) (a2:as2) >>= maybe empty pure
+
+  tryAlignWith f (a1:|as1) (a2:|as2) = (:|) <$> f (These a1 a2) <*> tryAlignWith f as1 as2
 
 -- | A generic type class for diffing two terms defined by the Generic1 interface.
 class GDiffable f where
   galgorithmFor :: f term1 -> f term2 -> Algorithm term1 term2 result (f result)
 
+  gtryAlignWith :: Alternative g => (These a1 a2 -> g b) -> f a1 -> f a2 -> g (f b)
+
   gcomparableTo :: f term1 -> f term2 -> Bool
   gcomparableTo _ _ = True
 
@@ -220,6 +238,8 @@ class GDiffable f where
 instance GDiffable f => GDiffable (M1 i c f) where
   galgorithmFor (M1 a1) (M1 a2) = M1 <$> galgorithmFor a1 a2
 
+  gtryAlignWith f (M1 a) (M1 b) = M1 <$> gtryAlignWith f a b
+
   gcomparableTo (M1 a1) (M1 a2) = gcomparableTo a1 a2
 
 -- | Diff the fields of a product type.
@@ -227,6 +247,8 @@ instance GDiffable f => GDiffable (M1 i c f) where
 instance (GDiffable f, GDiffable g) => GDiffable (f :*: g) where
   galgorithmFor (a1 :*: b1) (a2 :*: b2) = (:*:) <$> galgorithmFor a1 a2 <*> galgorithmFor b1 b2
 
+  gtryAlignWith f (a1 :*: b1) (a2 :*: b2) = (:*:) <$> gtryAlignWith f a1 a2 <*> gtryAlignWith f b1 b2
+
 -- | Diff the constructors of a sum type.
 -- i.e. data Foo a = Foo a | Bar a (the 'Foo a' is captured by L1 and 'Bar a' is R1).
 instance (GDiffable f, GDiffable g) => GDiffable (f :+: g) where
@@ -234,6 +256,11 @@ instance (GDiffable f, GDiffable g) => GDiffable (f :+: g) where
   galgorithmFor (R1 b1) (R1 b2) = R1 <$> galgorithmFor b1 b2
   galgorithmFor _ _ = empty
 
+  gtryAlignWith f a b = case (a, b) of
+    (L1 a, L1 b) -> L1 <$> gtryAlignWith f a b
+    (R1 a, R1 b) -> R1 <$> gtryAlignWith f a b
+    _ -> empty
+
   gcomparableTo (L1 _) (L1 _) = True
   gcomparableTo (R1 _) (R1 _) = True
   gcomparableTo _      _      = False
@@ -243,18 +270,26 @@ instance (GDiffable f, GDiffable g) => GDiffable (f :+: g) where
 instance GDiffable Par1 where
   galgorithmFor (Par1 a1) (Par1 a2) = Par1 <$> diff a1 a2
 
+  gtryAlignWith f (Par1 a) (Par1 b) = Par1 <$> f (These a b)
+
 -- | Diff two constant parameters (K1 is the Generic1 newtype representing type parameter constants).
 -- i.e. data Foo = Foo Int (the 'Int' is a constant parameter).
 instance Eq c => GDiffable (K1 i c) where
   galgorithmFor (K1 a1) (K1 a2) = guard (a1 == a2) $> K1 a1
 
+  gtryAlignWith _ (K1 a) (K1 b) = guard (a == b) $> K1 b
+
 -- | Diff two terms whose constructors contain 0 type parameters.
 -- i.e. data Foo = Foo.
 instance GDiffable U1 where
   galgorithmFor _ _ = pure U1
 
+  gtryAlignWith _ _ _ = pure U1
+
 -- | Diff two 'Diffable' containers of parameters.
 instance Diffable f => GDiffable (Rec1 f) where
   galgorithmFor a1 a2 = Rec1 <$> algorithmFor (unRec1 a1) (unRec1 a2)
 
+  gtryAlignWith f (Rec1 a) (Rec1 b) = Rec1 <$> tryAlignWith f a b
+
 {-# ANN module ("HLint: ignore Avoid return" :: String) #-}

src/Diffing/Algorithm/RWS.hs

@@ -14,23 +14,23 @@ module Diffing.Algorithm.RWS
 , equalTerms
 ) where
 
-import Prologue
-import Data.Align.Generic (galignWith)
 import Control.Monad.State.Strict
 import Data.Diff (DiffF(..), deleting, inserting, merge, replacing)
 import qualified Data.KdMap.Static as KdMap
 import Data.List (sortOn)
 import Data.Record
 import Data.Term as Term
+import Diffing.Algorithm
 import Diffing.Algorithm.RWS.FeatureVector
 import Diffing.Algorithm.SES
+import Prologue
 
 -- | A relation on 'Term's, guaranteed constant-time in the size of the 'Term' by parametricity.
 --
 --   This is used both to determine whether two root terms can be compared in O(1), and, recursively, to determine whether two nodes are equal in O(n); thus, comparability is defined s.t. two terms are equal if they are recursively comparable subterm-wise.
 type ComparabilityRelation syntax ann1 ann2 = forall a b. TermF syntax ann1 a -> TermF syntax ann2 b -> Bool
 
-rws :: (Foldable syntax, Functor syntax, GAlign syntax)
+rws :: (Foldable syntax, Functor syntax, Diffable syntax)
     => ComparabilityRelation syntax (Record (FeatureVector ': fields1)) (Record (FeatureVector ': fields2))
     -> (Term syntax (Record (FeatureVector ': fields1)) -> Term syntax (Record (FeatureVector ': fields2)) -> Bool)
     -> [Term syntax (Record (FeatureVector ': fields1))]
@@ -153,13 +153,13 @@ equalTerms canCompare = go
 -- | Return an edit distance between two terms, up to a certain depth.
 --
 --   Computes a constant-time approximation to the edit distance of a diff. This is done by comparing at most _m_ nodes, & assuming the rest are zero-cost.
-editDistanceUpTo :: (GAlign syntax, Foldable syntax, Functor syntax) => Int -> Term syntax ann1 -> Term syntax ann2 -> Int
+editDistanceUpTo :: (Diffable syntax, Foldable syntax, Functor syntax) => Int -> Term syntax ann1 -> Term syntax ann2 -> Int
 editDistanceUpTo m a b = diffCost m (approximateDiff a b)
   where diffCost = flip . cata $ \ diff m -> case diff of
           _ | m <= 0 -> 0
           Merge body -> sum (fmap ($ pred m) body)
           body -> succ (sum (fmap ($ pred m) body))
-        approximateDiff a b = maybe (replacing a b) (merge (termAnnotation a, termAnnotation b)) (galignWith (Just . these deleting inserting approximateDiff) (termOut a) (termOut b))
+        approximateDiff a b = maybe (replacing a b) (merge (termAnnotation a, termAnnotation b)) (tryAlignWith (Just . these deleting inserting approximateDiff) (termOut a) (termOut b))
 
 
 data Label syntax where

src/Diffing/Interpreter.hs

@@ -1,11 +1,10 @@
-{-# LANGUAGE DataKinds, GADTs, RankNTypes, ScopedTypeVariables, TypeOperators #-}
+{-# LANGUAGE GADTs, RankNTypes, TypeOperators #-}
 module Diffing.Interpreter
 ( diffTerms
 , diffTermPair
 ) where
 
 import Control.Monad.Free.Freer
-import Data.Align.Generic (galignWith)
 import Data.Diff
 import Data.Record
 import Data.Term
@@ -14,7 +13,7 @@ import Diffing.Algorithm.RWS
 import Prologue
 
 -- | Diff two à la carte terms recursively.
-diffTerms :: (Diffable syntax, Eq1 syntax, GAlign syntax, Hashable1 syntax, Traversable syntax)
+diffTerms :: (Diffable syntax, Eq1 syntax, Hashable1 syntax, Traversable syntax)
           => Term syntax (Record fields1)
           -> Term syntax (Record fields2)
           -> Diff syntax (Record fields1) (Record fields2)
@@ -23,22 +22,21 @@ diffTerms t1 t2 = stripDiff (fromMaybe (replacing t1' t2') (runAlgorithm (diff t
                      , defaultFeatureVectorDecorator t2)
 
 -- | Diff a 'These' of terms.
-diffTermPair :: (Diffable syntax, Eq1 syntax, GAlign syntax, Hashable1 syntax, Traversable syntax) => These (Term syntax (Record fields1)) (Term syntax (Record fields2)) -> Diff syntax (Record fields1) (Record fields2)
+diffTermPair :: (Diffable syntax, Eq1 syntax, Hashable1 syntax, Traversable syntax) => These (Term syntax (Record fields1)) (Term syntax (Record fields2)) -> Diff syntax (Record fields1) (Record fields2)
 diffTermPair = these deleting inserting diffTerms
 
 
 -- | Run an 'Algorithm' to completion in an 'Alternative' context using the supplied comparability & equivalence relations.
-runAlgorithm :: forall syntax fields1 fields2 m result
-             .  (Diffable syntax, Eq1 syntax, GAlign syntax, Traversable syntax, Alternative m, Monad m)
+runAlgorithm :: (Diffable syntax, Eq1 syntax, Traversable syntax, Alternative m, Monad m)
              => Algorithm
-               (Term syntax (Record (FeatureVector ': fields1)))
-               (Term syntax (Record (FeatureVector ': fields2)))
-               (Diff syntax (Record (FeatureVector ': fields1)) (Record (FeatureVector ': fields2)))
-               result
+                  (Term syntax (Record (FeatureVector ': fields1)))
+                  (Term syntax (Record (FeatureVector ': fields2)))
+                  (Diff syntax (Record (FeatureVector ': fields1)) (Record (FeatureVector ': fields2)))
+                  result
              -> m result
 runAlgorithm = iterFreerA (\ yield step -> case step of
   Diffing.Algorithm.Diff t1 t2 -> runAlgorithm (algorithmForTerms t1 t2) <|> pure (replacing t1 t2) >>= yield
-  Linear (Term (In ann1 f1)) (Term (In ann2 f2)) -> merge (ann1, ann2) <$> galignWith (runAlgorithm . diffThese) f1 f2 >>= yield
+  Linear (Term (In ann1 f1)) (Term (In ann2 f2)) -> merge (ann1, ann2) <$> tryAlignWith (runAlgorithm . diffThese) f1 f2 >>= yield
   RWS as bs -> traverse (runAlgorithm . diffThese) (rws comparableTerms equivalentTerms as bs) >>= yield
   Delete a -> yield (deleting a)
   Insert b -> yield (inserting b)

src/Language/Go/Syntax.hs

@@ -5,6 +5,7 @@ import           Data.Abstract.Evaluatable
 import           Data.Abstract.Module
 import qualified Data.Abstract.Package as Package
 import           Data.Abstract.Path
+import           Data.Aeson
 import qualified Data.ByteString as B
 import qualified Data.ByteString.Char8 as BC
 import           Data.JSON.Fields
@@ -13,10 +14,10 @@ import           Prologue
 import           System.FilePath.Posix
 
 data Relative = Relative | NonRelative
-  deriving (Eq, Generic, Hashable, Ord, Show)
+  deriving (Eq, Generic, Hashable, Ord, Show, ToJSON)
 
 data ImportPath = ImportPath { unPath :: FilePath, pathIsRelative :: Relative }
-  deriving (Eq, Generic, Hashable, Ord, Show)
+  deriving (Eq, Generic, Hashable, Ord, Show, ToJSON)
 
 importPath :: ByteString -> ImportPath
 importPath str = let path = stripQuotes str in ImportPath (BC.unpack path) (pathType path)
@@ -28,14 +29,14 @@ importPath str = let path = stripQuotes str in ImportPath (BC.unpack path) (path
 defaultAlias :: ImportPath -> Name
 defaultAlias = name . BC.pack . takeFileName . unPath
 
-resolveGoImport :: Members '[ Modules location value
-                            , Reader ModuleInfo
-                            , Reader Package.PackageInfo
-                            , Resumable ResolutionError
-                            , Trace
-                            ] effects
+resolveGoImport :: ( Member (Modules address value) effects
+                   , Member (Reader ModuleInfo) effects
+                   , Member (Reader Package.PackageInfo) effects
+                   , Member (Resumable ResolutionError) effects
+                   , Member Trace effects
+                   )
                 => ImportPath
-                -> Evaluator location value effects [ModulePath]
+                -> Evaluator address value effects [ModulePath]
 resolveGoImport (ImportPath path Relative) = do
   ModuleInfo{..} <- currentModule
   paths <- listModulesInDir (joinPaths (takeDirectory modulePath) path)
@@ -56,7 +57,7 @@ resolveGoImport (ImportPath path NonRelative) = do
 --
 -- If the list of symbols is empty copy everything to the calling environment.
 data Import a = Import { importFrom :: ImportPath, importWildcardToken :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Import where liftEq = genericLiftEq
 instance Ord1 Import where liftCompare = genericLiftCompare
@@ -70,7 +71,7 @@ instance Evaluatable Import where
     for_ paths $ \path -> do
       traceResolve (unPath importPath) path
       importedEnv <- maybe emptyEnv fst <$> isolate (require path)
-      modifyEnv (mergeEnvs importedEnv)
+      bindAll importedEnv
     rvalBox unit
 
 
@@ -78,7 +79,7 @@ instance Evaluatable Import where
 --
 -- If the list of symbols is empty copy and qualify everything to the calling environment.
 data QualifiedImport a = QualifiedImport { qualifiedImportFrom :: !ImportPath, qualifiedImportAlias :: !a}
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 QualifiedImport where liftEq = genericLiftEq
 instance Ord1 QualifiedImport where liftCompare = genericLiftCompare
@@ -94,13 +95,13 @@ instance Evaluatable QualifiedImport where
       for_ paths $ \p -> do
         traceResolve (unPath importPath) p
         importedEnv <- maybe emptyEnv fst <$> isolate (require p)
-        modifyEnv (mergeEnvs importedEnv)
+        bindAll importedEnv
       makeNamespace alias addr Nothing
     rvalBox unit
 
 -- | Side effect only imports (no symbols made available to the calling environment).
 data SideEffectImport a = SideEffectImport { sideEffectImportFrom :: !ImportPath, sideEffectImportToken :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 SideEffectImport where liftEq = genericLiftEq
 instance Ord1 SideEffectImport where liftCompare = genericLiftCompare
@@ -117,7 +118,7 @@ instance Evaluatable SideEffectImport where
 
 -- A composite literal in Go
 data Composite a = Composite { compositeType :: !a, compositeElement :: !a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 Composite where liftEq = genericLiftEq
 instance Ord1 Composite where liftCompare = genericLiftCompare
@@ -130,7 +131,7 @@ instance Evaluatable Composite
 
 -- | A default pattern in a Go select or switch statement (e.g. `switch { default: s() }`).
 newtype DefaultPattern a = DefaultPattern { defaultPatternBody :: a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 DefaultPattern where liftEq = genericLiftEq
 instance Ord1 DefaultPattern where liftCompare = genericLiftCompare
@@ -143,7 +144,7 @@ instance Evaluatable DefaultPattern
 
 -- | A defer statement in Go (e.g. `defer x()`).
 newtype Defer a = Defer { deferBody :: a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 Defer where liftEq = genericLiftEq
 instance Ord1 Defer where liftCompare = genericLiftCompare
@@ -156,7 +157,7 @@ instance Evaluatable Defer
 
 -- | A go statement (i.e. go routine) in Go (e.g. `go x()`).
 newtype Go a = Go { goBody :: a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 Go where liftEq = genericLiftEq
 instance Ord1 Go where liftCompare = genericLiftCompare
@@ -169,7 +170,7 @@ instance Evaluatable Go
 
 -- | A label statement in Go (e.g. `label:continue`).
 data Label a = Label { _labelName :: !a, labelStatement :: !a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 Label where liftEq = genericLiftEq
 instance Ord1 Label where liftCompare = genericLiftCompare
@@ -182,7 +183,7 @@ instance Evaluatable Label
 
 -- | A rune literal in Go (e.g. `'⌘'`).
 newtype Rune a = Rune { _runeLiteral :: ByteString }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Rune
 
@@ -195,7 +196,7 @@ instance Show1 Rune where liftShowsPrec = genericLiftShowsPrec
 
 -- | A select statement in Go (e.g. `select { case x := <-c: x() }` where each case is a send or receive operation on channels).
 newtype Select a = Select { selectCases :: a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Select
 
@@ -208,7 +209,7 @@ instance Show1 Select where liftShowsPrec = genericLiftShowsPrec
 
 -- | A send statement in Go (e.g. `channel <- value`).
 data Send a = Send { sendReceiver :: !a, sendValue :: !a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 Send where liftEq = genericLiftEq
 instance Ord1 Send where liftCompare = genericLiftCompare
@@ -221,7 +222,7 @@ instance Evaluatable Send
 
 -- | A slice expression in Go (e.g. `a[1:4:3]` where a is a list, 1 is the low bound, 4 is the high bound, and 3 is the max capacity).
 data Slice a = Slice { sliceName :: !a, sliceLow :: !a, sliceHigh :: !a, sliceCapacity :: !a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 Slice where liftEq = genericLiftEq
 instance Ord1 Slice where liftCompare = genericLiftCompare
@@ -234,7 +235,7 @@ instance Evaluatable Slice
 
 -- | A type switch statement in Go (e.g. `switch x.(type) { // cases }`).
 data TypeSwitch a = TypeSwitch { typeSwitchSubject :: !a, typeSwitchCases :: !a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 TypeSwitch where liftEq = genericLiftEq
 instance Ord1 TypeSwitch where liftCompare = genericLiftCompare
@@ -247,7 +248,7 @@ instance Evaluatable TypeSwitch
 
 -- | A type switch guard statement in a Go type switch statement (e.g. `switch i := x.(type) { // cases}`).
 newtype TypeSwitchGuard a = TypeSwitchGuard { typeSwitchGuardSubject :: a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 TypeSwitchGuard where liftEq = genericLiftEq
 instance Ord1 TypeSwitchGuard where liftCompare = genericLiftCompare
@@ -260,7 +261,7 @@ instance Evaluatable TypeSwitchGuard
 
 -- | A receive statement in a Go select statement (e.g. `case value := <-channel` )
 data Receive a = Receive { receiveSubject :: !a, receiveExpression :: !a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 Receive where liftEq = genericLiftEq
 instance Ord1 Receive where liftCompare = genericLiftCompare
@@ -273,7 +274,7 @@ instance Evaluatable Receive
 
 -- | A receive operator unary expression in Go (e.g. `<-channel` )
 newtype ReceiveOperator a = ReceiveOperator a
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 ReceiveOperator where liftEq = genericLiftEq
 instance Ord1 ReceiveOperator where liftCompare = genericLiftCompare
@@ -286,7 +287,7 @@ instance Evaluatable ReceiveOperator
 
 -- | A field declaration in a Go struct type declaration.
 data Field a = Field { fieldContext :: ![a], fieldName :: !a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 Field where liftEq = genericLiftEq
 instance Ord1 Field where liftCompare = genericLiftCompare
@@ -299,7 +300,7 @@ instance Evaluatable Field
 
 
 data Package a = Package { packageName :: !a, packageContents :: ![a] }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 Package where liftEq = genericLiftEq
 instance Ord1 Package where liftCompare = genericLiftCompare
@@ -313,7 +314,7 @@ instance Evaluatable Package where
 
 -- | A type assertion in Go (e.g. `x.(T)` where the value of `x` is not nil and is of type `T`).
 data TypeAssertion a = TypeAssertion { typeAssertionSubject :: !a, typeAssertionType :: !a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 TypeAssertion where liftEq = genericLiftEq
 instance Ord1 TypeAssertion where liftCompare = genericLiftCompare
@@ -326,7 +327,7 @@ instance Evaluatable TypeAssertion
 
 -- | A type conversion expression in Go (e.g. `T(x)` where `T` is a type and `x` is an expression that can be converted to type `T`).
 data TypeConversion a = TypeConversion { typeConversionType :: !a, typeConversionSubject :: !a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 TypeConversion where liftEq = genericLiftEq
 instance Ord1 TypeConversion where liftCompare = genericLiftCompare
@@ -339,7 +340,7 @@ instance Evaluatable TypeConversion
 
 -- | Variadic arguments and parameters in Go (e.g. parameter: `param ...Type`, argument: `Type...`).
 data Variadic a = Variadic { variadicContext :: [a], variadicIdentifier :: a }
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 Variadic where liftEq = genericLiftEq
 instance Ord1 Variadic where liftCompare = genericLiftCompare

src/Language/Go/Type.hs

@@ -8,7 +8,7 @@ import Diffing.Algorithm
 
 -- | A Bidirectional channel in Go (e.g. `chan`).
 newtype BidirectionalChannel a = BidirectionalChannel a
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 BidirectionalChannel where liftEq = genericLiftEq
 instance Ord1 BidirectionalChannel where liftCompare = genericLiftCompare
@@ -21,7 +21,7 @@ instance Evaluatable BidirectionalChannel
 
 -- | A Receive channel in Go (e.g. `<-chan`).
 newtype ReceiveChannel a = ReceiveChannel a
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 ReceiveChannel where liftEq = genericLiftEq
 instance Ord1 ReceiveChannel where liftCompare = genericLiftCompare
@@ -34,7 +34,7 @@ instance Evaluatable ReceiveChannel
 
 -- | A Send channel in Go (e.g. `chan<-`).
 newtype SendChannel a = SendChannel a
-  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, FreeVariables1, Declarations1, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 SendChannel where liftEq = genericLiftEq
 instance Ord1 SendChannel where liftCompare = genericLiftCompare

src/Language/Haskell/Syntax.hs

@@ -11,7 +11,7 @@ data Module a = Module { moduleIdentifier :: !a
                        , moduleExports    :: ![a]
                        , moduleStatements :: !a
                        }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Module where liftEq = genericLiftEq
 instance Ord1 Module where liftCompare = genericLiftCompare

src/Language/Markdown/Syntax.hs

@@ -7,7 +7,7 @@ import Data.JSON.Fields
 import Diffing.Algorithm
 
 newtype Document a = Document [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Document
 
@@ -19,7 +19,7 @@ instance Show1 Document where liftShowsPrec = genericLiftShowsPrec
 -- Block elements
 
 newtype Paragraph a = Paragraph [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Paragraph
 
@@ -28,7 +28,7 @@ instance Ord1 Paragraph where liftCompare = genericLiftCompare
 instance Show1 Paragraph where liftShowsPrec = genericLiftShowsPrec
 
 data Heading a = Heading { headingLevel :: Int, headingContent :: [a], sectionContent :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Heading
 
@@ -37,7 +37,7 @@ instance Ord1 Heading where liftCompare = genericLiftCompare
 instance Show1 Heading where liftShowsPrec = genericLiftShowsPrec
 
 newtype UnorderedList a = UnorderedList [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 UnorderedList
 
@@ -48,7 +48,7 @@ instance Show1 UnorderedList where liftShowsPrec = genericLiftShowsPrec
 instance ToJSONFields1 OrderedList
 
 newtype OrderedList a = OrderedList [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 OrderedList where liftEq = genericLiftEq
 instance Ord1 OrderedList where liftCompare = genericLiftCompare
@@ -57,7 +57,7 @@ instance Show1 OrderedList where liftShowsPrec = genericLiftShowsPrec
 instance ToJSONFields1 BlockQuote
 
 newtype BlockQuote a = BlockQuote [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 BlockQuote where liftEq = genericLiftEq
 instance Ord1 BlockQuote where liftCompare = genericLiftCompare
@@ -66,7 +66,7 @@ instance Show1 BlockQuote where liftShowsPrec = genericLiftShowsPrec
 instance ToJSONFields1 ThematicBreak
 
 data ThematicBreak a = ThematicBreak
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 ThematicBreak where liftEq = genericLiftEq
 instance Ord1 ThematicBreak where liftCompare = genericLiftCompare
@@ -76,14 +76,14 @@ instance ToJSONFields1 HTMLBlock where
   toJSONFields1 (HTMLBlock b) = noChildren [ "asString" .= unpack b ]
 
 newtype HTMLBlock a = HTMLBlock ByteString
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 HTMLBlock where liftEq = genericLiftEq
 instance Ord1 HTMLBlock where liftCompare = genericLiftCompare
 instance Show1 HTMLBlock where liftShowsPrec = genericLiftShowsPrec
 
 newtype Table a = Table [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Table
 
@@ -92,7 +92,7 @@ instance Ord1 Table where liftCompare = genericLiftCompare
 instance Show1 Table where liftShowsPrec = genericLiftShowsPrec
 
 newtype TableRow a = TableRow [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 TableRow
 
@@ -101,7 +101,7 @@ instance Ord1 TableRow where liftCompare = genericLiftCompare
 instance Show1 TableRow where liftShowsPrec = genericLiftShowsPrec
 
 newtype TableCell a = TableCell [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 TableCell
 
@@ -113,7 +113,7 @@ instance Show1 TableCell where liftShowsPrec = genericLiftShowsPrec
 -- Inline elements
 
 newtype Strong a = Strong [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Strong
 
@@ -122,7 +122,7 @@ instance Ord1 Strong where liftCompare = genericLiftCompare
 instance Show1 Strong where liftShowsPrec = genericLiftShowsPrec
 
 newtype Emphasis a = Emphasis [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Emphasis
 
@@ -131,7 +131,7 @@ instance Ord1 Emphasis where liftCompare = genericLiftCompare
 instance Show1 Emphasis where liftShowsPrec = genericLiftShowsPrec
 
 newtype Text a = Text ByteString
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Text where
   toJSONFields1 (Text s) = noChildren ["asString" .= unpack s ]
@@ -141,7 +141,7 @@ instance Ord1 Text where liftCompare = genericLiftCompare
 instance Show1 Text where liftShowsPrec = genericLiftShowsPrec
 
 data Link a = Link { linkURL :: ByteString, linkTitle :: Maybe ByteString }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 -- TODO: Better ToJSONFields1 instance
 instance ToJSONFields1 Link
@@ -151,7 +151,7 @@ instance Ord1 Link where liftCompare = genericLiftCompare
 instance Show1 Link where liftShowsPrec = genericLiftShowsPrec
 
 data Image a = Image { imageURL :: ByteString, imageTitle :: Maybe ByteString }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 -- TODO: Better ToJSONFields1 instance
 instance ToJSONFields1 Image
@@ -161,7 +161,7 @@ instance Ord1 Image where liftCompare = genericLiftCompare
 instance Show1 Image where liftShowsPrec = genericLiftShowsPrec
 
 data Code a = Code { codeLanguage :: Maybe ByteString, codeContent :: ByteString }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 -- TODO: Better ToJSONFields1 instance
 instance ToJSONFields1 Code
@@ -171,7 +171,7 @@ instance Ord1 Code where liftCompare = genericLiftCompare
 instance Show1 Code where liftShowsPrec = genericLiftShowsPrec
 
 data LineBreak a = LineBreak
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 LineBreak
 
@@ -182,7 +182,7 @@ instance Show1 LineBreak where liftShowsPrec = genericLiftShowsPrec
 instance ToJSONFields1 Strikethrough
 
 newtype Strikethrough a = Strikethrough [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 Strikethrough where liftEq = genericLiftEq
 instance Ord1 Strikethrough where liftCompare = genericLiftCompare

src/Language/PHP/Syntax.hs

@@ -1,7 +1,6 @@
 {-# LANGUAGE DeriveAnyClass, ViewPatterns #-}
 module Language.PHP.Syntax where
 
-import           Data.Abstract.Address
 import           Data.Abstract.Evaluatable
 import           Data.Abstract.Module
 import           Data.Abstract.Path
@@ -14,7 +13,7 @@ import           Prelude hiding (fail)
 import           Prologue hiding (Text)
 
 newtype Text a = Text ByteString
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Text where
   toJSONFields1 (Text t) = noChildren ["asString" .= BC.unpack t]
@@ -26,7 +25,7 @@ instance Evaluatable Text
 
 
 newtype VariableName a = VariableName a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 VariableName
 
@@ -43,44 +42,43 @@ instance Evaluatable VariableName
 -- file, the complete contents of the included file are treated as though it
 -- were defined inside that function.
 
-resolvePHPName :: Members '[ Modules location value
-                           , Resumable ResolutionError
-                           ] effects
+resolvePHPName :: ( Member (Modules address value) effects
+                  , Member (Resumable ResolutionError) effects
+                  )
                => ByteString
-               -> Evaluator location value effects ModulePath
+               -> Evaluator address value effects ModulePath
 resolvePHPName n = do
   modulePath <- resolve [name]
   maybe (throwResumable $ NotFoundError name [name] Language.PHP) pure modulePath
   where name = toName n
         toName = BC.unpack . dropRelativePrefix . stripQuotes
 
-include :: ( AbstractValue location value effects
-           , Members '[ Allocator location value
-                      , Modules location value
-                      , Reader (Environment location)
-                      , Resumable ResolutionError
-                      , Resumable (EnvironmentError location)
-                      , State (Environment location)
-                      , State (Exports location)
-                      , State (Heap location (Cell location) value)
-                      , Trace
-                      ] effects
-           , Ord location
-           , Reducer value (Cell location value)
+include :: ( AbstractValue address value effects
+           , Member (Allocator address value) effects
+           , Member (Modules address value) effects
+           , Member (Reader (Environment address)) effects
+           , Member (Resumable ResolutionError) effects
+           , Member (Resumable (EnvironmentError address)) effects
+           , Member (State (Environment address)) effects
+           , Member (State (Exports address)) effects
+           , Member (State (Heap address (Cell address) value)) effects
+           , Member Trace effects
+           , Ord address
+           , Reducer value (Cell address value)
            )
-        => Subterm term (Evaluator location value effects (ValueRef location value))
-        -> (ModulePath -> Evaluator location value effects (Maybe (Environment location, Address location value)))
-        -> Evaluator location value effects (ValueRef location value)
+        => Subterm term (Evaluator address value effects (ValueRef address value))
+        -> (ModulePath -> Evaluator address value effects (Maybe (Environment address, address)))
+        -> Evaluator address value effects (ValueRef address value)
 include pathTerm f = do
   name <- subtermValue pathTerm >>= asString
   path <- resolvePHPName name
   traceResolve name path
-  (importedEnv, v) <- isolate (f path) >>= maybeM ((,) emptyEnv <$> (box unit))
-  modifyEnv (mergeEnvs importedEnv)
+  (importedEnv, v) <- isolate (f path) >>= maybeM ((,) emptyEnv <$> box unit)
+  bindAll importedEnv
   pure (Rval v)
 
 newtype Require a = Require a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 Require where liftEq          = genericLiftEq
 instance Ord1 Require where liftCompare    = genericLiftCompare
@@ -93,7 +91,7 @@ instance Evaluatable Require where
 
 
 newtype RequireOnce a = RequireOnce a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 RequireOnce where liftEq = genericLiftEq
 instance Ord1 RequireOnce where liftCompare = genericLiftCompare
@@ -106,7 +104,7 @@ instance Evaluatable RequireOnce where
 
 
 newtype Include a = Include a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 Include where liftEq          = genericLiftEq
 instance Ord1 Include where liftCompare    = genericLiftCompare
@@ -119,7 +117,7 @@ instance Evaluatable Include where
 
 
 newtype IncludeOnce a = IncludeOnce a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 IncludeOnce where liftEq          = genericLiftEq
 instance Ord1 IncludeOnce where liftCompare    = genericLiftCompare
@@ -132,7 +130,7 @@ instance Evaluatable IncludeOnce where
 
 
 newtype ArrayElement a = ArrayElement a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 ArrayElement
 
@@ -142,7 +140,7 @@ instance Show1 ArrayElement where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ArrayElement
 
 newtype GlobalDeclaration a = GlobalDeclaration [a]
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 GlobalDeclaration
 
@@ -152,7 +150,7 @@ instance Show1 GlobalDeclaration where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable GlobalDeclaration
 
 newtype SimpleVariable a = SimpleVariable a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 SimpleVariable
 
@@ -164,7 +162,7 @@ instance Evaluatable SimpleVariable
 
 -- | TODO: Unify with TypeScript's PredefinedType
 newtype CastType a = CastType { _castType :: ByteString }
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 CastType
 
@@ -174,7 +172,7 @@ instance Show1 CastType where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable CastType
 
 newtype ErrorControl a = ErrorControl a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 ErrorControl
 
@@ -184,7 +182,7 @@ instance Show1 ErrorControl where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ErrorControl
 
 newtype Clone a = Clone a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Clone
 
@@ -194,7 +192,7 @@ instance Show1 Clone where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Clone
 
 newtype ShellCommand a = ShellCommand ByteString
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 ShellCommand
 
@@ -205,7 +203,7 @@ instance Evaluatable ShellCommand
 
 -- | TODO: Combine with TypeScript update expression.
 newtype Update a = Update { _updateSubject :: a }
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Update
 
@@ -215,7 +213,7 @@ instance Show1 Update where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Update
 
 newtype NewVariable a = NewVariable [a]
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 NewVariable
 
@@ -225,7 +223,7 @@ instance Show1 NewVariable where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable NewVariable
 
 newtype RelativeScope a = RelativeScope ByteString
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 RelativeScope
 
@@ -235,7 +233,7 @@ instance Show1 RelativeScope where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable RelativeScope
 
 data QualifiedName a = QualifiedName !a !a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 QualifiedName
 
@@ -247,7 +245,7 @@ instance Evaluatable QualifiedName where
   eval (fmap subtermValue -> QualifiedName name iden) = Rval <$> evaluateInScopedEnv name (box =<< iden)
 
 newtype NamespaceName a = NamespaceName (NonEmpty a)
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 NamespaceName
 
@@ -260,7 +258,7 @@ instance Evaluatable NamespaceName where
   eval (NamespaceName xs) = rvalBox =<< foldl1 (\ l r -> r >>= (evaluateInScopedEnv l . box) >>= deref) (fmap subtermValue xs)
 
 newtype ConstDeclaration a = ConstDeclaration [a]
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 ConstDeclaration
 
@@ -270,7 +268,7 @@ instance Show1 ConstDeclaration where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ConstDeclaration
 
 data ClassConstDeclaration a = ClassConstDeclaration a [a]
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 ClassConstDeclaration
 
@@ -280,7 +278,7 @@ instance Show1 ClassConstDeclaration where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ClassConstDeclaration
 
 newtype ClassInterfaceClause a = ClassInterfaceClause [a]
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 ClassInterfaceClause
 
@@ -290,7 +288,7 @@ instance Show1 ClassInterfaceClause where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ClassInterfaceClause
 
 newtype ClassBaseClause a = ClassBaseClause a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 ClassBaseClause
 
@@ -301,7 +299,7 @@ instance Evaluatable ClassBaseClause
 
 
 newtype UseClause a = UseClause [a]
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 UseClause
 
@@ -311,7 +309,7 @@ instance Show1 UseClause where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable UseClause
 
 newtype ReturnType a = ReturnType a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 ReturnType
 
@@ -321,7 +319,7 @@ instance Show1 ReturnType where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ReturnType
 
 newtype TypeDeclaration a = TypeDeclaration a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 TypeDeclaration
 
@@ -331,7 +329,7 @@ instance Show1 TypeDeclaration where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable TypeDeclaration
 
 newtype BaseTypeDeclaration a = BaseTypeDeclaration a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 BaseTypeDeclaration
 
@@ -341,7 +339,7 @@ instance Show1 BaseTypeDeclaration where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable BaseTypeDeclaration
 
 newtype ScalarType a = ScalarType ByteString
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 ScalarType
 
@@ -351,7 +349,7 @@ instance Show1 ScalarType where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ScalarType
 
 newtype EmptyIntrinsic a = EmptyIntrinsic a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 EmptyIntrinsic
 
@@ -361,7 +359,7 @@ instance Show1 EmptyIntrinsic where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable EmptyIntrinsic
 
 newtype ExitIntrinsic a = ExitIntrinsic a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 ExitIntrinsic
 
@@ -371,7 +369,7 @@ instance Show1 ExitIntrinsic where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ExitIntrinsic
 
 newtype IssetIntrinsic a = IssetIntrinsic a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 IssetIntrinsic
 
@@ -381,7 +379,7 @@ instance Show1 IssetIntrinsic where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable IssetIntrinsic
 
 newtype EvalIntrinsic a = EvalIntrinsic a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 EvalIntrinsic
 
@@ -391,7 +389,7 @@ instance Show1 EvalIntrinsic where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable EvalIntrinsic
 
 newtype PrintIntrinsic a = PrintIntrinsic a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 PrintIntrinsic
 
@@ -401,7 +399,7 @@ instance Show1 PrintIntrinsic where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable PrintIntrinsic
 
 newtype NamespaceAliasingClause a = NamespaceAliasingClause a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 NamespaceAliasingClause
 
@@ -411,7 +409,7 @@ instance Show1 NamespaceAliasingClause where liftShowsPrec = genericLiftShowsPre
 instance Evaluatable NamespaceAliasingClause
 
 newtype NamespaceUseDeclaration a = NamespaceUseDeclaration [a]
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 NamespaceUseDeclaration
 
@@ -421,7 +419,7 @@ instance Show1 NamespaceUseDeclaration where liftShowsPrec = genericLiftShowsPre
 instance Evaluatable NamespaceUseDeclaration
 
 newtype NamespaceUseClause a = NamespaceUseClause [a]
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 NamespaceUseClause
 
@@ -431,7 +429,7 @@ instance Show1 NamespaceUseClause where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable NamespaceUseClause
 
 newtype NamespaceUseGroupClause a = NamespaceUseGroupClause [a]
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 NamespaceUseGroupClause
 
@@ -441,7 +439,7 @@ instance Show1 NamespaceUseGroupClause where liftShowsPrec = genericLiftShowsPre
 instance Evaluatable NamespaceUseGroupClause
 
 data Namespace a = Namespace { namespaceName :: a, namespaceBody :: a }
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance Eq1 Namespace where liftEq = genericLiftEq
 instance Ord1 Namespace where liftCompare = genericLiftCompare
@@ -462,7 +460,7 @@ instance Evaluatable Namespace where
         go xs <* makeNamespace name addr Nothing
 
 data TraitDeclaration a = TraitDeclaration { traitName :: a, traitStatements :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 TraitDeclaration
 
@@ -472,7 +470,7 @@ instance Show1 TraitDeclaration where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable TraitDeclaration
 
 data AliasAs a = AliasAs { aliasAsName  :: a, aliasAsModifier :: a, aliasAsClause :: a }
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 AliasAs
 
@@ -482,7 +480,7 @@ instance Show1 AliasAs where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable AliasAs
 
 data InsteadOf a = InsteadOf a a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 InsteadOf
 
@@ -492,7 +490,7 @@ instance Show1 InsteadOf where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable InsteadOf
 
 newtype TraitUseSpecification a = TraitUseSpecification [a]
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 TraitUseSpecification
 
@@ -502,7 +500,7 @@ instance Show1 TraitUseSpecification where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable TraitUseSpecification
 
 data TraitUseClause a = TraitUseClause [a] a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 TraitUseClause
 
@@ -512,7 +510,7 @@ instance Show1 TraitUseClause where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable TraitUseClause
 
 data DestructorDeclaration a = DestructorDeclaration [a] a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 DestructorDeclaration
 
@@ -522,7 +520,7 @@ instance Show1 DestructorDeclaration where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable DestructorDeclaration
 
 newtype Static a = Static ByteString
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Static
 
@@ -532,7 +530,7 @@ instance Show1 Static where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Static
 
 newtype ClassModifier a = ClassModifier ByteString
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 ClassModifier
 
@@ -542,7 +540,7 @@ instance Show1 ClassModifier where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ClassModifier
 
 data ConstructorDeclaration a = ConstructorDeclaration [a] [a] a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 ConstructorDeclaration
 
@@ -552,7 +550,7 @@ instance Show1 ConstructorDeclaration where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ConstructorDeclaration
 
 data PropertyDeclaration a = PropertyDeclaration a [a]
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 PropertyDeclaration
 
@@ -562,7 +560,7 @@ instance Show1 PropertyDeclaration where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable PropertyDeclaration
 
 data PropertyModifier a = PropertyModifier a a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 PropertyModifier
 
@@ -572,7 +570,7 @@ instance Show1 PropertyModifier where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable PropertyModifier
 
 data InterfaceDeclaration a = InterfaceDeclaration a a [a]
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 InterfaceDeclaration
 
@@ -582,7 +580,7 @@ instance Show1 InterfaceDeclaration where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable InterfaceDeclaration
 
 newtype InterfaceBaseClause a = InterfaceBaseClause [a]
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 InterfaceBaseClause
 
@@ -592,7 +590,7 @@ instance Show1 InterfaceBaseClause where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable InterfaceBaseClause
 
 newtype Echo a = Echo a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Echo
 
@@ -602,7 +600,7 @@ instance Show1 Echo where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Echo
 
 newtype Unset a = Unset a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Unset
 
@@ -612,7 +610,7 @@ instance Show1 Unset where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Unset
 
 data Declare a = Declare a a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 Declare
 
@@ -622,7 +620,7 @@ instance Show1 Declare where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Declare
 
 newtype DeclareDirective a = DeclareDirective a
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 DeclareDirective
 
@@ -632,7 +630,7 @@ instance Show1 DeclareDirective where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable DeclareDirective
 
 newtype LabeledStatement a = LabeledStatement { _labeledStatementIdentifier :: a }
-  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
+  deriving (Diffable, Eq, Foldable, Functor, FreeVariables1, Declarations1, Generic1, Hashable1, Mergeable, Ord, Show, Traversable)
 
 instance ToJSONFields1 LabeledStatement
 

src/Language/Python/Syntax.hs

@@ -4,24 +4,24 @@ module Language.Python.Syntax where
 import           Data.Abstract.Environment as Env
 import           Data.Abstract.Evaluatable
 import           Data.Abstract.Module
-import           Data.Align.Generic
-import qualified Data.ByteString.Char8 as BC
+import           Data.Aeson
 import           Data.Functor.Classes.Generic
 import           Data.JSON.Fields
-import qualified Data.Language as Language
-import qualified Data.List.NonEmpty as NonEmpty
-import qualified Data.Semigroup.Reducer as Reducer
 import           Data.Mergeable
 import           Diffing.Algorithm
 import           GHC.Generics
 import           Prelude hiding (fail)
 import           Prologue
 import           System.FilePath.Posix
+import qualified Data.ByteString.Char8 as BC
+import qualified Data.Language as Language
+import qualified Data.List.NonEmpty as NonEmpty
+import qualified Data.Semigroup.Reducer as Reducer
 
 data QualifiedName
   = QualifiedName (NonEmpty FilePath)
   | RelativeQualifiedName FilePath (Maybe QualifiedName)
-  deriving (Eq, Generic, Hashable, Ord, Show)
+  deriving (Eq, Generic, Hashable, Ord, Show, ToJSON)
 
 qualifiedName :: NonEmpty ByteString -> QualifiedName
 qualifiedName xs = QualifiedName (BC.unpack <$> xs)
@@ -52,13 +52,13 @@ relativeQualifiedName prefix paths = RelativeQualifiedName (BC.unpack prefix) (J
 -- Subsequent imports of `parent.two` or `parent.three` will execute
 --     `parent/two/__init__.py` and
 --     `parent/three/__init__.py` respectively.
-resolvePythonModules :: Members '[ Modules location value
-                                 , Reader ModuleInfo
-                                 , Resumable ResolutionError
-                                 , Trace
-                                 ] effects
+resolvePythonModules :: ( Member (Modules address value) effects
+                        , Member (Reader ModuleInfo) effects
+                        , Member (Resumable ResolutionError) effects
+                        , Member Trace effects
+                        )
                      => QualifiedName
-                     -> Evaluator location value effects (NonEmpty ModulePath)
+                     -> Evaluator address value effects (NonEmpty ModulePath)
 resolvePythonModules q = do
   relRootDir <- rootDir q <$> currentModule
   for (moduleNames q) $ \name -> do
@@ -89,7 +89,7 @@ resolvePythonModules q = do
 --
 -- If the list of symbols is empty copy everything to the calling environment.
 data Import a = Import { importFrom :: QualifiedName, importSymbols :: ![(Name, Name)] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Import
 
@@ -118,7 +118,7 @@ instance Evaluatable Import where
     -- Last module path is the one we want to import
     let path = NonEmpty.last modulePaths
     importedEnv <- maybe emptyEnv fst <$> isolate (require path)
-    modifyEnv (mergeEnvs (select importedEnv))
+    bindAll (select importedEnv)
     rvalBox unit
     where
       select importedEnv
@@ -127,25 +127,24 @@ instance Evaluatable Import where
 
 
 -- Evaluate a qualified import
-evalQualifiedImport :: ( AbstractValue location value effects
-                       , Members '[ Allocator location value
-                                  , Modules location value
-                                  , Reader (Environment location)
-                                  , State (Environment location)
-                                  , State (Exports location)
-                                  , State (Heap location (Cell location) value)
-                                  ] effects
-                       , Ord location
-                       , Reducer.Reducer value (Cell location value)
+evalQualifiedImport :: ( AbstractValue address value effects
+                       , Member (Allocator address value) effects
+                       , Member (Modules address value) effects
+                       , Member (Reader (Environment address)) effects
+                       , Member (State (Environment address)) effects
+                       , Member (State (Exports address)) effects
+                       , Member (State (Heap address (Cell address) value)) effects
+                       , Ord address
+                       , Reducer.Reducer value (Cell address value)
                        )
-                    => Name -> ModulePath -> Evaluator location value effects value
+                    => Name -> ModulePath -> Evaluator address value effects value
 evalQualifiedImport name path = letrec' name $ \addr -> do
   importedEnv <- maybe emptyEnv fst <$> isolate (require path)
-  modifyEnv (mergeEnvs importedEnv)
+  bindAll importedEnv
   unit <$ makeNamespace name addr Nothing
 
 newtype QualifiedImport a = QualifiedImport { qualifiedImportFrom :: QualifiedName }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 QualifiedImport
 
@@ -169,7 +168,7 @@ instance Evaluatable QualifiedImport where
         makeNamespace name addr Nothing
 
 data QualifiedAliasedImport a = QualifiedAliasedImport { qualifiedAliasedImportFrom :: QualifiedName, qualifiedAliasedImportAlias :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 QualifiedAliasedImport
 
@@ -190,12 +189,12 @@ instance Evaluatable QualifiedAliasedImport where
     rvalBox =<< letrec' alias (\addr -> do
       let path = NonEmpty.last modulePaths
       importedEnv <- maybe emptyEnv fst <$> isolate (require path)
-      modifyEnv (mergeEnvs importedEnv)
+      bindAll importedEnv
       unit <$ makeNamespace alias addr Nothing)
 
 -- | Ellipsis (used in splice expressions and alternatively can be used as a fill in expression, like `undefined` in Haskell)
 data Ellipsis a = Ellipsis
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Ellipsis where liftEq = genericLiftEq
 instance Ord1 Ellipsis where liftCompare = genericLiftCompare
@@ -208,7 +207,7 @@ instance Evaluatable Ellipsis
 
 
 data Redirect a = Redirect !a !a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Redirect where liftEq = genericLiftEq
 instance Ord1 Redirect where liftCompare = genericLiftCompare

src/Language/Ruby/Syntax.hs

@@ -17,11 +17,11 @@ import           System.FilePath.Posix
 -- TODO: Fully sort out ruby require/load mechanics
 --
 -- require "json"
-resolveRubyName :: Members '[ Modules location value
-                            , Resumable ResolutionError
-                            ] effects
+resolveRubyName :: ( Member (Modules address value) effects
+                   , Member (Resumable ResolutionError) effects
+                   )
                 => ByteString
-                -> Evaluator location value effects M.ModulePath
+                -> Evaluator address value effects M.ModulePath
 resolveRubyName name = do
   let name' = cleanNameOrPath name
   let paths = [name' <.> "rb"]
@@ -29,11 +29,11 @@ resolveRubyName name = do
   maybe (throwResumable $ NotFoundError name' paths Language.Ruby) pure modulePath
 
 -- load "/root/src/file.rb"
-resolveRubyPath :: Members '[ Modules location value
-                            , Resumable ResolutionError
-                            ] effects
+resolveRubyPath :: ( Member (Modules address value) effects
+                   , Member (Resumable ResolutionError) effects
+                   )
                 => ByteString
-                -> Evaluator location value effects M.ModulePath
+                -> Evaluator address value effects M.ModulePath
 resolveRubyPath path = do
   let name' = cleanNameOrPath path
   modulePath <- resolve [name']
@@ -43,7 +43,7 @@ cleanNameOrPath :: ByteString -> String
 cleanNameOrPath = BC.unpack . dropRelativePrefix . stripQuotes
 
 data Send a = Send { sendReceiver :: Maybe a, sendSelector :: Maybe a, sendArgs :: [a], sendBlock :: Maybe a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Send where liftEq = genericLiftEq
 instance Ord1 Send where liftCompare = genericLiftCompare
@@ -60,7 +60,7 @@ instance Evaluatable Send where
     Rval <$> call func (map subtermAddress sendArgs) -- TODO pass through sendBlock
 
 data Require a = Require { requireRelative :: Bool, requirePath :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Require where liftEq = genericLiftEq
 instance Ord1 Require where liftCompare = genericLiftCompare
@@ -74,14 +74,14 @@ instance Evaluatable Require where
     path <- resolveRubyName name
     traceResolve name path
     (importedEnv, v) <- isolate (doRequire path)
-    modifyEnv (`mergeNewer` importedEnv)
+    bindAll importedEnv
     rvalBox v -- Returns True if the file was loaded, False if it was already loaded. http://ruby-doc.org/core-2.5.0/Kernel.html#method-i-require
 
-doRequire :: ( AbstractValue location value effects
-             , Member (Modules location value) effects
+doRequire :: ( AbstractValue address value effects
+             , Member (Modules address value) effects
              )
           => M.ModulePath
-          -> Evaluator location value effects (Environment location, value)
+          -> Evaluator address value effects (Environment address, value)
 doRequire path = do
   result <- join <$> lookupModule path
   case result of
@@ -90,7 +90,7 @@ doRequire path = do
 
 
 newtype Load a = Load { loadArgs :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Load where liftEq = genericLiftEq
 instance Ord1 Load where liftCompare = genericLiftCompare
@@ -108,28 +108,27 @@ instance Evaluatable Load where
     rvalBox =<< doLoad path shouldWrap
   eval (Load _) = raiseEff (fail "invalid argument supplied to load, path is required")
 
-doLoad :: ( AbstractValue location value effects
-          , Members '[ Modules location value
-                     , Resumable ResolutionError
-                     , State (Environment location)
-                     , State (Exports location)
-                     , Trace
-                     ] effects
+doLoad :: ( AbstractValue address value effects
+          , Member (Modules address value) effects
+          , Member (Resumable ResolutionError) effects
+          , Member (State (Environment address)) effects
+          , Member (State (Exports address)) effects
+          , Member Trace effects
           )
        => ByteString
        -> Bool
-       -> Evaluator location value effects value
+       -> Evaluator address value effects value
 doLoad path shouldWrap = do
   path' <- resolveRubyPath path
   traceResolve path path'
   importedEnv <- maybe emptyEnv fst <$> isolate (load path')
-  unless shouldWrap $ modifyEnv (mergeEnvs importedEnv)
+  unless shouldWrap $ bindAll importedEnv
   pure (boolean Prelude.True) -- load always returns true. http://ruby-doc.org/core-2.5.0/Kernel.html#method-i-load
 
 -- TODO: autoload
 
 data Class a = Class { classIdentifier :: !a, classSuperClass :: !(Maybe a), classBody :: !a }
-  deriving (Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Class
 
@@ -148,7 +147,7 @@ instance Evaluatable Class where
       subtermValue classBody <* makeNamespace name addr super)
 
 data Module a = Module { moduleIdentifier :: !a, moduleStatements :: ![a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Module where liftEq = genericLiftEq
 instance Ord1 Module where liftCompare = genericLiftCompare
@@ -165,7 +164,7 @@ instance Evaluatable Module where
 data LowPrecedenceBoolean a
   = LowAnd !a !a
   | LowOr !a !a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 LowPrecedenceBoolean
 

src/Language/TypeScript/Syntax.hs

@@ -6,6 +6,7 @@ import           Data.Abstract.Evaluatable
 import qualified Data.Abstract.Module as M
 import           Data.Abstract.Package
 import           Data.Abstract.Path
+import           Data.Aeson
 import qualified Data.ByteString as B
 import qualified Data.ByteString.Char8 as BC
 import           Data.JSON.Fields
@@ -18,10 +19,10 @@ import           Prologue
 import           System.FilePath.Posix
 
 data Relative = Relative | NonRelative
-  deriving (Eq, Generic, Hashable, Ord, Show)
+  deriving (Eq, Generic, Hashable, Ord, Show, ToJSON)
 
 data ImportPath = ImportPath { unPath :: FilePath, pathIsRelative :: Relative }
-  deriving (Eq, Generic, Hashable, Ord, Show)
+  deriving (Eq, Generic, Hashable, Ord, Show, ToJSON)
 
 importPath :: ByteString -> ImportPath
 importPath str = let path = stripQuotes str in ImportPath (BC.unpack path) (pathType path)
@@ -37,15 +38,15 @@ toName = name . BC.pack . unPath
 --
 -- NB: TypeScript has a couple of different strategies, but the main one (and the
 -- only one we support) mimics Node.js.
-resolveWithNodejsStrategy :: Members '[ Modules location value
-                                      , Reader M.ModuleInfo
-                                      , Reader PackageInfo
-                                      , Resumable ResolutionError
-                                      , Trace
-                                      ] effects
+resolveWithNodejsStrategy :: ( Member (Modules address value) effects
+                             , Member (Reader M.ModuleInfo) effects
+                             , Member (Reader PackageInfo) effects
+                             , Member (Resumable ResolutionError) effects
+                             , Member Trace effects
+                             )
                           => ImportPath
                           -> [String]
-                          -> Evaluator location value effects M.ModulePath
+                          -> Evaluator address value effects M.ModulePath
 resolveWithNodejsStrategy (ImportPath path Relative)    exts = resolveRelativePath path exts
 resolveWithNodejsStrategy (ImportPath path NonRelative) exts = resolveNonRelativePath path exts
 
@@ -56,15 +57,15 @@ resolveWithNodejsStrategy (ImportPath path NonRelative) exts = resolveNonRelativ
 -- /root/src/moduleB.ts
 -- /root/src/moduleB/package.json (if it specifies a "types" property)
 -- /root/src/moduleB/index.ts
-resolveRelativePath :: Members '[ Modules location value
-                                , Reader M.ModuleInfo
-                                , Reader PackageInfo
-                                , Resumable ResolutionError
-                                , Trace
-                                ] effects
+resolveRelativePath :: ( Member (Modules address value) effects
+                       , Member (Reader M.ModuleInfo) effects
+                       , Member (Reader PackageInfo) effects
+                       , Member (Resumable ResolutionError) effects
+                       , Member Trace effects
+                       )
                     => FilePath
                     -> [String]
-                    -> Evaluator location value effects M.ModulePath
+                    -> Evaluator address value effects M.ModulePath
 resolveRelativePath relImportPath exts = do
   M.ModuleInfo{..} <- currentModule
   let relRootDir = takeDirectory modulePath
@@ -84,15 +85,15 @@ resolveRelativePath relImportPath exts = do
 --
 -- /root/node_modules/moduleB.ts, etc
 -- /node_modules/moduleB.ts, etc
-resolveNonRelativePath :: Members '[ Modules location value
-                                   , Reader M.ModuleInfo
-                                   , Reader PackageInfo
-                                   , Resumable ResolutionError
-                                   , Trace
-                                   ] effects
+resolveNonRelativePath :: ( Member (Modules address value) effects
+                          , Member (Reader M.ModuleInfo) effects
+                          , Member (Reader PackageInfo) effects
+                          , Member (Resumable ResolutionError) effects
+                          , Member Trace effects
+                          )
                        => FilePath
                        -> [String]
-                       -> Evaluator location value effects M.ModulePath
+                       -> Evaluator address value effects M.ModulePath
 resolveNonRelativePath name exts = do
   M.ModuleInfo{..} <- currentModule
   go "." modulePath mempty
@@ -109,13 +110,13 @@ resolveNonRelativePath name exts = do
     notFound xs = throwResumable $ NotFoundError name xs Language.TypeScript
 
 -- | Resolve a module name to a ModulePath.
-resolveModule :: Members '[ Modules location value
-                          , Reader PackageInfo
-                          , Trace
-                          ] effects
-                => FilePath -- ^ Module path used as directory to search in
-                -> [String] -- ^ File extensions to look for
-                -> Evaluator location value effects (Either [FilePath] M.ModulePath)
+resolveModule :: ( Member (Modules address value) effects
+                 , Member (Reader PackageInfo) effects
+                 , Member Trace effects
+                 )
+              => FilePath -- ^ Module path used as directory to search in
+              -> [String] -- ^ File extensions to look for
+              -> Evaluator address value effects (Either [FilePath] M.ModulePath)
 resolveModule path' exts = do
   let path = makeRelative "." path'
   PackageInfo{..} <- currentPackage
@@ -132,28 +133,26 @@ typescriptExtensions = ["ts", "tsx", "d.ts"]
 javascriptExtensions :: [String]
 javascriptExtensions = ["js"]
 
-evalRequire :: ( AbstractValue location value effects
-               , Members '[ Allocator location value
-                          , Modules location value
-                          , Reader (Environment location)
-                          , State (Environment location)
-                          , State (Exports location)
-                          , State (Heap location (Cell location) value)
-                          , Trace
-                          ] effects
-               , Ord location
-               , Reducer value (Cell location value)
+evalRequire :: ( AbstractValue address value effects
+               , Member (Allocator address value) effects
+               , Member (Modules address value) effects
+               , Member (Reader (Environment address)) effects
+               , Member (State (Environment address)) effects
+               , Member (State (Exports address)) effects
+               , Member (State (Heap address (Cell address) value)) effects
+               , Ord address
+               , Reducer value (Cell address value)
                )
             => M.ModulePath
             -> Name
-            -> Evaluator location value effects value
+            -> Evaluator address value effects value
 evalRequire modulePath alias = letrec' alias $ \addr -> do
   importedEnv <- maybe emptyEnv fst <$> isolate (require modulePath)
-  modifyEnv (mergeEnvs importedEnv)
+  bindAll importedEnv
   unit <$ makeNamespace alias addr Nothing
 
 data Import a = Import { importSymbols :: ![(Name, Name)], importFrom :: ImportPath }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Import
 
@@ -166,14 +165,14 @@ instance Evaluatable Import where
   eval (Import symbols importPath) = do
     modulePath <- resolveWithNodejsStrategy importPath typescriptExtensions
     importedEnv <- maybe emptyEnv fst <$> isolate (require modulePath)
-    modifyEnv (mergeEnvs (renamed importedEnv)) *> rvalBox unit
+    bindAll (renamed importedEnv) *> rvalBox unit
     where
       renamed importedEnv
         | Prologue.null symbols = importedEnv
         | otherwise = Env.overwrite symbols importedEnv
 
 data JavaScriptRequire a = JavaScriptRequire { javascriptRequireIden :: !a, javascriptRequireFrom :: ImportPath }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 JavaScriptRequire where liftEq = genericLiftEq
 instance Ord1 JavaScriptRequire where liftCompare = genericLiftCompare
@@ -189,7 +188,7 @@ instance Evaluatable JavaScriptRequire where
 
 
 data QualifiedAliasedImport a = QualifiedAliasedImport { qualifiedAliasedImportAlias :: !a, qualifiedAliasedImportFrom :: ImportPath }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 QualifiedAliasedImport where liftEq = genericLiftEq
 instance Ord1 QualifiedAliasedImport where liftCompare = genericLiftCompare
@@ -204,7 +203,7 @@ instance Evaluatable QualifiedAliasedImport where
     rvalBox =<< evalRequire modulePath alias
 
 newtype SideEffectImport a = SideEffectImport { sideEffectImportFrom :: ImportPath }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 SideEffectImport where liftEq = genericLiftEq
 instance Ord1 SideEffectImport where liftCompare = genericLiftCompare
@@ -221,7 +220,7 @@ instance Evaluatable SideEffectImport where
 
 -- | Qualified Export declarations
 newtype QualifiedExport a = QualifiedExport { qualifiedExportSymbols :: [(Name, Name)] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 QualifiedExport where liftEq = genericLiftEq
 instance Ord1 QualifiedExport where liftCompare = genericLiftCompare
@@ -239,7 +238,7 @@ instance Evaluatable QualifiedExport where
 
 -- | Qualified Export declarations that export from another module.
 data QualifiedExportFrom a = QualifiedExportFrom { qualifiedExportFrom :: ImportPath, qualifiedExportFromSymbols :: ![(Name, Name)]}
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 QualifiedExportFrom where liftEq = genericLiftEq
 instance Ord1 QualifiedExportFrom where liftCompare = genericLiftCompare
@@ -258,7 +257,7 @@ instance Evaluatable QualifiedExportFrom where
     rvalBox unit
 
 newtype DefaultExport a = DefaultExport { defaultExport :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 DefaultExport
 
@@ -274,14 +273,14 @@ instance Evaluatable DefaultExport where
         addr <- lookupOrAlloc name
         assign addr v
         addExport name name Nothing
-        void $ modifyEnv (Env.insert name addr)
+        void $ bind name addr
       Nothing -> throwEvalError DefaultExportError
     rvalBox unit
 
 
 -- | Lookup type for a type-level key in a typescript map.
 data LookupType a = LookupType { lookupTypeIdentifier :: a, lookupTypeKey :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 LookupType
 
@@ -292,7 +291,7 @@ instance Evaluatable LookupType
 
 -- | ShorthandPropertyIdentifier used in object patterns such as var baz = { foo } to mean var baz = { foo: foo }
 newtype ShorthandPropertyIdentifier a = ShorthandPropertyIdentifier ByteString
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ShorthandPropertyIdentifier
 
@@ -302,7 +301,7 @@ instance Show1 ShorthandPropertyIdentifier where liftShowsPrec = genericLiftShow
 instance Evaluatable ShorthandPropertyIdentifier
 
 data Union a = Union { _unionLeft :: !a, _unionRight :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Language.TypeScript.Syntax.Union
 
@@ -312,7 +311,7 @@ instance Show1 Language.TypeScript.Syntax.Union where liftShowsPrec = genericLif
 instance Evaluatable Language.TypeScript.Syntax.Union
 
 data Intersection a = Intersection { _intersectionLeft :: !a, _intersectionRight :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Intersection
 
@@ -322,7 +321,7 @@ instance Show1 Intersection where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Intersection
 
 data FunctionType a = FunctionType { _functionTypeParameters :: !a, _functionFormalParameters :: ![a], _functionType :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 FunctionType
 
@@ -332,7 +331,7 @@ instance Show1 FunctionType where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable FunctionType
 
 data AmbientFunction a = AmbientFunction { _ambientFunctionContext :: ![a], _ambientFunctionIdentifier :: !a, _ambientFunctionParameters :: ![a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 AmbientFunction
 
@@ -342,7 +341,7 @@ instance Show1 AmbientFunction where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable AmbientFunction
 
 data ImportRequireClause a = ImportRequireClause { _importRequireIdentifier :: !a, _importRequireSubject :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ImportRequireClause
 
@@ -352,7 +351,7 @@ instance Show1 ImportRequireClause where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ImportRequireClause
 
 newtype ImportClause a = ImportClause { _importClauseElements :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ImportClause
 
@@ -362,7 +361,7 @@ instance Show1 ImportClause where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ImportClause
 
 newtype Tuple a = Tuple { _tupleElements :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Tuple
 
@@ -374,7 +373,7 @@ instance Show1 Tuple where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Tuple
 
 data Constructor a = Constructor { _constructorTypeParameters :: !a, _constructorFormalParameters :: ![a], _constructorType :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Language.TypeScript.Syntax.Constructor
 
@@ -384,7 +383,7 @@ instance Show1 Language.TypeScript.Syntax.Constructor where liftShowsPrec = gene
 instance Evaluatable Language.TypeScript.Syntax.Constructor
 
 data TypeParameter a = TypeParameter { _typeParameter :: !a, _typeParameterConstraint :: !a, _typeParameterDefaultType :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 TypeParameter
 
@@ -394,7 +393,7 @@ instance Show1 TypeParameter where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable TypeParameter
 
 data TypeAssertion a = TypeAssertion { _typeAssertionParameters :: !a, _typeAssertionExpression :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 TypeAssertion
 
@@ -404,7 +403,7 @@ instance Show1 TypeAssertion where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable TypeAssertion
 
 newtype Annotation a = Annotation { _annotationType :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Annotation
 
@@ -414,7 +413,7 @@ instance Show1 Annotation where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Annotation
 
 newtype Decorator a = Decorator { _decoratorTerm :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Decorator
 
@@ -424,7 +423,7 @@ instance Show1 Decorator where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Decorator
 
 newtype ComputedPropertyName a = ComputedPropertyName a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ComputedPropertyName
 
@@ -434,7 +433,7 @@ instance Show1 ComputedPropertyName where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ComputedPropertyName
 
 newtype Constraint a = Constraint { _constraintType :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Constraint
 
@@ -444,7 +443,7 @@ instance Show1 Constraint where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Constraint
 
 newtype DefaultType a = DefaultType { _defaultType :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 DefaultType
 
@@ -454,7 +453,7 @@ instance Show1 DefaultType where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable DefaultType
 
 newtype ParenthesizedType a = ParenthesizedType { _parenthesizedType :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ParenthesizedType
 
@@ -464,7 +463,7 @@ instance Show1 ParenthesizedType where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ParenthesizedType
 
 newtype PredefinedType a = PredefinedType { _predefinedType :: ByteString }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 PredefinedType
 
@@ -474,7 +473,7 @@ instance Show1 PredefinedType where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable PredefinedType
 
 newtype TypeIdentifier a = TypeIdentifier ByteString
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 TypeIdentifier
 
@@ -484,7 +483,7 @@ instance Show1 TypeIdentifier where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable TypeIdentifier
 
 data NestedIdentifier a = NestedIdentifier !a !a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 NestedIdentifier
 
@@ -494,7 +493,7 @@ instance Show1 NestedIdentifier where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable NestedIdentifier
 
 data NestedTypeIdentifier a = NestedTypeIdentifier !a !a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 NestedTypeIdentifier
 
@@ -504,7 +503,7 @@ instance Show1 NestedTypeIdentifier where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable NestedTypeIdentifier
 
 data GenericType a = GenericType { _genericTypeIdentifier :: !a, _genericTypeArguments :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 GenericType
 
@@ -514,7 +513,7 @@ instance Show1 GenericType where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable GenericType
 
 data TypePredicate a = TypePredicate { _typePredicateIdentifier :: !a, _typePredicateType :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 TypePredicate
 
@@ -524,7 +523,7 @@ instance Show1 TypePredicate where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable TypePredicate
 
 newtype ObjectType a = ObjectType { _objectTypeElements :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ObjectType
 
@@ -534,7 +533,7 @@ instance Show1 ObjectType where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ObjectType
 
 data With a = With { _withExpression :: !a, _withBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 With
 
@@ -544,7 +543,7 @@ instance Show1 With where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable With
 
 newtype AmbientDeclaration a = AmbientDeclaration { _ambientDeclarationBody :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 AmbientDeclaration
 
@@ -556,7 +555,7 @@ instance Evaluatable AmbientDeclaration where
   eval (AmbientDeclaration body) = subtermRef body
 
 data EnumDeclaration a = EnumDeclaration { enumDeclarationIdentifier :: !a, _enumDeclarationBody :: ![a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 EnumDeclaration
 
@@ -569,7 +568,7 @@ instance Declarations a => Declarations (EnumDeclaration a) where
   declaredName EnumDeclaration{..} = declaredName enumDeclarationIdentifier
 
 newtype ExtendsClause a = ExtendsClause { _extendsClauses :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ExtendsClause
 
@@ -579,7 +578,7 @@ instance Show1 ExtendsClause where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ExtendsClause
 
 newtype ArrayType a = ArrayType { _arrayType :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ArrayType
 
@@ -589,7 +588,7 @@ instance Show1 ArrayType where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ArrayType
 
 newtype FlowMaybeType a = FlowMaybeType { _flowMaybeType :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 FlowMaybeType
 
@@ -599,7 +598,7 @@ instance Show1 FlowMaybeType where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable FlowMaybeType
 
 newtype TypeQuery a = TypeQuery { _typeQuerySubject :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 TypeQuery
 
@@ -609,7 +608,7 @@ instance Show1 TypeQuery where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable TypeQuery
 
 newtype IndexTypeQuery a = IndexTypeQuery { _indexTypeQuerySubject :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 IndexTypeQuery
 
@@ -619,7 +618,7 @@ instance Show1 IndexTypeQuery where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable IndexTypeQuery
 
 newtype TypeArguments a = TypeArguments { _typeArguments :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 TypeArguments
 
@@ -629,7 +628,7 @@ instance Show1 TypeArguments where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable TypeArguments
 
 newtype ThisType a = ThisType ByteString
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ThisType
 
@@ -639,7 +638,7 @@ instance Show1 ThisType where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ThisType
 
 newtype ExistentialType a = ExistentialType ByteString
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ExistentialType
 
@@ -649,7 +648,7 @@ instance Show1 ExistentialType where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ExistentialType
 
 newtype LiteralType a = LiteralType { _literalTypeSubject :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 LiteralType
 
@@ -659,7 +658,7 @@ instance Show1 LiteralType where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable LiteralType
 
 data PropertySignature a = PropertySignature { _modifiers :: ![a], _propertySignaturePropertyName :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 PropertySignature
 
@@ -669,7 +668,7 @@ instance Show1 PropertySignature where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable PropertySignature
 
 data CallSignature a = CallSignature { _callSignatureTypeParameters :: !a, _callSignatureParameters :: ![a], _callSignatureType :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 CallSignature
 
@@ -680,7 +679,7 @@ instance Evaluatable CallSignature
 
 -- | Todo: Move type params and type to context
 data ConstructSignature a = ConstructSignature { _constructSignatureTypeParameters :: !a, _constructSignatureParameters :: ![a], _constructSignatureType :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ConstructSignature
 
@@ -690,7 +689,7 @@ instance Show1 ConstructSignature where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ConstructSignature
 
 data IndexSignature a = IndexSignature { _indexSignatureSubject :: a, _indexSignatureType :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 IndexSignature
 
@@ -700,7 +699,7 @@ instance Show1 IndexSignature where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable IndexSignature
 
 data AbstractMethodSignature a = AbstractMethodSignature { _abstractMethodSignatureContext :: ![a], _abstractMethodSignatureName :: !a, _abstractMethodSignatureParameters :: ![a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 AbstractMethodSignature
 
@@ -710,7 +709,7 @@ instance Show1 AbstractMethodSignature where liftShowsPrec = genericLiftShowsPre
 instance Evaluatable AbstractMethodSignature
 
 data Debugger a = Debugger
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Debugger
 
@@ -720,7 +719,7 @@ instance Show1 Debugger where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Debugger
 
 data ForOf a = ForOf { _forOfBinding :: !a, _forOfSubject :: !a, _forOfBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ForOf
 
@@ -730,7 +729,7 @@ instance Show1 ForOf where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ForOf
 
 data This a = This
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 This
 
@@ -740,7 +739,7 @@ instance Show1 This where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable This
 
 data LabeledStatement a = LabeledStatement { _labeledStatementIdentifier :: !a, _labeledStatementSubject :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 LabeledStatement
 
@@ -750,7 +749,7 @@ instance Show1 LabeledStatement where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable LabeledStatement
 
 newtype Update a = Update { _updateSubject :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Update
 
@@ -760,7 +759,7 @@ instance Show1 Update where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Update
 
 data Module a = Module { moduleIdentifier :: !a, moduleStatements :: ![a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 Module where liftEq = genericLiftEq
 instance Ord1 Module where liftCompare = genericLiftCompare
@@ -777,7 +776,7 @@ instance Evaluatable Module where
 
 
 data InternalModule a = InternalModule { internalModuleIdentifier :: !a, internalModuleStatements :: ![a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 InternalModule where liftEq = genericLiftEq
 instance Ord1 InternalModule where liftCompare = genericLiftCompare
@@ -796,7 +795,7 @@ instance Declarations a => Declarations (InternalModule a) where
 
 
 data ImportAlias a = ImportAlias { _importAliasSubject :: !a, _importAlias :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ImportAlias
 
@@ -806,7 +805,7 @@ instance Show1 ImportAlias where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ImportAlias
 
 data Super a = Super
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Super
 
@@ -816,7 +815,7 @@ instance Show1 Super where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Super
 
 data Undefined a = Undefined
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 Undefined
 
@@ -826,7 +825,7 @@ instance Show1 Undefined where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable Undefined
 
 data ClassHeritage a = ClassHeritage { _classHeritageExtendsClause :: !a, _implementsClause :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ClassHeritage
 
@@ -836,7 +835,7 @@ instance Show1 ClassHeritage where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ClassHeritage
 
 data AbstractClass a = AbstractClass { abstractClassIdentifier :: !a,  _abstractClassTypeParameters :: !a, classHeritage :: ![a], classBody :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance Eq1 AbstractClass where liftEq = genericLiftEq
 instance Ord1 AbstractClass where liftCompare = genericLiftCompare
@@ -854,11 +853,11 @@ instance Evaluatable AbstractClass where
       void $ subtermValue classBody
       classEnv <- Env.head <$> getEnv
       klass name supers classEnv
-    rvalBox =<< (v <$ modifyEnv (Env.insert name addr))
+    rvalBox =<< (v <$ bind name addr)
 
 
 data JsxElement a = JsxElement { _jsxOpeningElement :: !a,  _jsxElements :: ![a], _jsxClosingElement :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 JsxElement
 
@@ -868,7 +867,7 @@ instance Show1 JsxElement where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable JsxElement
 
 newtype JsxText a = JsxText ByteString
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 JsxText
 
@@ -878,7 +877,7 @@ instance Show1 JsxText where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable JsxText
 
 newtype JsxExpression a = JsxExpression { _jsxExpression :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 JsxExpression
 
@@ -888,7 +887,7 @@ instance Show1 JsxExpression where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable JsxExpression
 
 data JsxOpeningElement a = JsxOpeningElement { _jsxOpeningElementIdentifier :: !a,  _jsxAttributes :: ![a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 JsxOpeningElement
 
@@ -898,7 +897,7 @@ instance Show1 JsxOpeningElement where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable JsxOpeningElement
 
 newtype JsxClosingElement a = JsxClosingElement { _jsxClosingElementIdentifier :: a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 JsxClosingElement
 
@@ -908,7 +907,7 @@ instance Show1 JsxClosingElement where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable JsxClosingElement
 
 data JsxSelfClosingElement a = JsxSelfClosingElement { _jsxSelfClosingElementIdentifier :: !a, _jsxSelfClosingElementAttributes :: ![a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 JsxSelfClosingElement
 
@@ -918,7 +917,7 @@ instance Show1 JsxSelfClosingElement where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable JsxSelfClosingElement
 
 data JsxAttribute a = JsxAttribute { _jsxAttributeTarget :: !a, _jsxAttributeValue :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 JsxAttribute
 
@@ -928,7 +927,7 @@ instance Show1 JsxAttribute where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable JsxAttribute
 
 newtype ImplementsClause a = ImplementsClause { _implementsClauseTypes :: [a] }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 ImplementsClause
 
@@ -938,7 +937,7 @@ instance Show1 ImplementsClause where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable ImplementsClause
 
 data OptionalParameter a = OptionalParameter { _optionalParameterContext :: ![a], _optionalParameterSubject :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 OptionalParameter
 
@@ -948,7 +947,7 @@ instance Show1 OptionalParameter where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable OptionalParameter
 
 data RequiredParameter a = RequiredParameter { _requiredParameterContext :: ![a], _requiredParameterSubject :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 RequiredParameter
 
@@ -958,7 +957,7 @@ instance Show1 RequiredParameter where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable RequiredParameter
 
 data RestParameter a = RestParameter { _restParameterContext :: ![a], _restParameterSubject :: !a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 RestParameter
 
@@ -968,7 +967,7 @@ instance Show1 RestParameter where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable RestParameter
 
 newtype JsxFragment a = JsxFragment [a]
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 JsxFragment
 
@@ -978,7 +977,7 @@ instance Show1 JsxFragment where liftShowsPrec = genericLiftShowsPrec
 instance Evaluatable JsxFragment
 
 data JsxNamespaceName a = JsxNamespaceName a a
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
+  deriving (Diffable, Eq, Foldable, Functor, Generic1, Hashable1, Mergeable, Ord, Show, Traversable, FreeVariables1, Declarations1)
 
 instance ToJSONFields1 JsxNamespaceName
 

src/Parsing/TreeSitter.hs

@@ -69,7 +69,7 @@ bracket' before after action = do
 
 -- | Parse 'Source' with the given 'TS.Language' and return its AST.
 -- Returns Nothing if the operation timed out.
-parseToAST :: (Bounded grammar, Enum grammar, Members '[Trace, IO] effects) => Timeout -> Ptr TS.Language -> Blob -> Eff effects (Maybe (AST [] grammar))
+parseToAST :: (Bounded grammar, Enum grammar, Member IO effects, Member Trace effects) => Timeout -> Ptr TS.Language -> Blob -> Eff effects (Maybe (AST [] grammar))
 parseToAST (Milliseconds s) language Blob{..} = bracket' TS.ts_parser_new TS.ts_parser_delete $ \ parser -> do
   let parserTimeout = s * 1000
 

src/Prologue.hs

@@ -35,7 +35,6 @@ import Control.Monad as X hiding (fail, return, unless, when)
 import Control.Monad.Except as X (MonadError (..))
 import Control.Monad.Fail as X (MonadFail (..))
 import Data.Algebra as X
-import Data.Align.Generic as X (GAlign)
 import Data.Bifoldable as X
 import Data.Bifunctor as X (Bifunctor (..))
 import Data.Bitraversable as X

src/Rendering/Graph.hs

@@ -28,7 +28,7 @@ runGraph :: Eff '[Fresh, Reader (Graph vertex)] (Graph vertex) -> Graph vertex
 runGraph = run . runReader mempty . runFresh 0
 
 
-termAlgebra :: (ConstructorName syntax, Foldable syntax, Members '[Fresh, Reader (Graph (Vertex tag))] effs)
+termAlgebra :: (ConstructorName syntax, Foldable syntax, Member Fresh effs, Member (Reader (Graph (Vertex tag))) effs)
             => tag
             -> TermF syntax ann (Eff effs (Graph (Vertex tag)))
             -> Eff effs (Graph (Vertex tag))
@@ -63,7 +63,7 @@ data DiffTag = Deleted | Inserted | Merged
 
 
 class ToTreeGraph vertex t | t -> vertex where
-  toTreeGraph :: Members '[Fresh, Reader (Graph vertex)] effs => t (Eff effs (Graph vertex)) -> Eff effs (Graph vertex)
+  toTreeGraph :: (Member Fresh effs, Member (Reader (Graph vertex)) effs) => t (Eff effs (Graph vertex)) -> Eff effs (Graph vertex)
 
 instance (ConstructorName syntax, Foldable syntax) => ToTreeGraph (Vertex ()) (TermF syntax ann) where
   toTreeGraph = termAlgebra ()

src/Rendering/JSON.hs

@@ -52,8 +52,8 @@ data JSONTerm a = JSONTerm { jsonTermBlob :: Blob, jsonTerm :: a }
   deriving (Eq, Show)
 
 instance ToJSON a => ToJSON (JSONTerm a) where
-  toJSON JSONTerm{..} = object ("programNode" .= jsonTerm : toJSONFields jsonTermBlob)
-  toEncoding JSONTerm{..} = pairs (fold ("programNode" .= jsonTerm : toJSONFields jsonTermBlob))
+  toJSON JSONTerm{..} = object ("tree" .= jsonTerm : toJSONFields jsonTermBlob)
+  toEncoding JSONTerm{..} = pairs (fold ("tree" .= jsonTerm : toJSONFields jsonTermBlob))
 
 
 renderJSONAST :: ToJSON a => Blob -> a -> JSON "trees" SomeJSON

src/Semantic/AST.hs

@@ -16,7 +16,7 @@ data SomeAST where
 withSomeAST :: (forall grammar . Show grammar => AST [] grammar -> a) -> SomeAST -> a
 withSomeAST f (SomeAST ast) = f ast
 
-astParseBlob :: Members '[Task, Exc SomeException] effs => Blob -> Eff effs SomeAST
+astParseBlob :: (Member (Exc SomeException) effs, Member Task effs) => Blob -> Eff effs SomeAST
 astParseBlob blob@Blob{..}
   | Just (SomeASTParser parser) <- someASTParser <$> blobLanguage
   = SomeAST <$> parse parser blob
@@ -26,7 +26,7 @@ astParseBlob blob@Blob{..}
 data ASTFormat = SExpression | JSON | Show
   deriving (Show)
 
-runASTParse :: Members '[Distribute WrappedTask, Task, Exc SomeException] effects => ASTFormat -> [Blob] -> Eff effects F.Builder
+runASTParse :: (Member (Distribute WrappedTask) effects, Member Task effects) => ASTFormat -> [Blob] -> Eff effects F.Builder
 runASTParse SExpression = distributeFoldMap (WrapTask . (astParseBlob >=> withSomeAST (serialize (F.SExpression F.ByShow))))
 runASTParse Show        = distributeFoldMap (WrapTask . (astParseBlob >=> withSomeAST (serialize F.Show)))
 runASTParse JSON        = distributeFoldMap (\ blob -> WrapTask (astParseBlob blob >>= withSomeAST (render (renderJSONAST blob)))) >=> serialize F.JSON

src/Semantic/Diff.hs

@@ -1,8 +1,7 @@
 {-# LANGUAGE ConstraintKinds, GADTs, RankNTypes, ScopedTypeVariables #-}
 module Semantic.Diff where
 
-import Analysis.ConstructorName (ConstructorName, constructorLabel)
-import Analysis.IdentifierName (IdentifierName, identifierLabel)
+import Analysis.ConstructorName (ConstructorName)
 import Analysis.Declaration (HasDeclaration, declarationAlgebra)
 import Data.AST
 import Data.Blob
@@ -20,9 +19,9 @@ import Semantic.Stat as Stat
 import Semantic.Task as Task
 import Serializing.Format
 
-runDiff :: Members '[Distribute WrappedTask, Task, Telemetry, Exc SomeException, IO] effs => DiffRenderer output -> [BlobPair] -> Eff effs Builder
+runDiff :: (Member (Distribute WrappedTask) effs, Member Task effs) => DiffRenderer output -> [BlobPair] -> Eff effs Builder
 runDiff ToCDiffRenderer         = withParsedBlobPairs (decorate . declarationAlgebra) (render . renderToCDiff) >=> serialize JSON
-runDiff JSONDiffRenderer        = withParsedBlobPairs (const (decorate constructorLabel >=> decorate identifierLabel)) (render . renderJSONDiff) >=> serialize JSON
+runDiff JSONDiffRenderer        = withParsedBlobPairs (const pure) (render . renderJSONDiff) >=> serialize JSON
 runDiff SExpressionDiffRenderer = withParsedBlobPairs (const pure) (const (serialize (SExpression ByConstructorName)))
 runDiff ShowDiffRenderer        = withParsedBlobPairs (const pure) (const (serialize Show))
 runDiff DOTDiffRenderer         = withParsedBlobPairs (const pure) (const (render renderTreeGraph)) >=> serialize (DOT (diffStyle "diffs"))
@@ -33,28 +32,28 @@ data SomeTermPair typeclasses ann where
 withSomeTermPair :: (forall syntax . ApplyAll typeclasses syntax => Join These (Term syntax ann) -> a) -> SomeTermPair typeclasses ann -> a
 withSomeTermPair with (SomeTermPair terms) = with terms
 
-diffBlobTOCPairs :: Members '[Distribute WrappedTask, Task, Telemetry, Exc SomeException, IO] effs => [BlobPair] -> Eff effs ([TOCSummary], [TOCSummary])
+diffBlobTOCPairs :: Member (Distribute WrappedTask) effs => [BlobPair] -> Eff effs ([TOCSummary], [TOCSummary])
 diffBlobTOCPairs = withParsedBlobPairs (decorate . declarationAlgebra) (render . renderRPCToCDiff)
 
-type CanDiff syntax = (ConstructorName syntax, Diffable syntax, Eq1 syntax, GAlign syntax, HasDeclaration syntax, IdentifierName syntax, Hashable1 syntax, Show1 syntax, ToJSONFields1 syntax, Traversable syntax)
+type CanDiff syntax = (ConstructorName syntax, Diffable syntax, Eq1 syntax, HasDeclaration syntax, Hashable1 syntax, Show1 syntax, ToJSONFields1 syntax, Traversable syntax)
 
-withParsedBlobPairs :: (Members '[Distribute WrappedTask, Exc SomeException, IO, Task, Telemetry] effs, Monoid output)
+withParsedBlobPairs :: (Member (Distribute WrappedTask) effs, Monoid output)
                     => (forall syntax . CanDiff syntax => Blob -> Term syntax (Record Location) -> TaskEff (Term syntax (Record fields)))
                     -> (forall syntax . CanDiff syntax => BlobPair -> Diff syntax (Record fields) (Record fields) -> TaskEff output)
                     -> [BlobPair]
                     -> Eff effs output
 withParsedBlobPairs decorate render = distributeFoldMap (\ blobs -> WrapTask (withParsedBlobPair decorate blobs >>= withSomeTermPair (diffTerms blobs >=> render blobs)))
-  where diffTerms :: (Diffable syntax, Eq1 syntax, GAlign syntax, Hashable1 syntax, Traversable syntax, Members '[IO, Task, Telemetry] effs) => BlobPair -> Join These (Term syntax (Record fields)) -> Eff effs (Diff syntax (Record fields) (Record fields))
+  where diffTerms :: (Diffable syntax, Eq1 syntax, Hashable1 syntax, Traversable syntax, Member IO effs, Member Task effs, Member Telemetry effs) => BlobPair -> Join These (Term syntax (Record fields)) -> Eff effs (Diff syntax (Record fields) (Record fields))
         diffTerms blobs terms = time "diff" languageTag $ do
           diff <- diff (runJoin terms)
           diff <$ writeStat (Stat.count "diff.nodes" (bilength diff) languageTag)
           where languageTag = languageTagForBlobPair blobs
 
-withParsedBlobPair :: Members '[Distribute WrappedTask, Exc SomeException, Task] effs
+withParsedBlobPair :: (Member (Distribute WrappedTask) effs, Member (Exc SomeException) effs)
                    => (forall syntax . (CanDiff syntax) => Blob -> Term syntax (Record Location) -> TaskEff (Term syntax (Record fields)))
                    -> BlobPair
-                   -> Eff effs (SomeTermPair '[ConstructorName, Diffable, Eq1, GAlign, HasDeclaration, Hashable1, IdentifierName, Show1, ToJSONFields1, Traversable] (Record fields))
+                   -> Eff effs (SomeTermPair '[ConstructorName, Diffable, Eq1, HasDeclaration, Hashable1, Show1, ToJSONFields1, Traversable] (Record fields))
 withParsedBlobPair decorate blobs
-  | Just (SomeParser parser) <- someParser @'[ConstructorName, Diffable, Eq1, GAlign, HasDeclaration, Hashable1, IdentifierName, Show1, ToJSONFields1, Traversable] <$> languageForBlobPair blobs
+  | Just (SomeParser parser) <- someParser @'[ConstructorName, Diffable, Eq1, HasDeclaration, Hashable1, Show1, ToJSONFields1, Traversable] <$> languageForBlobPair blobs
   = SomeTermPair <$> distributeFor blobs (\ blob -> WrapTask (parse parser blob >>= decorate blob))
   | otherwise = noLanguageForBlob (pathForBlobPair blobs)

src/Semantic/Distribute.hs

@@ -39,6 +39,6 @@ data Distribute task output where
 
 
 -- | Evaluate a 'Distribute' effect concurrently.
-runDistribute :: Members '[Exc SomeException, IO] effs => (forall output . task output -> IO (Either SomeException output)) -> Eff (Distribute task ': effs) a -> Eff effs a
+runDistribute :: (Member (Exc SomeException) effs, Member IO effs) => (forall output . task output -> IO (Either SomeException output)) -> Eff (Distribute task ': effs) a -> Eff effs a
 runDistribute action = interpret (\ (Distribute tasks) ->
   liftIO (Async.mapConcurrently action tasks) >>= either throwError pure . sequenceA . withStrategy (parTraversable (parTraversable rseq)))

src/Semantic/Graph.hs

@@ -39,7 +39,7 @@ import           Semantic.Task as Task
 
 data GraphType = ImportGraph | CallGraph
 
-runGraph :: Members '[Distribute WrappedTask, Files, Resolution, Task, Exc SomeException, Telemetry, Trace] effs
+runGraph :: ( Member (Distribute WrappedTask) effs, Member (Exc SomeException) effs, Member Files effs, Member Resolution effs, Member Task effs, Member Trace effs)
          => GraphType
          -> Bool
          -> Project
@@ -71,7 +71,7 @@ runGraph graphType includePackages project
             . graphing
 
 -- | Parse a list of files into a 'Package'.
-parsePackage :: Members '[Distribute WrappedTask, Files, Resolution, Task, Trace] effs
+parsePackage :: (Member (Distribute WrappedTask) effs, Member Files effs, Member Resolution effs, Member Task effs, Member Trace effs)
              => Parser term -- ^ A parser.
              -> Maybe File  -- ^ Prelude (optional).
              -> Project     -- ^ Project to parse into a package.
@@ -87,11 +87,11 @@ parsePackage parser preludeFile project@Project{..} = do
     n = name (projectName project)
 
     -- | Parse all files in a project into 'Module's.
-    parseModules :: Members '[Distribute WrappedTask, Files, Task] effs => Parser term -> Project -> Eff effs [Module term]
+    parseModules :: Member (Distribute WrappedTask) effs => Parser term -> Project -> Eff effs [Module term]
     parseModules parser Project{..} = distributeFor (projectEntryPoints <> projectFiles) (WrapTask . parseModule parser (Just projectRootDir))
 
 -- | Parse a file into a 'Module'.
-parseModule :: Members '[Files, Task] effs => Parser term -> Maybe FilePath -> File -> Eff effs (Module term)
+parseModule :: (Member Files effs, Member Task effs) => Parser term -> Maybe FilePath -> File -> Eff effs (Module term)
 parseModule parser rootDir file = do
   blob <- readBlob file
   moduleForBlob rootDir blob <$> parse parser blob
@@ -100,8 +100,8 @@ parseModule parser rootDir file = do
 withTermSpans :: ( HasField fields Span
                  , Member (Reader Span) effects
                  )
-              => SubtermAlgebra (TermF syntax (Record fields)) term (TermEvaluator term location value effects a)
-              -> SubtermAlgebra (TermF syntax (Record fields)) term (TermEvaluator term location value effects a)
+              => SubtermAlgebra (TermF syntax (Record fields)) term (TermEvaluator term address value effects a)
+              -> SubtermAlgebra (TermF syntax (Record fields)) term (TermEvaluator term address 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
@@ -109,10 +109,10 @@ resumingResolutionError = runResolutionErrorWith (\ err -> trace ("ResolutionErr
   NotFoundError nameToResolve _ _ -> pure  nameToResolve
   GoImportError pathToResolve     -> pure [pathToResolve])
 
-resumingLoadError :: Member Trace effects => Evaluator location value (Resumable (LoadError location value) ': effects) a -> Evaluator location value effects a
+resumingLoadError :: Member Trace effects => Evaluator address value (Resumable (LoadError address value) ': effects) a -> Evaluator address value effects a
 resumingLoadError = runLoadErrorWith (\ (ModuleNotFound path) -> trace ("LoadError: " <> path) $> Nothing)
 
-resumingEvalError :: Member Trace effects => Evaluator location value (Resumable EvalError ': effects) a -> Evaluator location value effects a
+resumingEvalError :: Member Trace effects => Evaluator address value (Resumable EvalError ': effects) a -> Evaluator address value effects a
 resumingEvalError = runEvalErrorWith (\ err -> trace ("EvalError" <> show err) *> case err of
   DefaultExportError{}     -> pure ()
   ExportError{}            -> pure ()
@@ -121,19 +121,15 @@ resumingEvalError = runEvalErrorWith (\ err -> trace ("EvalError" <> show err) *
   RationalFormatError{}    -> pure 0
   FreeVariablesError names -> pure (fromMaybeLast "unknown" names))
 
-resumingUnspecialized :: ( AbstractHole value
-                         , Member Trace effects
-                         )
-                      => Evaluator location value (Resumable (Unspecialized value) ': effects) a
-                      -> Evaluator location value effects a
+resumingUnspecialized :: (Member Trace effects, AbstractHole value) => Evaluator address value (Resumable (Unspecialized value) ': effects) a -> Evaluator address value effects a
 resumingUnspecialized = runUnspecializedWith (\ err@(Unspecialized _) -> trace ("Unspecialized:" <> show err) $> hole)
 
-resumingAddressError :: (AbstractHole value, Lower (Cell location value), Member Trace effects, Show location) => Evaluator location value (Resumable (AddressError location value) ': effects) a -> Evaluator location value effects a
+resumingAddressError :: (AbstractHole value, Lower (Cell address value), Member Trace effects, Show address) => Evaluator address value (Resumable (AddressError address value) ': effects) a -> Evaluator address value effects a
 resumingAddressError = runAddressErrorWith (\ err -> trace ("AddressError:" <> show err) *> case err of
   UnallocatedAddress _   -> pure lowerBound
   UninitializedAddress _ -> pure hole)
 
-resumingValueError :: (Members '[State (Environment location), Trace] effects, Show location) => Evaluator location (Value location body) (Resumable (ValueError location body) ': effects) a -> Evaluator location (Value location body) effects a
+resumingValueError :: (Member (State (Environment address)) effects, Member Trace effects, Show address) => Evaluator address (Value address body) (Resumable (ValueError address body) ': effects) a -> Evaluator address (Value address body) effects a
 resumingValueError = runValueErrorWith (\ err -> trace ("ValueError" <> show err) *> case err of
   CallError val     -> pure val
   StringError val   -> pure (pack (show val))
@@ -149,7 +145,7 @@ resumingValueError = runValueErrorWith (\ err -> trace ("ValueError" <> show err
   KeyValueError{}   -> pure (hole, hole)
   ArithmeticError{} -> pure hole)
 
-resumingEnvironmentError :: AbstractHole location => Evaluator location value (Resumable (EnvironmentError location) ': effects) a -> Evaluator location value effects (a, [Name])
+resumingEnvironmentError :: AbstractHole address => Evaluator address value (Resumable (EnvironmentError address) ': effects) a -> Evaluator address value effects (a, [Name])
 resumingEnvironmentError
   = runState []
   . reinterpret (\ (Resumable (FreeVariable name)) -> modify' (name :) $> hole)

src/Semantic/IO.hs

@@ -252,7 +252,7 @@ data Files out where
   Write       :: Destination -> B.Builder -> Files ()
 
 -- | Run a 'Files' effect in 'IO'.
-runFiles :: Members '[Exc SomeException, IO] effs => Eff (Files ': effs) a -> Eff effs a
+runFiles :: (Member (Exc SomeException) effs, Member IO effs) => Eff (Files ': effs) a -> Eff effs a
 runFiles = interpret $ \ files -> case files of
   Read (FromPath path)         -> rethrowing (readBlobFromPath path)
   Read (FromHandle handle)     -> rethrowing (readBlobsFromHandle handle)

src/Semantic/Parse.hs

@@ -1,8 +1,7 @@
 {-# LANGUAGE GADTs, RankNTypes #-}
 module Semantic.Parse where
 
-import Analysis.ConstructorName (ConstructorName, constructorLabel)
-import Analysis.IdentifierName (IdentifierName, identifierLabel)
+import Analysis.ConstructorName (ConstructorName)
 import Analysis.Declaration (HasDeclaration, declarationAlgebra)
 import Analysis.PackageDef (HasPackageDef, packageDefAlgebra)
 import Data.AST
@@ -18,8 +17,8 @@ import Semantic.IO (noLanguageForBlob)
 import Semantic.Task
 import Serializing.Format
 
-runParse :: Members '[Distribute WrappedTask, Task, Exc SomeException] effs => TermRenderer output -> [Blob] -> Eff effs Builder
-runParse JSONTermRenderer             = withParsedBlobs (\ blob -> decorate constructorLabel >=> decorate identifierLabel >=> render (renderJSONTerm blob)) >=> serialize JSON
+runParse :: (Member (Distribute WrappedTask) effs, Member Task effs) => TermRenderer output -> [Blob] -> Eff effs Builder
+runParse JSONTermRenderer             = withParsedBlobs (render . renderJSONTerm) >=> serialize JSON
 runParse SExpressionTermRenderer      = withParsedBlobs (const (serialize (SExpression ByConstructorName)))
 runParse ShowTermRenderer             = withParsedBlobs (const (serialize Show))
 runParse TagsTermRenderer             = withParsedBlobs (\ blob -> decorate (declarationAlgebra blob) >=> render (renderToTags blob)) >=> serialize JSON
@@ -27,8 +26,8 @@ runParse ImportsTermRenderer          = withParsedBlobs (\ blob -> decorate (dec
 runParse (SymbolsTermRenderer fields) = withParsedBlobs (\ blob -> decorate (declarationAlgebra blob) >=> render (renderSymbolTerms . renderToSymbols fields blob)) >=> serialize JSON
 runParse DOTTermRenderer              = withParsedBlobs (const (render renderTreeGraph)) >=> serialize (DOT (termStyle "terms"))
 
-withParsedBlobs :: (Members '[Distribute WrappedTask, Task, Exc SomeException] effs, Monoid output) => (forall syntax . (ConstructorName syntax, Foldable syntax, Functor syntax, HasDeclaration syntax, HasPackageDef syntax, IdentifierName syntax, Show1 syntax, ToJSONFields1 syntax) => Blob -> Term syntax (Record Location) -> TaskEff output) -> [Blob] -> Eff effs output
+withParsedBlobs :: (Member (Distribute WrappedTask) effs, Monoid output) => (forall syntax . (ConstructorName syntax, Foldable syntax, Functor syntax, HasDeclaration syntax, HasPackageDef syntax, Show1 syntax, ToJSONFields1 syntax) => Blob -> Term syntax (Record Location) -> TaskEff output) -> [Blob] -> Eff effs output
 withParsedBlobs render = distributeFoldMap (\ blob -> WrapTask (parseSomeBlob blob >>= withSomeTerm (render blob)))
 
-parseSomeBlob :: Members '[Task, Exc SomeException] effs => Blob -> Eff effs (SomeTerm '[ConstructorName, Foldable, Functor, HasDeclaration, HasPackageDef, IdentifierName, Show1, ToJSONFields1] (Record Location))
+parseSomeBlob :: (Member (Exc SomeException) effs, Member Task effs) => Blob -> Eff effs (SomeTerm '[ConstructorName, Foldable, Functor, HasDeclaration, HasPackageDef, Show1, ToJSONFields1] (Record Location))
 parseSomeBlob blob@Blob{..} = maybe (noLanguageForBlob blobPath) (flip parse blob . someParser) blobLanguage

src/Semantic/Resolution.hs

@@ -39,7 +39,7 @@ data Resolution output where
   NodeJSResolution :: FilePath -> Text -> [FilePath] -> Resolution (Map FilePath FilePath)
   NoResolution :: Resolution (Map FilePath FilePath)
 
-runResolution :: Members '[Files] effs => Eff (Resolution ': effs) a -> Eff effs a
+runResolution :: Member Files effs => Eff (Resolution ': effs) a -> Eff effs a
 runResolution = interpret $ \ res -> case res of
   NodeJSResolution dir prop excludeDirs -> nodeJSResolutionMap dir prop excludeDirs
   NoResolution -> pure Map.empty

src/Semantic/Task.hs

@@ -104,7 +104,7 @@ parse :: Member Task effs => Parser term -> Blob -> Eff effs term
 parse parser = send . Parse parser
 
 -- | 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 :: Member Task effs => (Analysis.TermEvaluator term address value effects a -> result) -> Analysis.TermEvaluator term address 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.
@@ -112,7 +112,7 @@ decorate :: (Functor f, Member Task effs) => RAlgebra (TermF f (Record fields))
 decorate algebra = send . Decorate algebra
 
 -- | A task which diffs a pair of terms using the supplied 'Differ' function.
-diff :: (Diffable syntax, Eq1 syntax, GAlign syntax, Hashable1 syntax, Traversable syntax, Member Task effs) => These (Term syntax (Record fields1)) (Term syntax (Record fields2)) -> Eff effs (Diff syntax (Record fields1) (Record fields2))
+diff :: (Diffable syntax, Eq1 syntax, Hashable1 syntax, Traversable syntax, Member Task effs) => These (Term syntax (Record fields1)) (Term syntax (Record fields2)) -> Eff effs (Diff syntax (Record fields1) (Record fields2))
 diff terms = send (Semantic.Task.Diff terms)
 
 -- | A task which renders some input using the supplied 'Renderer' function.
@@ -160,14 +160,14 @@ 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.TermEvaluator term location value effects a -> result) -> Analysis.TermEvaluator term location value effects a -> Task result
+  Analyze   :: (Analysis.TermEvaluator term address value effects a -> result) -> Analysis.TermEvaluator term address 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, Hashable1 syntax, Traversable syntax) => These (Term syntax (Record fields1)) (Term syntax (Record fields2)) -> Task (Diff syntax (Record fields1) (Record fields2))
+  Diff      :: (Diffable syntax, Eq1 syntax, Hashable1 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
   Serialize :: Format input -> input -> Task Builder
 
 -- | Run a 'Task' effect by performing the actions in 'IO'.
-runTaskF :: Members '[Reader Options, Telemetry, Exc SomeException, Trace, IO] effs => Eff (Task ': effs) a -> Eff effs a
+runTaskF :: (Member (Exc SomeException) effs, Member IO effs, Member (Reader Options) effs, Member Telemetry effs, Member Trace effs) => Eff (Task ': effs) a -> Eff effs a
 runTaskF = interpret $ \ task -> case task of
   Parse parser blob -> runParser blob parser
   Analyze interpret analysis -> pure (interpret analysis)
@@ -191,7 +191,7 @@ defaultTimeout :: Timeout
 defaultTimeout = Milliseconds 5000
 
 -- | Parse a 'Blob' in 'IO'.
-runParser :: Members '[Reader Options, Telemetry, Exc SomeException, IO, Trace] effs => Blob -> Parser term -> Eff effs term
+runParser :: (Member (Exc SomeException) effs, Member IO effs, Member (Reader Options) effs, Member Telemetry effs, Member Trace effs) => Blob -> Parser term -> Eff effs term
 runParser blob@Blob{..} parser = case parser of
   ASTParser language ->
     time "parse.tree_sitter_ast_parse" languageTag $

src/Semantic/Telemetry.hs

@@ -23,7 +23,7 @@ writeStat :: Member Telemetry effs => Stat -> Eff effs ()
 writeStat stat = send (WriteStat stat)
 
 -- | A task which measures and stats the timing of another task.
-time :: Members '[Telemetry, IO] effs => String -> [(String, String)] -> Eff effs output -> Eff effs output
+time :: (Member IO effs, Member Telemetry effs) => String -> [(String, String)] -> Eff effs output -> Eff effs output
 time statName tags task = do
   (a, stat) <- withTiming statName tags task
   a <$ writeStat stat

test/Analysis/Python/Spec.hs

@@ -44,7 +44,6 @@ spec = parallel $ do
 
   where
     ns n = Just . Latest . Last . Just . Namespace n
-    addr = Address . Precise
     fixtures = "test/fixtures/python/analysis/"
     evaluate entry = evalPythonProject (fixtures <> entry)
     evalPythonProject path = testEvaluating <$> evaluateProject pythonParser Language.Python pythonPrelude path

test/Analysis/Ruby/Spec.hs

@@ -76,7 +76,6 @@ spec = parallel $ do
 
   where
     ns n = Just . Latest . Last . Just . Namespace n
-    addr = Address . Precise
     fixtures = "test/fixtures/ruby/analysis/"
     evaluate entry = evalRubyProject (fixtures <> entry)
     evalRubyProject path = testEvaluating <$> evaluateProject rubyParser Language.Ruby rubyPrelude path

test/Data/Mergeable/Spec.hs

@@ -1,61 +0,0 @@
-{-# LANGUAGE RankNTypes, ScopedTypeVariables #-}
-module Data.Mergeable.Spec (spec) where
-
-import Control.Applicative (Alternative(..))
-import Data.Functor.Identity
-import Data.Functor.Listable
-import Data.Maybe (catMaybes)
-import Data.Mergeable
-import Test.Hspec
-import Test.Hspec.LeanCheck
-import Test.LeanCheck
-
-spec :: Spec
-spec = parallel $ do
-  describe "[]" $ do
-    withAlternativeInstances sequenceAltLaws (tiers :: [Tier String])
-    withAlternativeInstances mergeLaws (tiers :: [Tier String])
-  describe "Maybe" $ do
-    withAlternativeInstances sequenceAltLaws (tiers :: [Tier (Maybe Char)])
-    withAlternativeInstances mergeLaws (tiers :: [Tier (Maybe Char)])
-  describe "Identity" $ do
-    withAlternativeInstances sequenceAltLaws (Identity `mapT` tiers :: [Tier (Identity Char)])
-    withAlternativeInstances mergeLaws (Identity `mapT` tiers :: [Tier (Identity Char)])
-  describe "ListableSyntax" $ do
-    withAlternativeInstances sequenceAltLaws (tiers :: [Tier (ListableSyntax Char)])
-    withAlternativeInstances mergeLaws (tiers :: [Tier (ListableSyntax Char)])
-
-  prop "subsumes catMaybes/Just" $
-    \ a -> sequenceAlt a `shouldBe` pure (catMaybes (a :: [Maybe Char]))
-
-mergeLaws :: forall f g a. (Mergeable f, Alternative g, Eq (g (f a)), Show (f a), Show (g (f a))) => [Tier (f a)] -> [Tier (Blind (a -> g a))] -> Spec
-mergeLaws value function = describe "merge" $ do
-  prop "identity" . forAll value $
-    \ a -> merge pure a `shouldNotBe` (empty :: g (f a))
-
-  prop "relationship with sequenceAlt" . forAll (value >< function) $
-    \ (a, f) -> merge (getBlind f) a `shouldBe` sequenceAlt (fmap (getBlind f) a)
-
-sequenceAltLaws :: forall f g a. (Mergeable f, Alternative g, Eq (g (f a)), Show (f a), Show (g (f a))) => [Tier (f a)] -> [Tier (Blind (a -> g a))] -> Spec
-sequenceAltLaws value function = describe "sequenceAlt" $ do
-  prop "identity" . forAll value $
-    \ a -> sequenceAlt (pure <$> a) `shouldNotBe` (empty :: g (f a))
-
-  prop "relationship with merge" . forAll (productWith ((Blind .) . fmap . getBlind) function value :: [Tier (Blind (f (g a)))]) $
-    \ a -> sequenceAlt (getBlind a) `shouldBe` merge id (getBlind a)
-
-
-withAlternativeInstances :: forall f a. (Listable a, Eq (f a), Show (f a)) => (forall g. (Alternative g, Eq (g (f a)), Show (g (f a))) => [Tier (f a)] -> [Tier (Blind (a -> g a))] -> Spec) -> [Tier (f a)] -> Spec
-withAlternativeInstances laws gen = do
-  describe "[]" $ laws gen (fmap const `mapT` tiers :: [Tier (Blind (a -> [a]))])
-  describe "Maybe" $ laws gen (fmap const `mapT` tiers :: [Tier (Blind (a -> Maybe a))])
-
-
-newtype Blind a = Blind { getBlind :: a }
-  deriving Functor
-
-instance Listable a => Listable (Blind a) where
-  tiers = Blind `mapT` tiers
-
-instance Show (Blind a) where
-  showsPrec _ _ = showString "*"

test/Doctests.hs

@@ -6,7 +6,8 @@ import System.Environment
 import Test.DocTest
 
 defaultFiles =
-  [ "src/Data/Abstract/Environment.hs"
+  [ "src/Data/Abstract/Address.hs"
+  , "src/Data/Abstract/Environment.hs"
   , "src/Data/Abstract/Name.hs"
   , "src/Data/Range.hs"
   , "src/Data/Semigroup/App.hs"

test/Rendering/TOC/Spec.hs

@@ -3,7 +3,6 @@ module Rendering.TOC.Spec (spec) where
 
 import Analysis.Declaration
 import Data.Aeson
-import Data.Align.Generic
 import Data.Bifunctor
 import Data.Bifunctor.Join
 import Data.Diff
@@ -240,10 +239,10 @@ diffWithParser :: ( HasField fields Data.Span.Span
                   , Show1 syntax
                   , Traversable syntax
                   , Diffable syntax
-                  , GAlign syntax
                   , HasDeclaration syntax
                   , Hashable1 syntax
-                  , Members '[Distribute WrappedTask, Task] effs
+                  , Member (Distribute WrappedTask) effs
+                  , Member Task effs
                   )
                => Parser (Term syntax (Record fields))
                -> BlobPair

test/Semantic/CLI/Spec.hs

@@ -41,8 +41,8 @@ parseFixtures =
         pathMode' = [File "test/fixtures/ruby/corpus/and-or.A.rb" (Just Ruby), File "test/fixtures/ruby/corpus/and-or.B.rb" (Just Ruby)]
 
         sExpressionParseTreeOutput = "(Program\n  (LowAnd\n    (Send\n      (Identifier))\n    (Send\n      (Identifier))))\n"
-        jsonParseTreeOutput = "{\"trees\":[{\"programNode\":{\"category\":\"Program\",\"sourceRange\":[0,12],\"sourceSpan\":{\"start\":[1,1],\"end\":[2,1]},\"children\":[{\"category\":\"LowAnd\",\"sourceRange\":[0,11],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,12]},\"children\":[{\"category\":\"Send\",\"sourceRange\":[0,3],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,4]},\"children\":[{\"name\":\"foo\",\"category\":\"Identifier\",\"sourceRange\":[0,3],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,4]},\"children\":[]}]},{\"category\":\"Send\",\"sourceRange\":[8,11],\"sourceSpan\":{\"start\":[1,9],\"end\":[1,12]},\"children\":[{\"name\":\"bar\",\"category\":\"Identifier\",\"sourceRange\":[8,11],\"sourceSpan\":{\"start\":[1,9],\"end\":[1,12]},\"children\":[]}]}]}]},\"path\":\"test/fixtures/ruby/corpus/and-or.A.rb\",\"language\":\"Ruby\"}]}\n"
-        jsonParseTreeOutput' = "{\"trees\":[{\"programNode\":{\"category\":\"Program\",\"sourceRange\":[0,12],\"sourceSpan\":{\"start\":[1,1],\"end\":[2,1]},\"children\":[{\"category\":\"LowAnd\",\"sourceRange\":[0,11],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,12]},\"children\":[{\"category\":\"Send\",\"sourceRange\":[0,3],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,4]},\"children\":[{\"name\":\"foo\",\"category\":\"Identifier\",\"sourceRange\":[0,3],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,4]},\"children\":[]}]},{\"category\":\"Send\",\"sourceRange\":[8,11],\"sourceSpan\":{\"start\":[1,9],\"end\":[1,12]},\"children\":[{\"name\":\"bar\",\"category\":\"Identifier\",\"sourceRange\":[8,11],\"sourceSpan\":{\"start\":[1,9],\"end\":[1,12]},\"children\":[]}]}]}]},\"path\":\"test/fixtures/ruby/corpus/and-or.A.rb\",\"language\":\"Ruby\"},{\"programNode\":{\"category\":\"Program\",\"sourceRange\":[0,24],\"sourceSpan\":{\"start\":[1,1],\"end\":[3,1]},\"children\":[{\"category\":\"LowOr\",\"sourceRange\":[0,10],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,11]},\"children\":[{\"category\":\"Send\",\"sourceRange\":[0,3],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,4]},\"children\":[{\"name\":\"foo\",\"category\":\"Identifier\",\"sourceRange\":[0,3],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,4]},\"children\":[]}]},{\"category\":\"Send\",\"sourceRange\":[7,10],\"sourceSpan\":{\"start\":[1,8],\"end\":[1,11]},\"children\":[{\"name\":\"bar\",\"category\":\"Identifier\",\"sourceRange\":[7,10],\"sourceSpan\":{\"start\":[1,8],\"end\":[1,11]},\"children\":[]}]}]},{\"category\":\"LowAnd\",\"sourceRange\":[11,23],\"sourceSpan\":{\"start\":[2,1],\"end\":[2,13]},\"children\":[{\"category\":\"LowOr\",\"sourceRange\":[11,17],\"sourceSpan\":{\"start\":[2,1],\"end\":[2,7]},\"children\":[{\"category\":\"Send\",\"sourceRange\":[11,12],\"sourceSpan\":{\"start\":[2,1],\"end\":[2,2]},\"children\":[{\"name\":\"a\",\"category\":\"Identifier\",\"sourceRange\":[11,12],\"sourceSpan\":{\"start\":[2,1],\"end\":[2,2]},\"children\":[]}]},{\"category\":\"Send\",\"sourceRange\":[16,17],\"sourceSpan\":{\"start\":[2,6],\"end\":[2,7]},\"children\":[{\"name\":\"b\",\"category\":\"Identifier\",\"sourceRange\":[16,17],\"sourceSpan\":{\"start\":[2,6],\"end\":[2,7]},\"children\":[]}]}]},{\"category\":\"Send\",\"sourceRange\":[22,23],\"sourceSpan\":{\"start\":[2,12],\"end\":[2,13]},\"children\":[{\"name\":\"c\",\"category\":\"Identifier\",\"sourceRange\":[22,23],\"sourceSpan\":{\"start\":[2,12],\"end\":[2,13]},\"children\":[]}]}]}]},\"path\":\"test/fixtures/ruby/corpus/and-or.B.rb\",\"language\":\"Ruby\"}]}\n"
+        jsonParseTreeOutput = "{\"trees\":[{\"tree\":{\"term\":\"Program\",\"children\":[{\"term\":\"LowAnd\",\"children\":{\"term\":\"Send\",\"sendReceiver\":null,\"sendSelector\":{\"term\":\"Identifier\",\"name\":\"foo\",\"sourceRange\":[0,3],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,4]}},\"sendArgs\":[],\"sendBlock\":null,\"sourceRange\":[0,3],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,4]}},\"children\":{\"term\":\"Send\",\"sendReceiver\":null,\"sendSelector\":{\"term\":\"Identifier\",\"name\":\"bar\",\"sourceRange\":[8,11],\"sourceSpan\":{\"start\":[1,9],\"end\":[1,12]}},\"sendArgs\":[],\"sendBlock\":null,\"sourceRange\":[8,11],\"sourceSpan\":{\"start\":[1,9],\"end\":[1,12]}},\"sourceRange\":[0,11],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,12]}}],\"sourceRange\":[0,12],\"sourceSpan\":{\"start\":[1,1],\"end\":[2,1]}},\"path\":\"test/fixtures/ruby/corpus/and-or.A.rb\",\"language\":\"Ruby\"}]}\n"
+        jsonParseTreeOutput' = "{\"trees\":[{\"tree\":{\"term\":\"Program\",\"children\":[{\"term\":\"LowAnd\",\"children\":{\"term\":\"Send\",\"sendReceiver\":null,\"sendSelector\":{\"term\":\"Identifier\",\"name\":\"foo\",\"sourceRange\":[0,3],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,4]}},\"sendArgs\":[],\"sendBlock\":null,\"sourceRange\":[0,3],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,4]}},\"children\":{\"term\":\"Send\",\"sendReceiver\":null,\"sendSelector\":{\"term\":\"Identifier\",\"name\":\"bar\",\"sourceRange\":[8,11],\"sourceSpan\":{\"start\":[1,9],\"end\":[1,12]}},\"sendArgs\":[],\"sendBlock\":null,\"sourceRange\":[8,11],\"sourceSpan\":{\"start\":[1,9],\"end\":[1,12]}},\"sourceRange\":[0,11],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,12]}}],\"sourceRange\":[0,12],\"sourceSpan\":{\"start\":[1,1],\"end\":[2,1]}},\"path\":\"test/fixtures/ruby/corpus/and-or.A.rb\",\"language\":\"Ruby\"},{\"tree\":{\"term\":\"Program\",\"children\":[{\"term\":\"LowOr\",\"children\":{\"term\":\"Send\",\"sendReceiver\":null,\"sendSelector\":{\"term\":\"Identifier\",\"name\":\"foo\",\"sourceRange\":[0,3],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,4]}},\"sendArgs\":[],\"sendBlock\":null,\"sourceRange\":[0,3],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,4]}},\"children\":{\"term\":\"Send\",\"sendReceiver\":null,\"sendSelector\":{\"term\":\"Identifier\",\"name\":\"bar\",\"sourceRange\":[7,10],\"sourceSpan\":{\"start\":[1,8],\"end\":[1,11]}},\"sendArgs\":[],\"sendBlock\":null,\"sourceRange\":[7,10],\"sourceSpan\":{\"start\":[1,8],\"end\":[1,11]}},\"sourceRange\":[0,10],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,11]}},{\"term\":\"LowAnd\",\"children\":{\"term\":\"LowOr\",\"children\":{\"term\":\"Send\",\"sendReceiver\":null,\"sendSelector\":{\"term\":\"Identifier\",\"name\":\"a\",\"sourceRange\":[11,12],\"sourceSpan\":{\"start\":[2,1],\"end\":[2,2]}},\"sendArgs\":[],\"sendBlock\":null,\"sourceRange\":[11,12],\"sourceSpan\":{\"start\":[2,1],\"end\":[2,2]}},\"children\":{\"term\":\"Send\",\"sendReceiver\":null,\"sendSelector\":{\"term\":\"Identifier\",\"name\":\"b\",\"sourceRange\":[16,17],\"sourceSpan\":{\"start\":[2,6],\"end\":[2,7]}},\"sendArgs\":[],\"sendBlock\":null,\"sourceRange\":[16,17],\"sourceSpan\":{\"start\":[2,6],\"end\":[2,7]}},\"sourceRange\":[11,17],\"sourceSpan\":{\"start\":[2,1],\"end\":[2,7]}},\"children\":{\"term\":\"Send\",\"sendReceiver\":null,\"sendSelector\":{\"term\":\"Identifier\",\"name\":\"c\",\"sourceRange\":[22,23],\"sourceSpan\":{\"start\":[2,12],\"end\":[2,13]}},\"sendArgs\":[],\"sendBlock\":null,\"sourceRange\":[22,23],\"sourceSpan\":{\"start\":[2,12],\"end\":[2,13]}},\"sourceRange\":[11,23],\"sourceSpan\":{\"start\":[2,1],\"end\":[2,13]}}],\"sourceRange\":[0,24],\"sourceSpan\":{\"start\":[1,1],\"end\":[3,1]}},\"path\":\"test/fixtures/ruby/corpus/and-or.B.rb\",\"language\":\"Ruby\"}]}\n"
         emptyJsonParseTreeOutput = "{\"trees\":[]}\n"
         symbolsOutput = "{\"files\":[{\"path\":\"test/fixtures/ruby/corpus/method-declaration.A.rb\",\"symbols\":[{\"span\":{\"start\":[1,1],\"end\":[2,4]},\"kind\":\"Method\",\"symbol\":\"foo\"}],\"language\":\"Ruby\"}]}\n"
         tagsOutput = "[{\"span\":{\"start\":[1,1],\"end\":[2,4]},\"path\":\"test/fixtures/ruby/corpus/method-declaration.A.rb\",\"kind\":\"Method\",\"symbol\":\"foo\",\"line\":\"def foo\",\"language\":\"Ruby\"}]\n"
@@ -56,6 +56,6 @@ diffFixtures =
   ]
   where pathMode = [both (File "test/fixtures/ruby/corpus/method-declaration.A.rb" (Just Ruby)) (File "test/fixtures/ruby/corpus/method-declaration.B.rb"  (Just Ruby))]
 
-        jsonOutput =  "{\"diffs\":[{\"diff\":{\"merge\":{\"before\":{\"category\":\"Program\",\"sourceRange\":[0,12],\"sourceSpan\":{\"start\":[1,1],\"end\":[3,1]}},\"after\":{\"category\":\"Program\",\"sourceRange\":[0,21],\"sourceSpan\":{\"start\":[1,1],\"end\":[4,1]}},\"children\":[{\"merge\":{\"before\":{\"category\":\"Method\",\"sourceRange\":[0,11],\"sourceSpan\":{\"start\":[1,1],\"end\":[2,4]}},\"after\":{\"category\":\"Method\",\"sourceRange\":[0,20],\"sourceSpan\":{\"start\":[1,1],\"end\":[3,4]}},\"children\":[{\"merge\":{\"before\":{\"category\":\"Empty\",\"sourceRange\":[0,0],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,1]}},\"after\":{\"category\":\"Empty\",\"sourceRange\":[0,0],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,1]}},\"children\":[]}},{\"patch\":{\"replace\":[{\"category\":\"Identifier\",\"children\":[],\"name\":\"foo\",\"sourceRange\":[4,7],\"sourceSpan\":{\"start\":[1,5],\"end\":[1,8]}},{\"category\":\"Identifier\",\"children\":[],\"name\":\"bar\",\"sourceRange\":[4,7],\"sourceSpan\":{\"start\":[1,5],\"end\":[1,8]}}]}},{\"patch\":{\"insert\":{\"category\":\"Identifier\",\"children\":[],\"name\":\"a\",\"sourceRange\":[8,9],\"sourceSpan\":{\"start\":[1,9],\"end\":[1,10]}}}},{\"merge\":{\"before\":{\"category\":\"[]\",\"sourceRange\":[8,11],\"sourceSpan\":{\"start\":[2,1],\"end\":[2,4]}},\"after\":{\"category\":\"\",\"sourceRange\":[13,16],\"sourceSpan\":{\"start\":[2,3],\"end\":[2,6]}},\"children\":[{\"patch\":{\"insert\":{\"category\":\"Send\",\"children\":[{\"patch\":{\"insert\":{\"category\":\"Identifier\",\"children\":[],\"name\":\"baz\",\"sourceRange\":[13,16],\"sourceSpan\":{\"start\":[2,3],\"end\":[2,6]}}}}],\"sourceRange\":[13,16],\"sourceSpan\":{\"start\":[2,3],\"end\":[2,6]}}}}]}}]}}]}},\"stat\":{\"path\":\"test/fixtures/ruby/corpus/method-declaration.A.rb -> test/fixtures/ruby/corpus/method-declaration.B.rb\",\"replace\":[{\"path\":\"test/fixtures/ruby/corpus/method-declaration.A.rb\",\"language\":\"Ruby\"},{\"path\":\"test/fixtures/ruby/corpus/method-declaration.B.rb\",\"language\":\"Ruby\"}]}}]}\n"
-        sExpressionOutput = "(Program\n  (Method\n    (Empty)\n  { (Identifier)\n  ->(Identifier) }\n  {+(Identifier)+}\n    (\n    {+(Send\n      {+(Identifier)+})+})))\n"
+        jsonOutput = "{\"diffs\":[{\"diff\":{\"merge\":{\"term\":\"Program\",\"children\":[{\"merge\":{\"term\":\"Method\",\"methodContext\":[],\"methodReceiver\":{\"merge\":{\"term\":\"Empty\",\"before\":{\"sourceRange\":[0,0],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,1]}},\"after\":{\"sourceRange\":[0,0],\"sourceSpan\":{\"start\":[1,1],\"end\":[1,1]}}}},\"methodName\":{\"patch\":{\"replace\":[{\"term\":\"Identifier\",\"name\":\"foo\",\"sourceRange\":[4,7],\"sourceSpan\":{\"start\":[1,5],\"end\":[1,8]}},{\"term\":\"Identifier\",\"name\":\"bar\",\"sourceRange\":[4,7],\"sourceSpan\":{\"start\":[1,5],\"end\":[1,8]}}]}},\"methodParameters\":[{\"patch\":{\"insert\":{\"term\":\"Identifier\",\"name\":\"a\",\"sourceRange\":[8,9],\"sourceSpan\":{\"start\":[1,9],\"end\":[1,10]}}}}],\"methodBody\":{\"merge\":{\"children\":[{\"patch\":{\"insert\":{\"term\":\"Send\",\"sourceRange\":[13,16],\"sendReceiver\":null,\"sendBlock\":null,\"sendArgs\":[],\"sourceSpan\":{\"start\":[2,3],\"end\":[2,6]},\"sendSelector\":{\"patch\":{\"insert\":{\"term\":\"Identifier\",\"name\":\"baz\",\"sourceRange\":[13,16],\"sourceSpan\":{\"start\":[2,3],\"end\":[2,6]}}}}}}}],\"before\":{\"sourceRange\":[8,11],\"sourceSpan\":{\"start\":[2,1],\"end\":[2,4]}},\"after\":{\"sourceRange\":[13,16],\"sourceSpan\":{\"start\":[2,3],\"end\":[2,6]}}}},\"before\":{\"sourceRange\":[0,11],\"sourceSpan\":{\"start\":[1,1],\"end\":[2,4]}},\"after\":{\"sourceRange\":[0,20],\"sourceSpan\":{\"start\":[1,1],\"end\":[3,4]}}}}],\"before\":{\"sourceRange\":[0,12],\"sourceSpan\":{\"start\":[1,1],\"end\":[3,1]}},\"after\":{\"sourceRange\":[0,21],\"sourceSpan\":{\"start\":[1,1],\"end\":[4,1]}}}},\"stat\":{\"path\":\"test/fixtures/ruby/corpus/method-declaration.A.rb -> test/fixtures/ruby/corpus/method-declaration.B.rb\",\"replace\":[{\"path\":\"test/fixtures/ruby/corpus/method-declaration.A.rb\",\"language\":\"Ruby\"},{\"path\":\"test/fixtures/ruby/corpus/method-declaration.B.rb\",\"language\":\"Ruby\"}]}}]}\n"
+        sExpressionOutput = "(Program\n  (Method\n    (Empty)\n  { (Identifier)\n  ->(Identifier) }\n  {+(Identifier)+}\n    (Statements\n    {+(Send\n      {+(Identifier)+})+})))\n"
         tocOutput = "{\"changes\":{\"test/fixtures/ruby/corpus/method-declaration.A.rb -> test/fixtures/ruby/corpus/method-declaration.B.rb\":[{\"span\":{\"start\":[1,1],\"end\":[3,4]},\"category\":\"Method\",\"term\":\"bar\",\"changeType\":\"modified\"}]},\"errors\":{}}\n"

test/Semantic/Spec.hs

@@ -18,6 +18,6 @@ spec = parallel $ do
 
     it "renders with the specified renderer" $ do
       output <- fmap runBuilder . runTask $ runParse SExpressionTermRenderer [methodsBlob]
-      output `shouldBe` "(Program\n  (Method\n    (Empty)\n    (Identifier)\n    ([])))\n"
+      output `shouldBe` "(Program\n  (Method\n    (Empty)\n    (Identifier)\n    (Statements)))\n"
   where
     methodsBlob = Blob "def foo\nend\n" "methods.rb" (Just Ruby)

test/Spec.hs

@@ -10,7 +10,6 @@ import qualified Control.Abstract.Evaluator.Spec
 import qualified Data.Diff.Spec
 import qualified Data.Abstract.Path.Spec
 import qualified Data.Functor.Classes.Generic.Spec
-import qualified Data.Mergeable.Spec
 import qualified Data.Scientific.Spec
 import qualified Data.Source.Spec
 import qualified Data.Term.Spec
@@ -40,7 +39,6 @@ main = hspec $ do
     describe "Data.Diff" Data.Diff.Spec.spec
     describe "Data.Abstract.Path" Data.Abstract.Path.Spec.spec
     describe "Data.Functor.Classes.Generic" Data.Functor.Classes.Generic.Spec.spec
-    describe "Data.Mergeable" Data.Mergeable.Spec.spec
     describe "Data.Scientific" Data.Scientific.Spec.spec
     describe "Data.Source" Data.Source.Spec.spec
     describe "Data.Term" Data.Term.Spec.spec

test/fixtures/go/corpus/array-types.diffA-B.txt

@@ -4,9 +4,9 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
-      (
+    (Statements)
+    (Statements
+      (Statements
         (Type
           (Identifier)
           (Array
@@ -17,7 +17,7 @@
             ->(Integer) })
           { (Identifier)
           ->(Identifier) })))
-      (
+      (Statements
         (Type
         { (Identifier)
         ->(Identifier) }
@@ -28,7 +28,7 @@
             { (Integer)
             ->(Integer) }
               (Identifier)))))
-      (
+      (Statements
         (Type
         { (Identifier)
         ->(Identifier) }

test/fixtures/go/corpus/array-types.diffB-A.txt

@@ -4,9 +4,9 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
-      (
+    (Statements)
+    (Statements
+      (Statements
         (Type
           (Identifier)
           (Array
@@ -17,7 +17,7 @@
             ->(Integer) })
           { (Identifier)
           ->(Identifier) })))
-      (
+      (Statements
         (Type
         { (Identifier)
         ->(Identifier) }
@@ -28,7 +28,7 @@
             { (Integer)
             ->(Integer) }
               (Identifier)))))
-      (
+      (Statements
         (Type
         { (Identifier)
         ->(Identifier) }

test/fixtures/go/corpus/array-types.parseA.txt

@@ -4,9 +4,9 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
-      (
+    (Statements)
+    (Statements
+      (Statements
         (Type
           (Identifier)
           (Array
@@ -14,7 +14,7 @@
               (Integer)
               (Integer))
             (Identifier))))
-      (
+      (Statements
         (Type
           (Identifier)
           (Array
@@ -22,7 +22,7 @@
             (Array
               (Integer)
               (Identifier)))))
-      (
+      (Statements
         (Type
           (Identifier)
           (Array

test/fixtures/go/corpus/array-types.parseB.txt

@@ -4,9 +4,9 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
-      (
+    (Statements)
+    (Statements
+      (Statements
         (Type
           (Identifier)
           (Array
@@ -14,7 +14,7 @@
               (Integer)
               (Integer))
             (Identifier))))
-      (
+      (Statements
         (Type
           (Identifier)
           (Array
@@ -22,7 +22,7 @@
             (Array
               (Integer)
               (Identifier)))))
-      (
+      (Statements
         (Type
           (Identifier)
           (Array

test/fixtures/go/corpus/array-with-implicit-length.diffA-B.txt

@@ -4,13 +4,13 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
+    (Statements)
     (Assignment
       (Identifier)
       (Composite
         (Array
           (Identifier))
-        (
+        (Statements
         {+(Integer)+}
         {+(Integer)+}
         { (Integer)

test/fixtures/go/corpus/array-with-implicit-length.diffB-A.txt

@@ -4,13 +4,13 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
+    (Statements)
     (Assignment
       (Identifier)
       (Composite
         (Array
           (Identifier))
-        (
+        (Statements
         {+(Integer)+}
         { (Integer)
         ->(Integer) }

test/fixtures/go/corpus/array-with-implicit-length.parseA.txt

@@ -4,13 +4,13 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
+    (Statements)
     (Assignment
       (Identifier)
       (Composite
         (Array
           (Identifier))
-        (
+        (Statements
           (Integer)
           (Integer)
           (Integer))))))

test/fixtures/go/corpus/array-with-implicit-length.parseB.txt

@@ -4,13 +4,13 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
+    (Statements)
     (Assignment
       (Identifier)
       (Composite
         (Array
           (Identifier))
-        (
+        (Statements
           (Integer)
           (Integer)
           (Integer))))))

test/fixtures/go/corpus/assignment-statements.diffA-B.txt

@@ -4,25 +4,25 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
+    (Statements)
+    (Statements
       (Assignment
       { (Identifier)
       ->(Identifier) }
         (Integer))
       (Assignment
-        (
+        (Statements
         { (Identifier)
         ->(Identifier) }
         { (Identifier)
         ->(Identifier) })
         (Plus
-          (
+          (Statements
           { (Identifier)
           ->(Identifier) }
           { (Identifier)
           ->(Identifier) })
-          (
+          (Statements
             (Integer)
             (Integer))))
     {+(Assignment
@@ -68,13 +68,13 @@
           {+(Integer)+})+})+})+}
     {+(Assignment
       {+(Identifier)+}
-      {+(
+      {+(Statements
         {+(Pointer
           {+(Identifier)+})+}
         {+(Reference
           {+(Composite
             {+(Identifier)+}
-            {+(
+            {+(Statements
               {+(KeyValue
                 {+(Identifier)+}
                 {+(Integer)+})+})+})+})+})+})+}
@@ -121,13 +121,13 @@
           {-(Integer)-})-})-})-}
     {-(Assignment
       {-(Identifier)-}
-      {-(
+      {-(Statements
         {-(Pointer
           {-(Identifier)-})-}
         {-(Reference
           {-(Composite
             {-(Identifier)-}
-            {-(
+            {-(Statements
               {-(KeyValue
                 {-(Identifier)-}
                 {-(Integer)-})-})-})-})-})-})-})))

test/fixtures/go/corpus/assignment-statements.diffB-A.txt

@@ -4,25 +4,25 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
+    (Statements)
+    (Statements
       (Assignment
       { (Identifier)
       ->(Identifier) }
         (Integer))
       (Assignment
-        (
+        (Statements
         { (Identifier)
         ->(Identifier) }
         { (Identifier)
         ->(Identifier) })
         (Plus
-          (
+          (Statements
           { (Identifier)
           ->(Identifier) }
           { (Identifier)
           ->(Identifier) })
-          (
+          (Statements
             (Integer)
             (Integer))))
     {+(Assignment
@@ -68,13 +68,13 @@
           {+(Integer)+})+})+})+}
     {+(Assignment
       {+(Identifier)+}
-      {+(
+      {+(Statements
         {+(Pointer
           {+(Identifier)+})+}
         {+(Reference
           {+(Composite
             {+(Identifier)+}
-            {+(
+            {+(Statements
               {+(KeyValue
                 {+(Identifier)+}
                 {+(Integer)+})+})+})+})+})+})+}
@@ -121,13 +121,13 @@
           {-(Integer)-})-})-})-}
     {-(Assignment
       {-(Identifier)-}
-      {-(
+      {-(Statements
         {-(Pointer
           {-(Identifier)-})-}
         {-(Reference
           {-(Composite
             {-(Identifier)-}
-            {-(
+            {-(Statements
               {-(KeyValue
                 {-(Identifier)-}
                 {-(Integer)-})-})-})-})-})-})-})))

test/fixtures/go/corpus/assignment-statements.parseA.txt

@@ -4,20 +4,20 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
+    (Statements)
+    (Statements
       (Assignment
         (Identifier)
         (Integer))
       (Assignment
-        (
+        (Statements
           (Identifier)
           (Identifier))
         (Plus
-          (
+          (Statements
             (Identifier)
             (Identifier))
-          (
+          (Statements
             (Integer)
             (Integer))))
       (Assignment
@@ -63,13 +63,13 @@
             (Integer))))
       (Assignment
         (Identifier)
-        (
+        (Statements
           (Pointer
             (Identifier))
           (Reference
             (Composite
               (Identifier)
-              (
+              (Statements
                 (KeyValue
                   (Identifier)
                   (Integer))))))))))

test/fixtures/go/corpus/assignment-statements.parseB.txt

@@ -4,20 +4,20 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
+    (Statements)
+    (Statements
       (Assignment
         (Identifier)
         (Integer))
       (Assignment
-        (
+        (Statements
           (Identifier)
           (Identifier))
         (Plus
-          (
+          (Statements
             (Identifier)
             (Identifier))
-          (
+          (Statements
             (Integer)
             (Integer))))
       (Assignment
@@ -63,13 +63,13 @@
             (Integer))))
       (Assignment
         (Identifier)
-        (
+        (Statements
           (Pointer
             (Identifier))
           (Reference
             (Composite
               (Identifier)
-              (
+              (Statements
                 (KeyValue
                   (Identifier)
                   (Integer))))))))))

test/fixtures/go/corpus/binary-expressions.diffA-B.txt

@@ -4,8 +4,8 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
+    (Statements)
+    (Statements
       (Context
         (Comment)
         (Or

test/fixtures/go/corpus/binary-expressions.diffB-A.txt

@@ -4,8 +4,8 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
+    (Statements)
+    (Statements
       (Context
         (Comment)
         (Or

test/fixtures/go/corpus/binary-expressions.parseA.txt

@@ -4,8 +4,8 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
+    (Statements)
+    (Statements
       (Context
         (Comment)
         (Or

test/fixtures/go/corpus/binary-expressions.parseB.txt

@@ -4,8 +4,8 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
+    (Statements)
+    (Statements
       (Context
         (Comment)
         (Or

test/fixtures/go/corpus/call-expressions.diffA-B.txt

@@ -4,12 +4,12 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
+    (Statements)
+    (Statements
       (Call
       { (Identifier)
       ->(Identifier) }
-        (
+        (Statements
           (Identifier)
           (Variadic
             (Identifier)))
@@ -17,25 +17,25 @@
       (Call
       { (Identifier)
       ->(Identifier) }
-        (
+        (Statements
           (Identifier)
           (Identifier))
         (Empty))
     {+(Call
       {+(Identifier)+}
-      {+(
+      {+(Statements
         {+(Identifier)+}
         {+(Variadic
           {+(Identifier)+})+})+}
       {+(Empty)+})+}
     {-(Call
       {-(Identifier)-}
-      {-(
+      {-(Statements
         {-(Identifier)-}
         {-(Variadic
           {-(Identifier)-})-})-}
       {-(Empty)-})-}
     {-(Call
       {-(Identifier)-}
-      {-([])-}
+      {-(Statements)-}
       {-(Empty)-})-})))

test/fixtures/go/corpus/call-expressions.diffB-A.txt

@@ -4,12 +4,12 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
+    (Statements)
+    (Statements
       (Call
       { (Identifier)
       ->(Identifier) }
-        (
+        (Statements
           (Identifier)
           (Variadic
             (Identifier)))
@@ -17,13 +17,13 @@
       (Call
       { (Identifier)
       ->(Identifier) }
-        (
+        (Statements
           (Identifier)
           (Identifier))
         (Empty))
     {+(Call
       {+(Identifier)+}
-      {+(
+      {+(Statements
         {+(Identifier)+}
         {+(Variadic
           {+(Identifier)+})+})+}
@@ -31,8 +31,8 @@
       (Call
       { (Identifier)
       ->(Identifier) }
-      {+([])+}
-      {-(
+      {+(Statements)+}
+      {-(Statements
         {-(Identifier)-}
         {-(Variadic
           {-(Identifier)-})-})-}

test/fixtures/go/corpus/call-expressions.parseA.txt

@@ -4,29 +4,29 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
+    (Statements)
+    (Statements
       (Call
         (Identifier)
-        (
+        (Statements
           (Identifier)
           (Variadic
             (Identifier)))
         (Empty))
       (Call
         (Identifier)
-        (
+        (Statements
           (Identifier)
           (Identifier))
         (Empty))
       (Call
         (Identifier)
-        (
+        (Statements
           (Identifier)
           (Variadic
             (Identifier)))
         (Empty))
       (Call
         (Identifier)
-        ([])
+        (Statements)
         (Empty)))))

test/fixtures/go/corpus/call-expressions.parseB.txt

@@ -4,24 +4,24 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-    (
+    (Statements)
+    (Statements
       (Call
         (Identifier)
-        (
+        (Statements
           (Identifier)
           (Variadic
             (Identifier)))
         (Empty))
       (Call
         (Identifier)
-        (
+        (Statements
           (Identifier)
           (Identifier))
         (Empty))
       (Call
         (Identifier)
-        (
+        (Statements
           (Identifier)
           (Variadic
             (Identifier)))

test/fixtures/go/corpus/case-statements.diffA-B.txt

@@ -4,44 +4,44 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
+    (Statements)
   { (Match
     {-(Empty)-}
-    {-([])-})
-  ->(
+    {-(Statements)-})
+  ->(Statements
     {+(Match
-      {+([])+}
+      {+(Statements)+}
       {+(Pattern
         {+(Identifier)+}
         {+(Call
           {+(Identifier)+}
-          {+([])+}
+          {+(Statements)+}
           {+(Empty)+})+})+})+}
     {+(Match
-      {+(
+      {+(Statements
         {+(Identifier)+})+}
-      {+(
+      {+(Statements
         {+(Pattern
-          {+(
+          {+(Statements
             {+(Integer)+}
             {+(Integer)+})+}
-          {+(
+          {+(Statements
             {+(Call
               {+(Identifier)+}
-              {+([])+}
+              {+(Statements)+}
               {+(Empty)+})+}
             {+(Call
               {+(Identifier)+}
-              {+([])+}
+              {+(Statements)+}
               {+(Empty)+})+}
             {+(Pattern
               {+(Identifier)+}
               {+(Empty)+})+})+})+}
         {+(DefaultPattern
-          {+(
+          {+(Statements
             {+(Call
               {+(Identifier)+}
-              {+([])+}
+              {+(Statements)+}
               {+(Empty)+})+}
             {+(Break
               {+(Empty)+})+})+})+})+})+}) }))

test/fixtures/go/corpus/case-statements.diffB-A.txt

@@ -4,44 +4,44 @@
   (Function
     (Empty)
     (Identifier)
-    ([])
-  { (
+    (Statements)
+  { (Statements
     {-(Match
-      {-([])-}
+      {-(Statements)-}
       {-(Pattern
         {-(Identifier)-}
         {-(Call
           {-(Identifier)-}
-          {-([])-}
+          {-(Statements)-}
           {-(Empty)-})-})-})-}
     {-(Match
-      {-(
+      {-(Statements
         {-(Identifier)-})-}
-      {-(
+      {-(Statements
         {-(Pattern
-          {-(
+          {-(Statements
             {-(Integer)-}
             {-(Integer)-})-}
-          {-(
+          {-(Statements
             {-(Call
               {-(Identifier)-}
-              {-([])-}
+              {-(Statements)-}
               {-(Empty)-})-}
             {-(Call
               {-(Identifier)-}
-              {-([])-}
+              {-(Statements)-}
               {-(Empty)-})-}
             {-(Pattern
               {-(Identifier)-}
               {-(Empty)-})-})-})-}
         {-(DefaultPattern
-          {-(
+          {-(Statements
             {-(Call
               {-(Identifier)-}
-              {-([])-}
+              {-(Statements)-}
               {-(Empty)-})-}
             {-(Break
               {-(Empty)-})-})-})-})-})-})
   ->(Match
     {+(Empty)+}
-    {+([])+}) }))
+    {+(Statements)+}) }))