From 3426a768ba4d20a427f2dcb281ad4087d97a3cfb Mon Sep 17 00:00:00 2001
From: Brandon Bosman <brandobosman@gmail.com>
Date: Wed, 10 Jul 2024 12:26:57 -0400
Subject: [PATCH] Split `ClassInterface.hs` into separate files.

I called them `InterfaceCommon.hs` and `InterfaceGOOL.hs`.  I chose to
postfix the `Shared` and `GOOL` parts so that the files are together
when sorted alphabetically.

I tried not to make any changes to the interface itself; however I did
notice one method I had left in `ValueExpression`, and I moved it to
`OOValueExpression` where it belongs.
---
 code/drasil-gool/lib/GOOL/Drasil.hs           |  65 ++++---
 code/drasil-gool/lib/GOOL/Drasil/CodeInfo.hs  |  35 ++--
 .../{ClassInterface.hs => InterfaceCommon.hs} | 182 ++----------------
 .../lib/GOOL/Drasil/InterfaceGOOL.hs          | 152 +++++++++++++++
 .../lib/GOOL/Drasil/LanguageRenderer.hs       |   2 +-
 .../lib/GOOL/Drasil/LanguageRenderer/CLike.hs |  30 +--
 .../Drasil/LanguageRenderer/CSharpRenderer.hs |  37 ++--
 .../Drasil/LanguageRenderer/CommonPseudoOO.hs | 102 +++++-----
 .../Drasil/LanguageRenderer/Constructors.hs   |   4 +-
 .../Drasil/LanguageRenderer/CppRenderer.hs    |  40 ++--
 .../Drasil/LanguageRenderer/JavaRenderer.hs   |  36 ++--
 .../LanguageRenderer/LanguagePolymorphic.hs   | 103 +++++-----
 .../GOOL/Drasil/LanguageRenderer/Macros.hs    |  95 ++++-----
 .../Drasil/LanguageRenderer/PythonRenderer.hs |  34 ++--
 .../Drasil/LanguageRenderer/SwiftRenderer.hs  |  38 ++--
 .../lib/GOOL/Drasil/RendererClasses.hs        |  25 +--
 16 files changed, 507 insertions(+), 473 deletions(-)
 rename code/drasil-gool/lib/GOOL/Drasil/{ClassInterface.hs => InterfaceCommon.hs} (73%)
 create mode 100644 code/drasil-gool/lib/GOOL/Drasil/InterfaceGOOL.hs

diff --git a/code/drasil-gool/lib/GOOL/Drasil.hs b/code/drasil-gool/lib/GOOL/Drasil.hs
index 8cb6580728..2a78ec98f2 100644
--- a/code/drasil-gool/lib/GOOL/Drasil.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil.hs
@@ -18,39 +18,40 @@ module GOOL.Drasil (Label, GSProgram, SFile, MSBody, MSBlock, VSType,
   libFuncApp, newObj, extNewObj, libNewObj, exists, objMethodCall,
   objMethodCallNamedArgs, objMethodCallMixedArgs, objMethodCallNoParams,
   FunctionSym(..), ($.), selfAccess, GetSet(..), List(..),  listSlice,
-  listIndexExists, at, ObserverPattern(..),
-  StrategyPattern(..), ScopeSym(..), ParameterSym(..), MethodSym(..),
-  privMethod, pubMethod, initializer, nonInitConstructor, StateVarSym(..),
-  privDVar, pubDVar, pubSVar, ClassSym(..), ModuleSym(..), convType, convTypeOO,
-  ProgData(..), FileData(..), ModData(..), ScopeTag(..), CodeType(..),
-  GOOLState(..), lensMStoVS, headers, sources, mainMod, initialState,
-  onStateValue, onCodeList, unCI, unPC, unJC, unCSC, unCPPC, unSC, pyName,
-  pyVersion, jName, jVersion, csName, csVersion, cppName, cppVersion, swiftName,
-  swiftVersion) where
+  listIndexExists, at, ObserverPattern(..), StrategyPattern(..), ScopeSym(..),
+  ParameterSym(..), MethodSym(..), privMethod, pubMethod, initializer,
+  nonInitConstructor, StateVarSym(..), privDVar, pubDVar, pubSVar, ClassSym(..),
+  ModuleSym(..), convType, convTypeOO, ProgData(..), FileData(..), ModData(..),
+  ScopeTag(..), CodeType(..), GOOLState(..), lensMStoVS, headers, sources,
+  mainMod, initialState, onStateValue, onCodeList, unCI, unPC, unJC, unCSC,
+  unCPPC, unSC, pyName, pyVersion, jName, jVersion, csName, csVersion, cppName,
+  cppVersion, swiftName, swiftVersion
+  ) where
 
-import GOOL.Drasil.ClassInterface (Label, GSProgram, SFile, MSBody, MSBlock, 
-  VSType, SVariable, SValue, VSFunction, MSStatement, MSParameter, SMethod,
-  CSStateVar, SClass, FSModule, NamedArgs, Initializers, OOProg,
-  ProgramSym(..), FileSym(..), PermanenceSym(..), BodySym(..), bodyStatements,
-  oneLiner, BlockSym(..), TypeSym(..), OOTypeSym(..), TypeElim(..), ThunkSym(..),
-  VectorType(..), VectorDecl(..), VectorThunk(..), VectorExpression(..),
-  ThunkAssign(..), StatementSym(..), AssignStatement(..), (&=),
-  assignToListIndex, DeclStatement(..), OODeclStatement(..), objDecNewNoParams,
-  extObjDecNewNoParams, IOStatement(..), StringStatement(..),
-  FuncAppStatement(..), OOFuncAppStatement(..), CommentStatement(..),
-  initObserverList, addObserver, ControlStatement(..), switchAsIf, ifNoElse,
-  VariableSym(..), OOVariableSym(..), VariableElim(..), ($->), listOf, listVar,
-  ValueSym(..), Argument(..), Literal(..), MathConstant(..), VariableValue(..),
-  OOVariableValue, CommandLineArgs(..), NumericExpression(..),
-  BooleanExpression(..), Comparison(..), ValueExpression(..),
-  OOValueExpression(..), funcApp, funcAppNamedArgs, selfFuncApp, extFuncApp,
-  libFuncApp, newObj, extNewObj, libNewObj, exists, objMethodCall,
-  objMethodCallNamedArgs, objMethodCallMixedArgs,
-  objMethodCallNoParams, FunctionSym(..), ($.), selfAccess, GetSet(..),
-  List(..), listSlice, listIndexExists, at, ObserverPattern(..),
-  StrategyPattern(..), ScopeSym(..), ParameterSym(..), MethodSym(..),
-  privMethod, pubMethod, initializer, nonInitConstructor, StateVarSym(..),
-  privDVar, pubDVar, pubSVar, ClassSym(..), ModuleSym(..), convType, convTypeOO)
+import GOOL.Drasil.InterfaceCommon (Label, GSProgram, SFile, MSBody, MSBlock, 
+  VSType, SVariable, SValue, MSStatement, MSParameter, SMethod, CSStateVar,
+  SClass, FSModule, NamedArgs, Initializers, ProgramSym(..), FileSym(..),
+  PermanenceSym(..), BodySym(..), bodyStatements, oneLiner, BlockSym(..),
+  TypeSym(..), TypeElim(..), ThunkSym(..), VectorType(..), VectorDecl(..),
+  VectorThunk(..), VectorExpression(..), ThunkAssign(..), StatementSym(..),
+  AssignStatement(..), (&=), assignToListIndex, DeclStatement(..),
+  IOStatement(..), StringStatement(..), FuncAppStatement(..),
+  CommentStatement(..), ControlStatement(..), switchAsIf, ifNoElse,
+  VariableSym(..), VariableElim(..), listOf, listVar, ValueSym(..),
+  Argument(..), Literal(..), MathConstant(..), VariableValue(..),
+  CommandLineArgs(..), NumericExpression(..), BooleanExpression(..),
+  Comparison(..), ValueExpression(..), funcApp, funcAppNamedArgs, extFuncApp,
+  libFuncApp, exists, List(..), listSlice, listIndexExists, at, ScopeSym(..),
+  ParameterSym(..), MethodSym(..), privMethod, pubMethod, initializer,
+  nonInitConstructor, StateVarSym(..), privDVar, pubDVar, pubSVar, ClassSym(..),
+  ModuleSym(..), convType)
+import GOOL.Drasil.InterfaceGOOL (VSFunction, OOProg, OOTypeSym(..),
+  OOVariableSym(..), ($->), OOVariableValue, OOValueExpression(..),
+  selfFuncApp, newObj, extNewObj, libNewObj, OODeclStatement(..),
+  objDecNewNoParams, extObjDecNewNoParams, OOFuncAppStatement(..), GetSet(..),
+  objMethodCall, objMethodCallNamedArgs, objMethodCallMixedArgs,
+  objMethodCallNoParams, FunctionSym(..), ($.), selfAccess, ObserverPattern(..),
+  initObserverList, addObserver, StrategyPattern(..), convTypeOO)
 
 import GOOL.Drasil.AST (FileData(..), ModData(..), ProgData(..), ScopeTag(..))
 
diff --git a/code/drasil-gool/lib/GOOL/Drasil/CodeInfo.hs b/code/drasil-gool/lib/GOOL/Drasil/CodeInfo.hs
index e8727cdd9e..d9fa100afb 100644
--- a/code/drasil-gool/lib/GOOL/Drasil/CodeInfo.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil/CodeInfo.hs
@@ -3,20 +3,22 @@
 -- Performs code analysis on the GOOL code
 module GOOL.Drasil.CodeInfo (CodeInfo(..)) where
 
-import GOOL.Drasil.ClassInterface (MSBody, VSType, SValue, MSStatement, 
-  SMethod, OOProg, ProgramSym(..), FileSym(..), PermanenceSym(..), BodySym(..),
-  BlockSym(..), TypeSym(..), OOTypeSym(..), TypeElim(..), VariableSym(..),
-  OOVariableSym(..), VariableElim(..), ValueSym(..), OOValueSym, Argument(..),
-  Literal(..), MathConstant(..), VariableValue(..), OOVariableValue,
-  CommandLineArgs(..), NumericExpression(..), BooleanExpression(..), Comparison(..),
-  ValueExpression(..), OOValueExpression(..), InternalValueExp(..),
-  FunctionSym(..), GetSet(..), List(..), InternalList(..), ThunkSym(..),
-  VectorType(..), VectorDecl(..), VectorThunk(..), VectorExpression(..),
-  ThunkAssign(..), StatementSym(..), AssignStatement(..), DeclStatement(..),
-  OODeclStatement(..), IOStatement(..), StringStatement(..),
-  FuncAppStatement(..), OOFuncAppStatement(..), CommentStatement(..),
-  ControlStatement(..), ObserverPattern(..), StrategyPattern(..), ScopeSym(..),
-  ParameterSym(..), MethodSym(..), StateVarSym(..), ClassSym(..), ModuleSym(..))
+import GOOL.Drasil.InterfaceCommon (MSBody, VSType, SValue, MSStatement, 
+  SMethod, SharedProg, ProgramSym(..), FileSym(..), PermanenceSym(..),
+  BodySym(..), BlockSym(..), TypeSym(..), TypeElim(..), VariableSym(..),
+  VariableElim(..), ValueSym(..), Argument(..), Literal(..), MathConstant(..),
+  VariableValue(..), CommandLineArgs(..), NumericExpression(..),
+  BooleanExpression(..), Comparison(..), ValueExpression(..), List(..),
+  InternalList(..), ThunkSym(..), VectorType(..), VectorDecl(..),
+  VectorThunk(..), VectorExpression(..), ThunkAssign(..), StatementSym(..),
+  AssignStatement(..), DeclStatement(..), IOStatement(..), StringStatement(..),
+  FuncAppStatement(..), CommentStatement(..), ControlStatement(..),
+  ScopeSym(..), ParameterSym(..), MethodSym(..), StateVarSym(..), ClassSym(..),
+  ModuleSym(..))
+import GOOL.Drasil.InterfaceGOOL (OOProg, OOTypeSym(..), OOVariableSym(..),
+  OOValueSym, OOVariableValue, OOValueExpression(..), InternalValueExp(..),
+  FunctionSym(..), GetSet(..), OODeclStatement(..), OOFuncAppStatement(..),
+  ObserverPattern(..), StrategyPattern(..))
 import GOOL.Drasil.CodeType (CodeType(Void))
 import GOOL.Drasil.AST (ScopeTag(..), qualName)
 import GOOL.Drasil.CodeAnalysis (ExceptionType(..))
@@ -47,7 +49,8 @@ instance Applicative CodeInfo where
 instance Monad CodeInfo where
   CI x >>= f = f x
 
-instance OOProg CodeInfo where
+instance SharedProg CodeInfo
+instance OOProg CodeInfo
 
 instance ProgramSym CodeInfo where
   type Program CodeInfo = GOOLState
@@ -195,7 +198,6 @@ instance Comparison CodeInfo where
 instance ValueExpression CodeInfo where
   inlineIf = execute3
   funcAppMixedArgs n _ = currModCall n
-  selfFuncAppMixedArgs = funcAppMixedArgs
   extFuncAppMixedArgs l n _ vs ns = do
     sequence_ vs
     executePairList ns
@@ -207,6 +209,7 @@ instance ValueExpression CodeInfo where
   notNull = execute1
 
 instance OOValueExpression CodeInfo where
+  selfFuncAppMixedArgs = funcAppMixedArgs
   newObjMixedArgs ot vs ns = do
     sequence_ vs
     executePairList ns
diff --git a/code/drasil-gool/lib/GOOL/Drasil/ClassInterface.hs b/code/drasil-gool/lib/GOOL/Drasil/InterfaceCommon.hs
similarity index 73%
rename from code/drasil-gool/lib/GOOL/Drasil/ClassInterface.hs
rename to code/drasil-gool/lib/GOOL/Drasil/InterfaceCommon.hs
index 7c2940dd35..3003dcc022 100644
--- a/code/drasil-gool/lib/GOOL/Drasil/ClassInterface.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil/InterfaceCommon.hs
@@ -1,38 +1,30 @@
 {-# LANGUAGE TypeFamilies #-}
 
-module GOOL.Drasil.ClassInterface (
+module GOOL.Drasil.InterfaceCommon (
   -- Types
   Label, Library, GSProgram, SFile, MSBody, MSBlock, VSType, SVariable, SValue,
-  VSThunk, VSFunction, MSStatement, MSParameter, SMethod, CSStateVar, SClass,
+  VSThunk, MSStatement, MSParameter, SMethod, CSStateVar, SClass,
   FSModule, NamedArgs, Initializers, MixedCall, MixedCtorCall, PosCall,
-  PosCtorCall,
+  PosCtorCall, InOutCall,
   -- Typeclasses
-  OOProg, ProcProg, ProgramSym(..), FileSym(..), PermanenceSym(..), BodySym(..), 
-  bodyStatements, oneLiner, BlockSym(..), TypeSym(..), OOTypeSym(..), TypeElim(..), 
-  VariableSym(..), OOVariableSym(..), VariableElim(..), ($->), listOf, listVar,
-  ValueSym(..), OOValueSym, Argument(..), Literal(..), litZero,
-  MathConstant(..), VariableValue(..), OOVariableValue, CommandLineArgs(..),
-  NumericExpression(..), BooleanExpression(..), Comparison(..),
-  ValueExpression(..), OOValueExpression(..), funcApp, funcAppNamedArgs,
-  selfFuncApp, extFuncApp, libFuncApp, newObj, extNewObj, libNewObj, exists,
-  InternalValueExp(..), objMethodCall, objMethodCallNamedArgs,
-  objMethodCallMixedArgs, objMethodCallNoParams, FunctionSym(..), ($.),
-  selfAccess, GetSet(..), List(..), InternalList(..), listSlice,
-  listIndexExists, at, ThunkSym(..),
-  VectorType(..), VectorDecl(..), VectorThunk(..), VectorExpression(..),
-  ThunkAssign(..), StatementSym(..), AssignStatement(..), (&=),
-  assignToListIndex, DeclStatement(..), OODeclStatement(..), objDecNewNoParams,
-  extObjDecNewNoParams, IOStatement(..), StringStatement(..),
-  FuncAppStatement(..), OOFuncAppStatement(..), CommentStatement(..),
-  ControlStatement(..), ObserverPattern(..), observerListName, initObserverList,
-  addObserver, StrategyPattern(..), ifNoElse, switchAsIf, ScopeSym(..),
-  ParameterSym(..), MethodSym(..), privMethod, pubMethod, initializer,
-  nonInitConstructor, StateVarSym(..), privDVar, pubDVar, pubSVar, ClassSym(..),
-  ModuleSym(..), convType, convTypeOO
+  SharedProg, ProgramSym(..), FileSym(..), PermanenceSym(..), BodySym(..), 
+  bodyStatements, oneLiner, BlockSym(..), TypeSym(..), TypeElim(..),
+  VariableSym(..), VariableElim(..), listOf, listVar, ValueSym(..),
+  Argument(..), Literal(..), litZero, MathConstant(..), VariableValue(..),
+  CommandLineArgs(..), NumericExpression(..), BooleanExpression(..),
+  Comparison(..), ValueExpression(..), funcApp, funcAppNamedArgs, extFuncApp,
+  libFuncApp, exists, List(..), InternalList(..), listSlice, listIndexExists,
+  at, ThunkSym(..), VectorType(..), VectorDecl(..), VectorThunk(..),
+  VectorExpression(..), ThunkAssign(..), StatementSym(..), AssignStatement(..),
+  (&=), assignToListIndex, DeclStatement(..), IOStatement(..),
+  StringStatement(..), FuncAppStatement(..), CommentStatement(..),
+  ControlStatement(..), ifNoElse, switchAsIf, ScopeSym(..), ParameterSym(..),
+  MethodSym(..), privMethod, pubMethod, initializer, nonInitConstructor,
+  StateVarSym(..), privDVar, pubDVar, pubSVar, ClassSym(..), ModuleSym(..),
+  convType
 ) where
 
-import GOOL.Drasil.CodeType (CodeType(..), ClassName)
-import GOOL.Drasil.Helpers (onStateValue)
+import GOOL.Drasil.CodeType (CodeType(..))
 import GOOL.Drasil.State (GS, FS, CS, MS, VS)
 
 import qualified Data.Kind as K (Type)
@@ -49,22 +41,13 @@ type GSProgram a = GS (a (Program a))
 -- Functions in GOOL's interface beginning with "ext" are to be used to access items from other modules in the same program/project
 -- Functions in GOOL's interface beginning with "lib" are to be used to access items from different libraries/projects
 
-class (ProgramSym r, OOVariableValue r, VectorType r, VectorDecl r, VectorThunk r,
-  VectorExpression r, ThunkAssign r, AssignStatement r, OODeclStatement r,
-  IOStatement r, StringStatement r, OOFuncAppStatement r, CommentStatement r,
-  ControlStatement r, InternalList r, Argument r, Literal r, MathConstant r,
-  VariableValue r, CommandLineArgs r, NumericExpression r, BooleanExpression r,
-  Comparison r, OOValueExpression r, InternalValueExp r, GetSet r, List r,
-  ObserverPattern r, StrategyPattern r, TypeElim r, VariableElim r
-  ) => OOProg r
-
-class (ProgramSym r, VectorType r, VectorDecl r, VectorThunk r,
+class (VectorType r, VectorDecl r, VectorThunk r,
   VectorExpression r, ThunkAssign r, AssignStatement r, DeclStatement r,
   IOStatement r, StringStatement r, FuncAppStatement r, CommentStatement r,
   ControlStatement r, InternalList r, Argument r, Literal r, MathConstant r,
   VariableValue r, CommandLineArgs r, NumericExpression r, BooleanExpression r,
   Comparison r, ValueExpression r, List r, TypeElim r, VariableElim r
-  ) => ProcProg r
+  ) => SharedProg r
 
 -- Shared between OO and Procedural --
 
@@ -142,10 +125,6 @@ class (VariableSym r) => VariableElim r where
   variableName :: r (Variable r) -> String
   variableType :: r (Variable r) -> r (Type r)
 
-($->) :: (OOVariableSym r) => SVariable r -> SVariable r -> SVariable r
-infixl 9 $->
-($->) = objVar
-
 listVar :: (VariableSym r) => Label -> VSType r -> SVariable r
 listVar n t = var n (listType t)
 
@@ -266,7 +245,6 @@ class (VariableSym r, ValueSym r) => ValueExpression r where
   inlineIf     :: SValue r -> SValue r -> SValue r -> SValue r
   
   funcAppMixedArgs     ::            MixedCall r
-  selfFuncAppMixedArgs ::            MixedCall r
   extFuncAppMixedArgs  :: Library -> MixedCall r
   libFuncAppMixedArgs  :: Library -> MixedCall r
 
@@ -281,9 +259,6 @@ funcAppNamedArgs :: (ValueExpression r) =>            Label -> VSType r ->
   NamedArgs r -> SValue r
 funcAppNamedArgs n t = funcAppMixedArgs n t []
 
-selfFuncApp      :: (ValueExpression r) =>            PosCall r
-selfFuncApp n t vs = selfFuncAppMixedArgs n t vs []
-
 extFuncApp       :: (ValueExpression r) => Library -> PosCall r
 extFuncApp l n t vs = extFuncAppMixedArgs l n t vs []
 
@@ -581,117 +556,6 @@ class (ClassSym r) => ModuleSym r where
   type Module r
   buildModule :: Label -> [Label] -> [SMethod r] -> [SClass r] -> FSModule r
 
--- OO Only --
-class (TypeSym r) => OOTypeSym r where
-  obj :: ClassName -> VSType r
-
-class (ValueSym r, OOTypeSym r) => OOValueSym r
-
-class (VariableSym r, OOTypeSym r) => OOVariableSym r where
-  staticVar    :: Label -> VSType r -> SVariable r -- I *think* this is OO-only
-  self         :: SVariable r
-  classVar     :: VSType r -> SVariable r -> SVariable r
-  extClassVar  :: VSType r -> SVariable r -> SVariable r
-  objVar       :: SVariable r -> SVariable r -> SVariable r
-  objVarSelf   :: SVariable r -> SVariable r
-
--- for values that can include expressions
-class (ValueExpression r, OOVariableSym r, OOValueSym r) => OOValueExpression r where
-  newObjMixedArgs      ::            MixedCtorCall r
-  extNewObjMixedArgs   :: Library -> MixedCtorCall r
-  libNewObjMixedArgs   :: Library -> MixedCtorCall r
-
-newObj           :: (OOValueExpression r) =>            PosCtorCall r
-newObj t vs = newObjMixedArgs t vs []
-
-extNewObj        :: (OOValueExpression r) => Library -> PosCtorCall r
-extNewObj l t vs = extNewObjMixedArgs l t vs []
-
-libNewObj        :: (OOValueExpression r) => Library -> PosCtorCall r
-libNewObj l t vs = libNewObjMixedArgs l t vs []
-
-class (VariableValue r, OOVariableSym r) => OOVariableValue r
-
-class (FuncAppStatement r, OOVariableSym r) => OOFuncAppStatement r where
-  selfInOutCall :: InOutCall r
-
-class (DeclStatement r, OOVariableSym r) => OODeclStatement r where
-  objDecDef    :: SVariable r -> SValue r -> MSStatement r
-  objDecNew    :: SVariable r -> [SValue r] -> MSStatement r
-  extObjDecNew :: Library -> SVariable r -> [SValue r] -> MSStatement r
-
-objDecNewNoParams :: (OODeclStatement r) => SVariable r -> MSStatement r
-objDecNewNoParams v = objDecNew v []
-
-extObjDecNewNoParams :: (OODeclStatement r) => Library -> SVariable r -> 
-  MSStatement r
-extObjDecNewNoParams l v = extObjDecNew l v []
-
-class (StatementSym r, FunctionSym r) => ObserverPattern r where
-  notifyObservers :: VSFunction r -> VSType r -> MSStatement r
-
-observerListName :: Label
-observerListName = "observerList"
-
-initObserverList :: (DeclStatement r) => VSType r -> [SValue r] -> MSStatement r
-initObserverList t = listDecDef (var observerListName (listType t))
-
-addObserver :: (StatementSym r, OOVariableValue r, List r) => SValue r -> 
-  MSStatement r
-addObserver o = valStmt $ listAdd obsList lastelem o
-  where obsList = valueOf $ observerListName `listOf` onStateValue valueType o
-        lastelem = listSize obsList
-
-class (BodySym r, VariableSym r) => StrategyPattern r where
-  runStrategy     :: Label -> [(Label, MSBody r)] -> Maybe (SValue r) -> 
-    Maybe (SVariable r) -> MSBlock r
-
-class (ValueSym r) => InternalValueExp r where
-  -- | Generic function for calling a method.
-  --   Takes the function name, the return type, the object, a list of 
-  --   positional arguments, and a list of named arguments.
-  objMethodCallMixedArgs' :: Label -> VSType r -> SValue r -> [SValue r] -> 
-    NamedArgs r -> SValue r
-
--- | Calling a method. t is the return type of the method, o is the
---   object, f is the method name, and ps is a list of positional arguments.
-objMethodCall :: (InternalValueExp r) => VSType r -> SValue r -> Label -> 
-  [SValue r] -> SValue r
-objMethodCall t o f ps = objMethodCallMixedArgs' f t o ps []
-
--- | Calling a method with named arguments.
-objMethodCallNamedArgs :: (InternalValueExp r) => VSType r -> SValue r -> Label 
-  -> NamedArgs r -> SValue r
-objMethodCallNamedArgs t o f = objMethodCallMixedArgs' f t o []
-
--- | Calling a method with a mix of positional and named arguments.
-objMethodCallMixedArgs :: (InternalValueExp r) => VSType r -> SValue r -> Label 
-  -> [SValue r] -> NamedArgs r -> SValue r
-objMethodCallMixedArgs t o f = objMethodCallMixedArgs' f t o
-
--- | Calling a method with no parameters.
-objMethodCallNoParams :: (InternalValueExp r) => VSType r -> SValue r -> Label 
-  -> SValue r
-objMethodCallNoParams t o f = objMethodCall t o f []
-
-type VSFunction a = VS (a (Function a))
-
-class (ValueSym r) => FunctionSym r where
-  type Function r
-  func :: Label -> VSType r -> [SValue r] -> VSFunction r
-  objAccess :: SValue r -> VSFunction r -> SValue r
-
-($.) :: (FunctionSym r) => SValue r -> VSFunction r -> SValue r
-infixl 9 $.
-($.) = objAccess
-
-selfAccess :: (OOVariableValue r, FunctionSym r) => VSFunction r -> SValue r
-selfAccess = objAccess (valueOf self)
-
-class (ValueSym r, VariableSym r) => GetSet r where
-  get :: SValue r -> SVariable r -> SValue r
-  set :: SValue r -> SVariable r -> SValue r -> SValue r
-
 -- Utility
 
 convType :: (TypeSym r) => CodeType -> VSType r
@@ -708,7 +572,3 @@ convType Void = void
 convType InFile = infile
 convType OutFile = outfile
 convType (Object _) = error "Objects not supported"
-
-convTypeOO :: (OOTypeSym r) => CodeType -> VSType r
-convTypeOO (Object n) = obj n
-convTypeOO t = convType t
\ No newline at end of file
diff --git a/code/drasil-gool/lib/GOOL/Drasil/InterfaceGOOL.hs b/code/drasil-gool/lib/GOOL/Drasil/InterfaceGOOL.hs
new file mode 100644
index 0000000000..3ebc9dcc1a
--- /dev/null
+++ b/code/drasil-gool/lib/GOOL/Drasil/InterfaceGOOL.hs
@@ -0,0 +1,152 @@
+{-# LANGUAGE TypeFamilies #-}
+
+module GOOL.Drasil.InterfaceGOOL (
+  -- Types
+  VSFunction,
+  -- Typeclasses
+  OOProg, OOTypeSym(..), OOVariableSym(..),
+  ($->), OOValueSym, OOVariableValue, OOValueExpression(..), selfFuncApp,
+  newObj, extNewObj, libNewObj, OODeclStatement(..), objDecNewNoParams,
+  extObjDecNewNoParams, OOFuncAppStatement(..), GetSet(..),
+  InternalValueExp(..), objMethodCall, objMethodCallNamedArgs,
+  objMethodCallMixedArgs, objMethodCallNoParams, FunctionSym(..), ($.),
+  selfAccess, ObserverPattern(..), observerListName, initObserverList,
+  addObserver, StrategyPattern(..), convTypeOO
+  ) where
+
+import GOOL.Drasil.InterfaceCommon (Label, Library, MSBody, MSBlock, VSType,
+  SVariable, SValue, MSStatement, NamedArgs, MixedCall, MixedCtorCall,
+  PosCall, PosCtorCall, InOutCall, SharedProg, ProgramSym, BodySym,
+  TypeSym(listType), VariableSym(var), ValueSym(valueType),
+  VariableValue(valueOf), ValueExpression, List(listSize, listAdd), listOf,
+  StatementSym(valStmt), DeclStatement(listDecDef), FuncAppStatement, convType)
+import GOOL.Drasil.CodeType (CodeType(..), ClassName)
+import GOOL.Drasil.Helpers (onStateValue)
+import GOOL.Drasil.State (VS)
+
+class (SharedProg r, ProgramSym r, OOVariableValue r, OODeclStatement r,
+  OOFuncAppStatement r, OOValueExpression r, InternalValueExp r, GetSet r,
+  ObserverPattern r, StrategyPattern r
+  ) => OOProg r
+
+class (TypeSym r) => OOTypeSym r where
+  obj :: ClassName -> VSType r
+
+class (ValueSym r, OOTypeSym r) => OOValueSym r
+
+class (VariableSym r, OOTypeSym r) => OOVariableSym r where
+  staticVar    :: Label -> VSType r -> SVariable r -- I *think* this is OO-only
+  self         :: SVariable r
+  classVar     :: VSType r -> SVariable r -> SVariable r
+  extClassVar  :: VSType r -> SVariable r -> SVariable r
+  objVar       :: SVariable r -> SVariable r -> SVariable r
+  objVarSelf   :: SVariable r -> SVariable r
+
+($->) :: (OOVariableSym r) => SVariable r -> SVariable r -> SVariable r
+infixl 9 $->
+($->) = objVar
+
+class (VariableValue r, OOVariableSym r) => OOVariableValue r
+
+-- for values that can include expressions
+class (ValueExpression r, OOVariableSym r, OOValueSym r) => OOValueExpression r where
+  selfFuncAppMixedArgs ::            MixedCall r
+  newObjMixedArgs      ::            MixedCtorCall r
+  extNewObjMixedArgs   :: Library -> MixedCtorCall r
+  libNewObjMixedArgs   :: Library -> MixedCtorCall r
+
+selfFuncApp      :: (OOValueExpression r) =>            PosCall r
+selfFuncApp n t vs = selfFuncAppMixedArgs n t vs []
+
+newObj           :: (OOValueExpression r) =>            PosCtorCall r
+newObj t vs = newObjMixedArgs t vs []
+
+extNewObj        :: (OOValueExpression r) => Library -> PosCtorCall r
+extNewObj l t vs = extNewObjMixedArgs l t vs []
+
+libNewObj        :: (OOValueExpression r) => Library -> PosCtorCall r
+libNewObj l t vs = libNewObjMixedArgs l t vs []
+
+class (ValueSym r) => InternalValueExp r where
+  -- | Generic function for calling a method.
+  --   Takes the function name, the return type, the object, a list of 
+  --   positional arguments, and a list of named arguments.
+  objMethodCallMixedArgs' :: Label -> VSType r -> SValue r -> [SValue r] -> 
+    NamedArgs r -> SValue r
+
+-- | Calling a method. t is the return type of the method, o is the
+--   object, f is the method name, and ps is a list of positional arguments.
+objMethodCall :: (InternalValueExp r) => VSType r -> SValue r -> Label -> 
+  [SValue r] -> SValue r
+objMethodCall t o f ps = objMethodCallMixedArgs' f t o ps []
+
+-- | Calling a method with named arguments.
+objMethodCallNamedArgs :: (InternalValueExp r) => VSType r -> SValue r -> Label 
+  -> NamedArgs r -> SValue r
+objMethodCallNamedArgs t o f = objMethodCallMixedArgs' f t o []
+
+-- | Calling a method with a mix of positional and named arguments.
+objMethodCallMixedArgs :: (InternalValueExp r) => VSType r -> SValue r -> Label 
+  -> [SValue r] -> NamedArgs r -> SValue r
+objMethodCallMixedArgs t o f = objMethodCallMixedArgs' f t o
+
+-- | Calling a method with no parameters.
+objMethodCallNoParams :: (InternalValueExp r) => VSType r -> SValue r -> Label 
+  -> SValue r
+objMethodCallNoParams t o f = objMethodCall t o f []
+
+class (DeclStatement r, OOVariableSym r) => OODeclStatement r where
+  objDecDef    :: SVariable r -> SValue r -> MSStatement r
+  objDecNew    :: SVariable r -> [SValue r] -> MSStatement r
+  extObjDecNew :: Library -> SVariable r -> [SValue r] -> MSStatement r
+
+objDecNewNoParams :: (OODeclStatement r) => SVariable r -> MSStatement r
+objDecNewNoParams v = objDecNew v []
+
+extObjDecNewNoParams :: (OODeclStatement r) => Library -> SVariable r -> 
+  MSStatement r
+extObjDecNewNoParams l v = extObjDecNew l v []
+
+class (FuncAppStatement r, OOVariableSym r) => OOFuncAppStatement r where
+  selfInOutCall :: InOutCall r
+
+class (StatementSym r, FunctionSym r) => ObserverPattern r where
+  notifyObservers :: VSFunction r -> VSType r -> MSStatement r
+
+observerListName :: Label
+observerListName = "observerList"
+
+initObserverList :: (DeclStatement r) => VSType r -> [SValue r] -> MSStatement r
+initObserverList t = listDecDef (var observerListName (listType t))
+
+addObserver :: (StatementSym r, OOVariableValue r, List r) => SValue r -> 
+  MSStatement r
+addObserver o = valStmt $ listAdd obsList lastelem o
+  where obsList = valueOf $ observerListName `listOf` onStateValue valueType o
+        lastelem = listSize obsList
+
+class (BodySym r, VariableSym r) => StrategyPattern r where
+  runStrategy :: Label -> [(Label, MSBody r)] -> Maybe (SValue r) ->
+    Maybe (SVariable r) -> MSBlock r
+
+type VSFunction a = VS (a (Function a))
+
+class (ValueSym r) => FunctionSym r where
+  type Function r
+  func :: Label -> VSType r -> [SValue r] -> VSFunction r
+  objAccess :: SValue r -> VSFunction r -> SValue r
+
+($.) :: (FunctionSym r) => SValue r -> VSFunction r -> SValue r
+infixl 9 $.
+($.) = objAccess
+
+selfAccess :: (OOVariableValue r, FunctionSym r) => VSFunction r -> SValue r
+selfAccess = objAccess (valueOf self)
+
+class (ValueSym r, VariableSym r) => GetSet r where
+  get :: SValue r -> SVariable r -> SValue r
+  set :: SValue r -> SVariable r -> SValue r -> SValue r
+
+convTypeOO :: (OOTypeSym r) => CodeType -> VSType r
+convTypeOO (Object n) = obj n
+convTypeOO t = convType t
diff --git a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer.hs b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer.hs
index 2f40c03d44..2446b1a70b 100644
--- a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer.hs
@@ -28,7 +28,7 @@ module GOOL.Drasil.LanguageRenderer (
 import Utils.Drasil (blank, capitalize, indent, indentList, stringList)
 
 import GOOL.Drasil.CodeType (CodeType(..))
-import GOOL.Drasil.ClassInterface (Label, Library, SValue, BodySym(Body), 
+import GOOL.Drasil.InterfaceCommon (Label, Library, SValue, BodySym(Body), 
   PermanenceSym(Permanence), TypeSym(Type), TypeElim(..), VariableSym(Variable),
   VariableElim(..), ValueSym(..), StatementSym(Statement), ScopeSym(Scope), 
   ParameterSym(Parameter))
diff --git a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CLike.hs b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CLike.hs
index 862cf88fcc..f072c48e60 100644
--- a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CLike.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CLike.hs
@@ -11,13 +11,15 @@ module GOOL.Drasil.LanguageRenderer.CLike (charRender, float, double, char,
 import Utils.Drasil (indent)
 
 import GOOL.Drasil.CodeType (CodeType(..))
-import GOOL.Drasil.ClassInterface (Label, Library, MSBody, VSType, SVariable, 
+import GOOL.Drasil.InterfaceCommon (Label, Library, MSBody, VSType, SVariable, 
   SValue, MSStatement, MSParameter, SMethod, MixedCall, MixedCtorCall, 
   PermanenceSym(..), TypeElim(getType, getTypeString), 
-  VariableElim(..), ValueSym(Value, valueType), extNewObj, ($.), ScopeSym(..))
-import qualified GOOL.Drasil.ClassInterface as S (TypeSym(bool, float),
-  OOTypeSym(obj), ValueExpression(funcAppMixedArgs),
-  OOValueExpression(newObjMixedArgs), DeclStatement(varDec, varDecDef))
+  VariableElim(..), ValueSym(Value, valueType), ScopeSym(..))
+import qualified GOOL.Drasil.InterfaceCommon as IC (TypeSym(bool, float),
+  ValueExpression(funcAppMixedArgs), DeclStatement(varDec, varDecDef))
+import GOOL.Drasil.InterfaceGOOL (extNewObj, ($.))
+import qualified GOOL.Drasil.InterfaceGOOL as IG (OOTypeSym(obj),
+  OOValueExpression(newObjMixedArgs))
 import GOOL.Drasil.RendererClasses (MSMthdType, RenderSym, RenderType(..),
   InternalVarElim(variableBind), RenderValue(valFromData), 
   ValueElim(valuePrec), RenderMethod(intMethod))
@@ -88,18 +90,18 @@ orOp = orPrec "||"
 self :: (RenderSym r) => SVariable r
 self = do 
   l <- zoom lensVStoMS getClassName 
-  mkStateVar R.this (S.obj l) R.this'
+  mkStateVar R.this (IG.obj l) R.this'
 
 -- Values --
 
 litTrue :: (RenderSym r) => SValue r
-litTrue = mkStateVal S.bool (text "true")
+litTrue = mkStateVal IC.bool (text "true")
 
 litFalse :: (RenderSym r) => SValue r
-litFalse = mkStateVal S.bool (text "false")
+litFalse = mkStateVal IC.bool (text "false")
 
 litFloat :: (RenderSym r) => Float -> SValue r
-litFloat f = mkStateVal S.float (D.float f <> text "f")
+litFloat f = mkStateVal IC.float (D.float f <> text "f")
 
 inlineIf :: (RenderSym r) => SValue r -> SValue r -> SValue r -> SValue r
 inlineIf c' v1' v2' = do
@@ -112,11 +114,11 @@ inlineIf c' v1' v2' = do
 
 libFuncAppMixedArgs :: (RenderSym r) => Library -> MixedCall r
 libFuncAppMixedArgs l n t vs ns = modify (addLibImportVS l) >> 
-  S.funcAppMixedArgs n t vs ns
+  IC.funcAppMixedArgs n t vs ns
   
 libNewObjMixedArgs :: (RenderSym r) => Library -> MixedCtorCall r
 libNewObjMixedArgs l tp vs ns = modify (addLibImportVS l) >> 
-  S.newObjMixedArgs tp vs ns
+  IG.newObjMixedArgs tp vs ns
 
 -- Functions --
 
@@ -151,7 +153,7 @@ varDec s d pdoc v' = do
 varDecDef :: (RenderSym r) => Terminator -> SVariable r -> SValue r -> 
   MSStatement r
 varDecDef t vr vl' = do 
-  vd <- S.varDec vr
+  vd <- IC.varDec vr
   vl <- zoom lensMStoVS vl'
   let stmtCtor Empty = mkStmtNoEnd
       stmtCtor Semi = mkStmt
@@ -161,12 +163,12 @@ listDec :: (RenderSym r) => (r (Value r) -> Doc) -> SValue r -> SVariable r ->
   MSStatement r
 listDec f vl v = do 
   sz <- zoom lensMStoVS vl
-  vd <- S.varDec v
+  vd <- IC.varDec v
   mkStmt (RC.statement vd <> f sz)
   
 extObjDecNew :: (RenderSym r) => Library -> SVariable r -> [SValue r] -> 
   MSStatement r
-extObjDecNew l v vs = S.varDecDef v (extNewObj l (onStateValue variableType v)
+extObjDecNew l v vs = IC.varDecDef v (extNewObj l (onStateValue variableType v)
   vs)
 
 -- 1st parameter is a Doc function to apply to the render of the control value (i.e. parens)
diff --git a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CSharpRenderer.hs b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CSharpRenderer.hs
index 7c0d1cb59e..af0857ebd3 100644
--- a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CSharpRenderer.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CSharpRenderer.hs
@@ -10,22 +10,24 @@ module GOOL.Drasil.LanguageRenderer.CSharpRenderer (
 import Utils.Drasil (indent)
 
 import GOOL.Drasil.CodeType (CodeType(..))
-import GOOL.Drasil.ClassInterface (Label, MSBody, VSType, SVariable, SValue, 
-  VSFunction, MSStatement, MSParameter, SMethod, OOProg, ProgramSym(..),
+import GOOL.Drasil.InterfaceCommon (SharedProg, Label, MSBody, VSType,
+  SVariable, SValue, MSStatement, MSParameter, SMethod, ProgramSym(..),
   FileSym(..), PermanenceSym(..), BodySym(..), oneLiner, BlockSym(..),
-  TypeSym(..), OOTypeSym(..), TypeElim(..), VariableSym(..), OOVariableSym(..),
-  VariableElim(..), ValueSym(..), OOValueSym, Argument(..), Literal(..), litZero,
-  MathConstant(..), VariableValue(..), OOVariableValue, CommandLineArgs(..),
-  NumericExpression(..), BooleanExpression(..), Comparison(..),
-  ValueExpression(..), OOValueExpression(..), funcApp, selfFuncApp, extFuncApp,
-  newObj, InternalValueExp(..), objMethodCallNoParams, FunctionSym(..), ($.),
-  GetSet(..), List(..), InternalList(..), ThunkSym(..),
-  VectorType(..), VectorDecl(..), VectorThunk(..), VectorExpression(..),
-  ThunkAssign(..), StatementSym(..), AssignStatement(..), (&=),
-  DeclStatement(..), OODeclStatement(..), IOStatement(..), StringStatement(..),
-  FuncAppStatement(..), OOFuncAppStatement(..), CommentStatement(..), ControlStatement(..),
-  ObserverPattern(..), StrategyPattern(..), ScopeSym(..), ParameterSym(..),
-  MethodSym(..), StateVarSym(..), ClassSym(..), ModuleSym(..))
+  TypeSym(..), TypeElim(..), VariableSym(..), VariableElim(..), ValueSym(..),
+  Argument(..), Literal(..), litZero, MathConstant(..), VariableValue(..),
+  CommandLineArgs(..), NumericExpression(..), BooleanExpression(..),
+  Comparison(..), ValueExpression(..), funcApp, extFuncApp, List(..),
+  InternalList(..), ThunkSym(..), VectorType(..), VectorDecl(..),
+  VectorThunk(..), VectorExpression(..), ThunkAssign(..), StatementSym(..),
+  AssignStatement(..), (&=), DeclStatement(..), IOStatement(..),
+  StringStatement(..), FuncAppStatement(..), CommentStatement(..),
+  ControlStatement(..), ScopeSym(..), ParameterSym(..), MethodSym(..),
+  StateVarSym(..), ClassSym(..), ModuleSym(..))
+import GOOL.Drasil.InterfaceGOOL (VSFunction, OOProg, OOTypeSym(..),
+  OOVariableSym(..), OOValueSym, OOVariableValue, OOValueExpression(..),
+  selfFuncApp, newObj, InternalValueExp(..), objMethodCallNoParams,
+  FunctionSym(..), ($.), GetSet(..), OODeclStatement(..),
+  OOFuncAppStatement(..), ObserverPattern(..), StrategyPattern(..))
 import GOOL.Drasil.RendererClasses (RenderSym, RenderFile(..), ImportSym(..), 
   ImportElim, PermElim(binding), RenderBody(..), BodyElim, RenderBlock(..), 
   BlockElim, RenderType(..), InternalTypeElim, UnaryOpSym(..), BinaryOpSym(..), 
@@ -118,7 +120,8 @@ instance Applicative CSharpCode where
 instance Monad CSharpCode where
   CSC x >>= f = f x
 
-instance OOProg CSharpCode where
+instance SharedProg CSharpCode
+instance OOProg CSharpCode
 
 instance ProgramSym CSharpCode where
   type Program CSharpCode = ProgData
@@ -361,7 +364,6 @@ instance ValueExpression CSharpCode where
   inlineIf = C.inlineIf
 
   funcAppMixedArgs = G.funcAppMixedArgs
-  selfFuncAppMixedArgs = G.selfFuncAppMixedArgs dot self
   extFuncAppMixedArgs = CP.extFuncAppMixedArgs
   libFuncAppMixedArgs = C.libFuncAppMixedArgs
 
@@ -370,6 +372,7 @@ instance ValueExpression CSharpCode where
   notNull = CP.notNull nullLabel
 
 instance OOValueExpression CSharpCode where
+  selfFuncAppMixedArgs = G.selfFuncAppMixedArgs dot self
   newObjMixedArgs = G.newObjMixedArgs (new ++ " ")
   extNewObjMixedArgs _ = newObjMixedArgs
   libNewObjMixedArgs = C.libNewObjMixedArgs
diff --git a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CommonPseudoOO.hs b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CommonPseudoOO.hs
index 60e7e3ed6f..c38253be18 100644
--- a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CommonPseudoOO.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CommonPseudoOO.hs
@@ -16,22 +16,24 @@ module GOOL.Drasil.LanguageRenderer.CommonPseudoOO (int, constructor, doxFunc,
 import Utils.Drasil (indent, stringList)
 
 import GOOL.Drasil.CodeType (CodeType(..))
-import GOOL.Drasil.ClassInterface (Label, Library, SFile, MSBody, VSType,
-  SVariable, SValue, VSFunction, MSStatement, MSParameter, SMethod, CSStateVar,
-  SClass, FSModule, Initializers, MixedCall, PermanenceSym(..), bodyStatements,
-  oneLiner, TypeSym(infile, outfile, listInnerType), OOTypeSym(obj),
-  TypeElim(getType, getTypeString), VariableElim(variableName, variableType),
-  ValueSym(valueType), Comparison(..), objMethodCallNoParams, (&=),
-  ControlStatement(returnStmt), ScopeSym(..), MethodSym(function),
-  NumericExpression((#+), (#-)))
-import qualified GOOL.Drasil.ClassInterface as S (
+import GOOL.Drasil.InterfaceCommon (Label, Library, SFile, MSBody, VSType,
+  SVariable, SValue, MSStatement, MSParameter, SMethod, CSStateVar, SClass,
+  FSModule, Initializers, MixedCall, PermanenceSym(..), bodyStatements,
+  oneLiner, TypeSym(infile, outfile, listInnerType), TypeElim(getType,
+  getTypeString), VariableElim(variableName, variableType), ValueSym(valueType),
+  Comparison(..), (&=), ControlStatement(returnStmt), ScopeSym(..),
+  MethodSym(function), NumericExpression((#+), (#-)))
+import qualified GOOL.Drasil.InterfaceCommon as IC (
   TypeSym(int, double, string, listType, arrayType, void),
-  VariableSym(var), OOVariableSym(self, objVar),
-  Literal(litTrue, litFalse, litList, litInt), VariableValue(valueOf),
-  FunctionSym(func, objAccess), StatementSym(valStmt),
+  VariableSym(var), Literal(litTrue, litFalse, litList, litInt),
+  VariableValue(valueOf), StatementSym(valStmt),
   DeclStatement(varDec, varDecDef, constDecDef), List(intToIndex, indexToInt),
   ParameterSym(param, pointerParam), MethodSym(mainFunction),
   ClassSym(buildClass))
+import GOOL.Drasil.InterfaceGOOL (VSFunction, OOTypeSym(obj),
+  objMethodCallNoParams)
+import qualified GOOL.Drasil.InterfaceGOOL as IG (OOVariableSym(self, objVar),
+  FunctionSym(..))
 import GOOL.Drasil.RendererClasses (RenderSym, ImportSym(..), RenderBody(..), 
   RenderType(..), RenderVariable(varFromData), InternalVarElim(variableBind), 
   RenderFunction(funcFromData), MethodTypeSym(mType),
@@ -125,17 +127,17 @@ classVar f c' v'= do
   toState $ classVarCheckStatic vr
   
 objVarSelf :: (RenderSym r) => SVariable r -> SVariable r
-objVarSelf = S.objVar S.self
+objVarSelf = IG.objVar IG.self
 
 indexOf :: (RenderSym r) => Label -> SValue r -> SValue r -> SValue r
-indexOf f l v = S.indexToInt $ S.objAccess l (S.func f S.int [v])
+indexOf f l v = IC.indexToInt $ IG.objAccess l (IG.func f IC.int [v])
 
 listAddFunc :: (RenderSym r) => Label -> SValue r -> SValue r -> VSFunction r
-listAddFunc f i v = S.func f (S.listType $ onStateValue valueType v) 
+listAddFunc f i v = IG.func f (IC.listType $ onStateValue valueType v) 
   [i, v]
   
 discardFileLine :: (RenderSym r) => Label -> SValue r -> MSStatement r
-discardFileLine n f = S.valStmt $ objMethodCallNoParams S.string f n 
+discardFileLine n f = IC.valStmt $ objMethodCallNoParams IC.string f n 
 
 intClass :: (RenderSym r, Monad r) => (Label -> Doc -> Doc -> Doc -> Doc -> 
   Doc) -> Label -> r (Scope r) -> r ParentSpec -> [CSStateVar r] -> [SMethod r] 
@@ -178,7 +180,7 @@ arrayType t' = do
     (getTypeString t ++ array) (RC.type' t <> brackets empty)
   
 pi :: (RenderSym r) => SValue r
-pi = mkStateVal S.double (text $ mathFunc "PI")
+pi = mkStateVal IC.double (text $ mathFunc "PI")
 
 printSt :: (RenderSym r) => SValue r -> SValue r -> MSStatement r
 printSt va' vb' = do
@@ -199,12 +201,12 @@ arrayDec n vr = do
 arrayDecDef :: (RenderSym r) => SVariable r -> [SValue r] -> MSStatement r
 arrayDecDef v' vals' = do 
   vs <- mapM (zoom lensMStoVS) vals'
-  vd <- S.varDec v'
+  vd <- IC.varDec v'
   mkStmt (RC.statement vd <+> equals <+> braces (valueList vs))
 
 openFileA :: (RenderSym r) => (SValue r -> VSType r -> SValue r -> SValue r) -> 
   SVariable r -> SValue r -> MSStatement r
-openFileA f vr vl = vr &= f vl outfile S.litTrue
+openFileA f vr vl = vr &= f vl outfile IC.litTrue
 
 forEach :: (RenderSym r) => Doc -> Doc -> Doc -> Doc -> SVariable r -> SValue r 
   -> MSBody r -> MSStatement r
@@ -224,18 +226,18 @@ argsDesc = "List of command-line arguments"
 
 docMain :: (RenderSym r) => MSBody r -> SMethod r
 docMain b = commentedFunc (docComment $ toState $ functionDox 
-  mainDesc [(args, argsDesc)] []) (S.mainFunction b)
+  mainDesc [(args, argsDesc)] []) (IC.mainFunction b)
 
 mainFunction :: (RenderSym r) => VSType r -> Label -> MSBody r -> SMethod r
-mainFunction s n = S.intFunc True n public static (mType S.void)
-  [S.param (S.var args (s >>= (\argT -> typeFromData (List String) 
+mainFunction s n = S.intFunc True n public static (mType IC.void)
+  [IC.param (IC.var args (s >>= (\argT -> typeFromData (List String) 
   (render (RC.type' argT) ++ array) (RC.type' argT <> array'))))]
 
 buildModule' :: (RenderSym r) => Label -> (String -> r (Import r)) -> [Label] 
   -> [SMethod r] -> [SClass r] -> FSModule r
 buildModule' n inc is ms cs = S.modFromData n (do
   cls <- mapM (zoom lensFStoCS) 
-          (if null ms then cs else S.buildClass Nothing [] ms : cs) 
+          (if null ms then cs else IC.buildClass Nothing [] ms : cs) 
   lis <- getLangImports
   libis <- getLibImports
   mis <- getModuleImports
@@ -245,7 +247,7 @@ buildModule' n inc is ms cs = S.modFromData n (do
 
 -- Java and C++ --
 
--- | First parameter is language name, rest similar to call from ClassInterface
+-- | First parameter is language name, rest similar to call from RendererClasses
 call' :: (RenderSym r) => String -> Maybe Library -> Maybe Doc -> MixedCall r
 call' l _ _ _ _ _ (_:_) = error $ namedArgError l
 call' _ l o n t ps ns = call empty l o n t ps ns
@@ -254,11 +256,11 @@ namedArgError :: String -> String
 namedArgError l = "Named arguments not supported in " ++ l 
 
 listSizeFunc :: (RenderSym r) => VSFunction r
-listSizeFunc = S.func "size" S.int []
+listSizeFunc = IG.func "size" IC.int []
 
 listAccessFunc' :: (RenderSym r) => Label -> VSType r -> SValue r -> 
   VSFunction r
-listAccessFunc' f t i = S.func f t [intValue i]
+listAccessFunc' f t i = IG.func f t [intValue i]
 
 -- C# and C++ --
 
@@ -295,13 +297,13 @@ extFuncAppMixedArgs :: (RenderSym r) => Library -> MixedCall r
 extFuncAppMixedArgs l = S.call (Just l) Nothing
 
 notNull :: (RenderSym r) => String -> SValue r -> SValue r
-notNull nil v = v ?!= S.valueOf (S.var nil $ onStateValue valueType v)
+notNull nil v = v ?!= IC.valueOf (IC.var nil $ onStateValue valueType v)
 
 listDecDef :: (RenderSym r) => SVariable r -> [SValue r] -> MSStatement r
 listDecDef v vals = do
   vr <- zoom lensMStoVS v 
-  let lst = S.litList (listInnerType $ return $ variableType vr) vals
-  S.varDecDef (return vr) lst
+  let lst = IC.litList (listInnerType $ return $ variableType vr) vals
+  IC.varDecDef (return vr) lst
 
 destructorError :: String -> String
 destructorError l = "Destructors not allowed in " ++ l
@@ -309,17 +311,17 @@ destructorError l = "Destructors not allowed in " ++ l
 stateVarDef :: (RenderSym r, Monad r) => r (Scope r) -> r (Permanence r) -> 
   SVariable r -> SValue r -> CS (r Doc)
 stateVarDef s p vr vl = zoom lensCStoMS $ onStateValue (toCode . R.stateVar 
-  (RC.scope s) (RC.perm p) . RC.statement) (S.stmt $ S.varDecDef vr vl)
+  (RC.scope s) (RC.perm p) . RC.statement) (S.stmt $ IC.varDecDef vr vl)
   
 constVar :: (RenderSym r, Monad r) => Doc -> r (Scope r) -> SVariable r -> 
   SValue r -> CS (r Doc)
 constVar p s vr vl = zoom lensCStoMS $ onStateValue (toCode . R.stateVar 
-  (RC.scope s) p . RC.statement) (S.stmt $ S.constDecDef vr vl)
+  (RC.scope s) p . RC.statement) (S.stmt $ IC.constDecDef vr vl)
 
 -- Python, Java, C++, and Swift --
 
 litArray :: (RenderSym r) => (Doc -> Doc) -> VSType r -> [SValue r] -> SValue r
-litArray f t es = sequence es >>= (\elems -> mkStateVal (S.arrayType t) 
+litArray f t es = sequence es >>= (\elems -> mkStateVal (IC.arrayType t) 
   (f $ valueList elems))
 
 -- Python, C#, C++, and Swift --
@@ -353,12 +355,12 @@ openFileR f vr vl = vr &= f vl infile
 
 openFileW :: (RenderSym r) => (SValue r -> VSType r -> SValue r -> SValue r) -> 
   SVariable r -> SValue r -> MSStatement r
-openFileW f vr vl = vr &= f vl outfile S.litFalse
+openFileW f vr vl = vr &= f vl outfile IC.litFalse
 
 stateVar :: (RenderSym r, Monad r) => r (Scope r) -> r (Permanence r) -> 
   SVariable r -> CS (r Doc)
 stateVar s p v = zoom lensCStoMS $ onStateValue (toCode . R.stateVar 
-  (RC.scope s) (RC.perm p) . RC.statement) (S.stmt $ S.varDec v)
+  (RC.scope s) (RC.perm p) . RC.statement) (S.stmt $ IC.varDec v)
 
 -- Python and Swift --
 
@@ -378,18 +380,18 @@ multiAssign f vars vals = if length vals /= 1 && length vars /= length vals
   vls <- mapM (zoom lensMStoVS) vals
   let wrapIfMult :: [a] -> Doc -> Doc
       wrapIfMult l = if length l > 1 then f else id
-  mkStateVar "" S.void (wrapIfMult vrs (variableList vrs)) &= 
-    mkStateVal S.void (wrapIfMult vls (valueList vls))
+  mkStateVar "" IC.void (wrapIfMult vrs (variableList vrs)) &= 
+    mkStateVal IC.void (wrapIfMult vls (valueList vls))
 
 multiReturn :: (RenderSym r) => (Doc -> Doc) -> [SValue r] -> MSStatement r
 multiReturn _ [] = error "Attempt to write return statement with no values."
 multiReturn _ [v] = returnStmt v
 multiReturn f vs = do
   vs' <- mapM (zoom lensMStoVS) vs
-  returnStmt $ mkStateVal S.void $ f $ valueList vs'
+  returnStmt $ mkStateVal IC.void $ f $ valueList vs'
 
 listDec :: (RenderSym r) => SVariable r -> MSStatement r
-listDec v = S.varDecDef v $ S.litList (onStateValue variableType v) []
+listDec v = IC.varDecDef v $ IC.litList (onStateValue variableType v) []
 
 funcDecDef :: (RenderSym r) => SVariable r -> [SVariable r] -> MSBody r -> 
   MSStatement r
@@ -398,14 +400,14 @@ funcDecDef v ps b = do
   modify $ useVarName $ variableName vr
   s <- get
   f <- function (variableName vr) private (return $ variableType vr) 
-    (map S.param ps) b
+    (map IC.param ps) b
   modify (L.set currParameters (s ^. currParameters))
   mkStmtNoEnd $ RC.method f
 
 inOutCall :: (RenderSym r) => (Label -> VSType r -> [SValue r] -> SValue r) -> 
   Label -> [SValue r] -> [SVariable r] -> [SVariable r] -> MSStatement r
-inOutCall f n ins [] [] = S.valStmt $ f n S.void ins
-inOutCall f n ins outs both = S.multiAssign rets [f n S.void (map S.valueOf 
+inOutCall f n ins [] [] = IC.valStmt $ f n IC.void ins
+inOutCall f n ins outs both = S.multiAssign rets [f n IC.void (map IC.valueOf 
   both ++ ins)]
   where rets = both ++ outs
 
@@ -423,12 +425,12 @@ mainBody b = do
 inOutFunc :: (RenderSym r) => (VSType r -> [MSParameter r] -> MSBody r -> 
   SMethod r) -> [SVariable r] -> [SVariable r] -> [SVariable r] -> MSBody r -> 
   SMethod r
-inOutFunc f ins [] [] b = f S.void (map S.param ins) b
+inOutFunc f ins [] [] b = f IC.void (map IC.param ins) b
 inOutFunc f ins outs both b = f 
   (multiType $ map (onStateValue variableType) rets)  
-  (map S.pointerParam both ++ map S.param ins) 
-  (multiBody [bodyStatements $ map S.varDec outs, b, oneLiner $ S.multiReturn $ 
-  map S.valueOf rets])
+  (map IC.pointerParam both ++ map IC.param ins) 
+  (multiBody [bodyStatements $ map IC.varDec outs, b, oneLiner $ S.multiReturn $ 
+  map IC.valueOf rets])
   where rets = both ++ outs
 
 docInOutFunc' :: (RenderSym r) => FuncDocRenderer -> ([SVariable r] -> 
@@ -503,7 +505,7 @@ listSize l = do
 -- | Call to insert a value into a list in a language where this is not a method.
 listAdd :: (RenderSym r) => SValue r -> SValue r -> SValue r -> SValue r
 listAdd l i v = do
-  f <- S.listAddFunc l (S.intToIndex i) v
+  f <- S.listAddFunc l (IC.intToIndex i) v
   mkVal (RC.functionType f) (RC.function f)
 
 -- | Call to append a value to a list in a language where this is not a method.
@@ -518,8 +520,8 @@ intToIndex' :: (RenderSym r) => SValue r -> SValue r
 intToIndex' v = do 
   v' <- v
   case RC.valueInt v' of
-    (Just i) -> S.litInt (i + 1)
-    Nothing -> v #+ S.litInt 1
+    (Just i) -> IC.litInt (i + 1)
+    Nothing -> v #+ IC.litInt 1
 
 -- | Convert an index to an integer in a 1-indexed language
 --   Since GOOL is 0-indexed, we need to subtract 1
@@ -527,5 +529,5 @@ indexToInt' :: (RenderSym r) => SValue r -> SValue r
 indexToInt' v = do
   v' <- v
   case RC.valueInt v' of
-    (Just i) -> S.litInt (i - 1)
-    Nothing -> v #- S.litInt 1
\ No newline at end of file
+    (Just i) -> IC.litInt (i - 1)
+    Nothing -> v #- IC.litInt 1
\ No newline at end of file
diff --git a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/Constructors.hs b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/Constructors.hs
index 129cbfad1c..8b64b07e74 100644
--- a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/Constructors.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/Constructors.hs
@@ -6,8 +6,8 @@ module GOOL.Drasil.LanguageRenderer.Constructors (
   binExpr', binExprNumDbl', typeBinExpr
 ) where
 
-import GOOL.Drasil.ClassInterface (VSType, MSStatement, SVariable, SValue, TypeSym(..), 
-  TypeElim(..), ValueSym(..))
+import GOOL.Drasil.InterfaceCommon (VSType, MSStatement, SVariable, SValue,
+  TypeSym(..), TypeElim(..), ValueSym(..))
 import GOOL.Drasil.RendererClasses (RenderSym, VSUnOp, VSBinOp, UnaryOpSym(..),
   BinaryOpSym(..), OpElim(uOpPrec, bOpPrec), RenderVariable(..), 
   RenderValue(..), ValueElim(valuePrec), RenderStatement(..))
diff --git a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CppRenderer.hs b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CppRenderer.hs
index f30f033a7e..cdaf04d36b 100644
--- a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CppRenderer.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/CppRenderer.hs
@@ -11,23 +11,24 @@ module GOOL.Drasil.LanguageRenderer.CppRenderer (
 import Utils.Drasil (blank, indent, indentList)
 
 import GOOL.Drasil.CodeType (CodeType(..))
-import GOOL.Drasil.ClassInterface (Label, MSBody, VSType, SVariable, SValue, 
-  VSFunction, MSStatement, MSParameter, SMethod, CSStateVar, NamedArgs, OOProg,
+import GOOL.Drasil.InterfaceCommon (SharedProg, Label, MSBody, VSType,
+  SVariable, SValue, MSStatement, MSParameter, SMethod, CSStateVar, NamedArgs,
   ProgramSym(..), FileSym(..), PermanenceSym(..), BodySym(..), bodyStatements,
-  oneLiner, BlockSym(..), TypeSym(..), OOTypeSym(..), TypeElim(..),
-  VariableSym(..), OOVariableSym(..), VariableElim(..), ValueSym(..), OOValueSym,
-  Argument(..), Literal(..), litZero, MathConstant(..), VariableValue(..),
-  OOVariableValue, CommandLineArgs(..), NumericExpression(..),
-  BooleanExpression(..), Comparison(..), ValueExpression(..),
-  OOValueExpression(..), funcApp, selfFuncApp, extFuncApp, InternalValueExp(..),
-  objMethodCall, FunctionSym(..), ($.), GetSet(..), List(..), InternalList(..),
+  oneLiner, BlockSym(..), TypeSym(..), TypeElim(..), VariableSym(..),
+  VariableElim(..), ValueSym(..), Argument(..), Literal(..), litZero,
+  MathConstant(..), VariableValue(..), CommandLineArgs(..),
+  NumericExpression(..), BooleanExpression(..), Comparison(..),
+  ValueExpression(..), funcApp, extFuncApp, List(..), InternalList(..),
   ThunkSym(..), VectorType(..), VectorDecl(..), VectorThunk(..),
   VectorExpression(..), ThunkAssign(..), StatementSym(..), AssignStatement(..),
-  DeclStatement(..), OODeclStatement(..), IOStatement(..), StringStatement(..),
-  FuncAppStatement(..), OOFuncAppStatement(..), CommentStatement(..),
-  ControlStatement(..), ObserverPattern(..), StrategyPattern(..),
-  ScopeSym(..), ParameterSym(..), MethodSym(..), pubMethod, StateVarSym(..),
-  ClassSym(..), ModuleSym(..))
+  DeclStatement(..), IOStatement(..), StringStatement(..), FuncAppStatement(..),
+  CommentStatement(..), ControlStatement(..), ScopeSym(..), ParameterSym(..),
+  MethodSym(..), pubMethod, StateVarSym(..), ClassSym(..), ModuleSym(..))
+import GOOL.Drasil.InterfaceGOOL (VSFunction, OOProg, OOTypeSym(..),
+  OOVariableSym(..), OOValueSym, OOVariableValue, OOValueExpression(..),
+  selfFuncApp, InternalValueExp(..), objMethodCall, FunctionSym(..), ($.),
+  GetSet(..), OODeclStatement(..), OOFuncAppStatement(..), ObserverPattern(..),
+  StrategyPattern(..))
 import GOOL.Drasil.RendererClasses (RenderSym, RenderFile(..), ImportSym(..), 
   ImportElim, PermElim(binding), RenderBody(..), BodyElim, RenderBlock(..), 
   BlockElim, RenderType(..), InternalTypeElim, UnaryOpSym(..), BinaryOpSym(..), 
@@ -130,6 +131,7 @@ unCPPC (CPPC (CPPSC a) _) = a
 hdrToSrc :: CppHdrCode a -> CppSrcCode a
 hdrToSrc (CPPHC a) = CPPSC a
 
+instance (Pair p) => SharedProg (p CppSrcCode CppHdrCode)
 instance (Pair p) => OOProg (p CppSrcCode CppHdrCode)
 
 instance (Pair p) => ProgramSym (p CppSrcCode CppHdrCode) where
@@ -371,9 +373,6 @@ instance (Pair p) => ValueExpression (p CppSrcCode CppHdrCode) where
   inlineIf = pair3 inlineIf inlineIf
 
   funcAppMixedArgs n = pair1Val3Lists (funcAppMixedArgs n) (funcAppMixedArgs n)
-  selfFuncAppMixedArgs n = pair1Val3Lists
-    (selfFuncAppMixedArgs n) 
-    (selfFuncAppMixedArgs n) 
   extFuncAppMixedArgs l n = pair1Val3Lists
     (extFuncAppMixedArgs l n) 
     (extFuncAppMixedArgs l n) 
@@ -386,6 +385,9 @@ instance (Pair p) => ValueExpression (p CppSrcCode CppHdrCode) where
   notNull = pair1 notNull notNull
 
 instance (Pair p) => OOValueExpression (p CppSrcCode CppHdrCode) where
+  selfFuncAppMixedArgs n = pair1Val3Lists
+    (selfFuncAppMixedArgs n)
+    (selfFuncAppMixedArgs n)
   newObjMixedArgs = pair1Val3Lists newObjMixedArgs newObjMixedArgs
   extNewObjMixedArgs l = pair1Val3Lists
     (extNewObjMixedArgs l) 
@@ -1280,7 +1282,6 @@ instance ValueExpression CppSrcCode where
   inlineIf = C.inlineIf
 
   funcAppMixedArgs = G.funcAppMixedArgs
-  selfFuncAppMixedArgs = G.selfFuncAppMixedArgs ptrAccess' self
   extFuncAppMixedArgs l n t vs ns = do
     modify (addModuleImportVS l)
     funcAppMixedArgs n t vs ns
@@ -1291,6 +1292,7 @@ instance ValueExpression CppSrcCode where
   notNull v = v
 
 instance OOValueExpression CppSrcCode where
+  selfFuncAppMixedArgs = G.selfFuncAppMixedArgs ptrAccess' self
   newObjMixedArgs = G.newObjMixedArgs ""
   extNewObjMixedArgs l t vs ns = do
     modify (addModuleImportVS l)
@@ -1962,7 +1964,6 @@ instance ValueExpression CppHdrCode where
   inlineIf _ _ _ = mkStateVal void empty
 
   funcAppMixedArgs _ _ _ _ = mkStateVal void empty
-  selfFuncAppMixedArgs _ _ _ _ = mkStateVal void empty
   extFuncAppMixedArgs _ _ _ _ _ = mkStateVal void empty
   libFuncAppMixedArgs _ _ _ _ _ = mkStateVal void empty
 
@@ -1971,6 +1972,7 @@ instance ValueExpression CppHdrCode where
   notNull _ = mkStateVal void empty
 
 instance OOValueExpression CppHdrCode where
+  selfFuncAppMixedArgs _ _ _ _ = mkStateVal void empty
   newObjMixedArgs _ _ _ = mkStateVal void empty
   extNewObjMixedArgs _ _ _ _ = mkStateVal void empty
   libNewObjMixedArgs _ _ _ _ = mkStateVal void empty
diff --git a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/JavaRenderer.hs b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/JavaRenderer.hs
index f795580670..46040c668d 100644
--- a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/JavaRenderer.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/JavaRenderer.hs
@@ -10,22 +10,23 @@ module GOOL.Drasil.LanguageRenderer.JavaRenderer (
 import Utils.Drasil (indent)
 
 import GOOL.Drasil.CodeType (CodeType(..))
-import GOOL.Drasil.ClassInterface (Label, MSBody, VSType, SVariable, SValue, 
-  VSFunction, MSStatement, MSParameter, SMethod, CSStateVar, SClass, OOProg,
+import GOOL.Drasil.InterfaceCommon (SharedProg, Label, MSBody, VSType,
+  SVariable, SValue, MSStatement, MSParameter, SMethod, CSStateVar, SClass,
   ProgramSym(..), FileSym(..), PermanenceSym(..), BodySym(..), oneLiner,
-  BlockSym(..), TypeSym(..), OOTypeSym(..), TypeElim(..), VariableSym(..),
-  OOVariableSym(..), VariableElim(..), ValueSym(..), OOValueSym, Argument(..),
-  Literal(..), litZero, MathConstant(..), VariableValue(..), OOVariableValue,
-  CommandLineArgs(..), NumericExpression(..), BooleanExpression(..), Comparison(..),
-  ValueExpression(..), OOValueExpression(..), funcApp, selfFuncApp, extFuncApp,
-  newObj, InternalValueExp(..), FunctionSym(..), ($.), GetSet(..), List(..),
-  InternalList(..), ThunkSym(..), VectorType(..), VectorDecl(..),
-  VectorThunk(..), VectorExpression(..), ThunkAssign(..), StatementSym(..),
-  AssignStatement(..), (&=), DeclStatement(..), OODeclStatement(..),
+  BlockSym(..), TypeSym(..), TypeElim(..), VariableSym(..), VariableElim(..),
+  ValueSym(..), Argument(..), Literal(..), litZero, MathConstant(..),
+  VariableValue(..), CommandLineArgs(..), NumericExpression(..),
+  BooleanExpression(..), Comparison(..), ValueExpression(..), funcApp,
+  extFuncApp, List(..), InternalList(..), ThunkSym(..), VectorType(..),
+  VectorDecl(..), VectorThunk(..), VectorExpression(..), ThunkAssign(..),
+  StatementSym(..), AssignStatement(..), (&=), DeclStatement(..),
   IOStatement(..), StringStatement(..), FuncAppStatement(..),
-  OOFuncAppStatement(..), CommentStatement(..), ControlStatement(..),
-  ObserverPattern(..), StrategyPattern(..), ScopeSym(..), ParameterSym(..),
+  CommentStatement(..), ControlStatement(..), ScopeSym(..), ParameterSym(..),
   MethodSym(..), StateVarSym(..), ClassSym(..), ModuleSym(..))
+import GOOL.Drasil.InterfaceGOOL (VSFunction, OOProg, OOTypeSym(..), OOVariableSym(..),
+  OOValueSym, OOVariableValue, OOValueExpression(..), selfFuncApp, newObj,
+  InternalValueExp(..), FunctionSym(..), ($.), GetSet(..), OODeclStatement(..),
+  OOFuncAppStatement(..), ObserverPattern(..), StrategyPattern(..))
 import GOOL.Drasil.RendererClasses (RenderSym, RenderFile(..), ImportSym(..), 
   ImportElim, PermElim(binding), RenderBody(..), BodyElim, RenderBlock(..), 
   BlockElim, RenderType(..), InternalTypeElim, UnaryOpSym(..), BinaryOpSym(..), 
@@ -128,7 +129,8 @@ instance Applicative JavaCode where
 instance Monad JavaCode where
   JC x >>= f = f x
 
-instance OOProg JavaCode where
+instance SharedProg JavaCode
+instance OOProg JavaCode
 
 instance ProgramSym JavaCode where
   type Program JavaCode = ProgData
@@ -377,9 +379,6 @@ instance ValueExpression JavaCode where
   funcAppMixedArgs n t vs ns = do
     addCallExcsCurrMod n 
     G.funcAppMixedArgs n t vs ns
-  selfFuncAppMixedArgs n t ps ns = do
-    addCallExcsCurrMod n
-    G.selfFuncAppMixedArgs dot self n t ps ns
   extFuncAppMixedArgs l n t vs ns = do
     mem <- getMethodExcMap
     modify (maybe id addExceptions (Map.lookup (qualName l n) mem))
@@ -391,6 +390,9 @@ instance ValueExpression JavaCode where
   notNull = CP.notNull nullLabel
 
 instance OOValueExpression JavaCode where
+  selfFuncAppMixedArgs n t ps ns = do
+    addCallExcsCurrMod n
+    G.selfFuncAppMixedArgs dot self n t ps ns
   newObjMixedArgs ot vs ns = addConstructorCallExcsCurrMod ot (\t -> 
     G.newObjMixedArgs (new ++ " ") t vs ns)
   extNewObjMixedArgs l ot vs ns = do
diff --git a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/LanguagePolymorphic.hs b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/LanguagePolymorphic.hs
index eb3d02d0ab..7d23d41772 100644
--- a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/LanguagePolymorphic.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/LanguagePolymorphic.hs
@@ -19,25 +19,26 @@ module GOOL.Drasil.LanguageRenderer.LanguagePolymorphic (fileFromData,
 import Utils.Drasil (indent)
 
 import GOOL.Drasil.CodeType (CodeType(..), ClassName)
-import GOOL.Drasil.ClassInterface (Label, Library, SFile, MSBody, MSBlock, 
-  VSType, SVariable, SValue, VSFunction, MSStatement, MSParameter, SMethod,
-  CSStateVar, SClass, FSModule, NamedArgs, Initializers, MixedCall,
-  MixedCtorCall, FileSym(File), BodySym(Body), bodyStatements, oneLiner,
-  BlockSym(Block), PermanenceSym(..), TypeSym(Type), TypeElim(getType,
-  getTypeString), VariableSym(Variable), VariableElim(variableName,
-  variableType), ValueSym(Value, valueType), NumericExpression((#-), (#/), sin,
-  cos, tan), Comparison(..), funcApp, newObj, objMethodCallNoParams, ($.),
-  StatementSym(multi), AssignStatement((&++)), (&=), IOStatement(printStr,
-  printStrLn, printFile, printFileStr, printFileStrLn), ifNoElse, ScopeSym(..),
-  ModuleSym(Module), convTypeOO)
-import qualified GOOL.Drasil.ClassInterface as S (
-  TypeSym(int, double, char, string, listType, arrayType, listInnerType,
-  funcType, void), VariableSym(var), OOVariableSym(objVarSelf),
+import GOOL.Drasil.InterfaceCommon (Label, Library, SFile, MSBody, MSBlock, 
+  VSType, SVariable, SValue, MSStatement, MSParameter, SMethod, CSStateVar,
+  SClass, FSModule, NamedArgs, Initializers, MixedCall, MixedCtorCall,
+  FileSym(File), BodySym(Body), bodyStatements, oneLiner, BlockSym(Block),
+  PermanenceSym(..), TypeSym(Type), TypeElim(getType, getTypeString),
+  VariableSym(Variable), VariableElim(variableName, variableType),
+  ValueSym(Value, valueType), NumericExpression((#-), (#/), sin, cos, tan),
+  Comparison(..), funcApp, StatementSym(multi), AssignStatement((&++)), (&=),
+  IOStatement(printStr, printStrLn, printFile, printFileStr, printFileStrLn),
+  ifNoElse, ScopeSym(..), ModuleSym(Module))
+import qualified GOOL.Drasil.InterfaceCommon as IC (TypeSym(int, double, char,
+  string, listType, arrayType, listInnerType, funcType, void), VariableSym(var), 
   Literal(litInt, litFloat, litDouble, litString), VariableValue(valueOf),
-  FunctionSym(func), List(listSize, listAccess), StatementSym(valStmt),
-  DeclStatement(varDecDef), IOStatement(print),
-  ControlStatement(returnStmt, for), ParameterSym(param), MethodSym(method),
-  List(intToIndex))
+  List(listSize, listAccess), StatementSym(valStmt), DeclStatement(varDecDef),
+  IOStatement(print), ControlStatement(returnStmt, for), ParameterSym(param),
+  MethodSym(method), List(intToIndex))
+import GOOL.Drasil.InterfaceGOOL (VSFunction, newObj, objMethodCallNoParams, ($.),
+  convTypeOO)
+import qualified GOOL.Drasil.InterfaceGOOL as IG (OOVariableSym(objVarSelf),
+  FunctionSym(func))
 import GOOL.Drasil.RendererClasses (RenderSym, RenderFile(commentedMod),  
   RenderType(..), InternalVarElim(variableBind), RenderValue(valFromData),
   RenderFunction(funcFromData), FunctionElim(functionType), 
@@ -116,8 +117,8 @@ cot v = valOfOne (fmap valueType v) #/ tan v
 
 valOfOne :: (RenderSym r) => VSType r -> SValue r
 valOfOne t = t >>= (getVal . getType)
-  where getVal Float = S.litFloat 1.0
-        getVal _ = S.litDouble 1.0
+  where getVal Float = IC.litFloat 1.0
+        getVal _ = IC.litDouble 1.0
 
 -- Binary Operators --
 
@@ -192,16 +193,16 @@ arrayElem i' v' = do
 -- Values --
 
 litChar :: (RenderSym r) => (Doc -> Doc) -> Char -> SValue r
-litChar f c = mkStateVal S.char (f $ if c == '\n' then text "\\n" else D.char c)
+litChar f c = mkStateVal IC.char (f $ if c == '\n' then text "\\n" else D.char c)
 
 litDouble :: (RenderSym r) => Double -> SValue r
-litDouble d = mkStateVal S.double (D.double d)
+litDouble d = mkStateVal IC.double (D.double d)
 
 litInt :: (RenderSym r) => Integer -> SValue r
-litInt i = valFromData Nothing (Just i) S.int (integer i)
+litInt i = valFromData Nothing (Just i) IC.int (integer i)
 
 litString :: (RenderSym r) => String -> SValue r
-litString s = mkStateVal S.string (doubleQuotedText s)
+litString s = mkStateVal IC.string (doubleQuotedText s)
 
 valueOf :: (RenderSym r) => SVariable r -> SValue r
 valueOf v' = do 
@@ -212,11 +213,11 @@ arg :: (RenderSym r) => SValue r -> SValue r -> SValue r
 arg n' args' = do 
   n <- n'
   args <- args'
-  s <- S.string
+  s <- IC.string
   mkVal s (R.arg n args)
 
 argsList :: (RenderSym r) => String -> SValue r
-argsList l = mkStateVal (S.arrayType S.string) (text l)
+argsList l = mkStateVal (IC.arrayType IC.string) (text l)
 
 -- | First parameter is separator between name and value for named arguments, 
 -- rest similar to call from RendererClasses
@@ -249,7 +250,7 @@ lambda :: (RenderSym r) => ([r (Variable r)] -> r (Value r) -> Doc) ->
 lambda f ps' ex' = do
   ps <- sequence ps'
   ex <- ex'
-  let ft = S.funcType (map (return . variableType) ps) (return $ valueType ex)
+  let ft = IC.funcType (map (return . variableType) ps) (return $ valueType ex)
   valFromData (Just 0) Nothing ft (f ps ex)
 
 objAccess :: (RenderSym r) => SValue r -> VSFunction r -> SValue r
@@ -273,7 +274,7 @@ set :: (RenderSym r) => SValue r -> SVariable r -> SValue r -> SValue r
 set v vToSet toVal = v $. S.setFunc (onStateValue valueType v) vToSet toVal
 
 listAdd :: (RenderSym r) => SValue r -> SValue r -> SValue r -> SValue r
-listAdd v i vToAdd = v $. S.listAddFunc v (S.intToIndex i) vToAdd
+listAdd v i vToAdd = v $. S.listAddFunc v (IC.intToIndex i) vToAdd
 
 listAppend :: (RenderSym r) => SValue r -> SValue r -> SValue r
 listAppend v vToApp = v $. S.listAppendFunc v vToApp
@@ -281,27 +282,27 @@ listAppend v vToApp = v $. S.listAppendFunc v vToApp
 listAccess :: (RenderSym r) => SValue r -> SValue r -> SValue r
 listAccess v i = do
   v' <- v
-  let i' = S.intToIndex i
-      checkType (List _) = S.listAccessFunc (S.listInnerType $ return $ 
+  let i' = IC.intToIndex i
+      checkType (List _) = S.listAccessFunc (IC.listInnerType $ return $ 
         valueType v') i'
       checkType (Array _) = i' >>= (\ix -> funcFromData (brackets (RC.value ix)) 
-        (S.listInnerType $ return $ valueType v'))
+        (IC.listInnerType $ return $ valueType v'))
       checkType _ = error "listAccess called on non-list-type value"
   v $. checkType (getType (valueType v'))
 
 listSet :: (RenderSym r) => SValue r -> SValue r -> SValue r -> SValue r
-listSet v i toVal = v $. S.listSetFunc v (S.intToIndex i) toVal
+listSet v i toVal = v $. S.listSetFunc v (IC.intToIndex i) toVal
 
 getFunc :: (RenderSym r) => SVariable r -> VSFunction r
-getFunc v = v >>= (\vr -> S.func (getterName $ variableName vr) 
+getFunc v = v >>= (\vr -> IG.func (getterName $ variableName vr) 
   (toState $ variableType vr) [])
 
 setFunc :: (RenderSym r) => VSType r -> SVariable r -> SValue r -> VSFunction r
-setFunc t v toVal = v >>= (\vr -> S.func (setterName $ variableName vr) t 
+setFunc t v toVal = v >>= (\vr -> IG.func (setterName $ variableName vr) t 
   [toVal])
 
 listAppendFunc :: (RenderSym r) => Label -> SValue r -> VSFunction r
-listAppendFunc f v = S.func f (S.listType $ onStateValue valueType v) [v]
+listAppendFunc f v = IG.func f (IC.listType $ onStateValue valueType v) [v]
 
 -- Statements --
 
@@ -337,19 +338,19 @@ increment vr' v'= do
   mkStmt $ R.addAssign vr v
 
 objDecNew :: (RenderSym r) => SVariable r -> [SValue r] -> MSStatement r
-objDecNew v vs = S.varDecDef v (newObj (onStateValue variableType v) vs)
+objDecNew v vs = IC.varDecDef v (newObj (onStateValue variableType v) vs)
 
 printList :: (RenderSym r) => Integer -> SValue r -> (SValue r -> MSStatement r)
   -> (String -> MSStatement r) -> (String -> MSStatement r) -> MSStatement r
 printList n v prFn prStrFn prLnFn = multi [prStrFn "[", 
-  S.for (S.varDecDef i (S.litInt 0)) 
-    (S.valueOf i ?< (S.listSize v #- S.litInt 1)) (i &++) 
-    (bodyStatements [prFn (S.listAccess v (S.valueOf i)), prStrFn ", "]), 
-  ifNoElse [(S.listSize v ?> S.litInt 0, oneLiner $
-    prFn (S.listAccess v (S.listSize v #- S.litInt 1)))], 
+  IC.for (IC.varDecDef i (IC.litInt 0)) 
+    (IC.valueOf i ?< (IC.listSize v #- IC.litInt 1)) (i &++) 
+    (bodyStatements [prFn (IC.listAccess v (IC.valueOf i)), prStrFn ", "]), 
+  ifNoElse [(IC.listSize v ?> IC.litInt 0, oneLiner $
+    prFn (IC.listAccess v (IC.listSize v #- IC.litInt 1)))], 
   prLnFn "]"]
   where l_i = "list_i" ++ show n
-        i = S.var l_i S.int
+        i = IC.var l_i IC.int
 
 printObj :: ClassName -> (String -> MSStatement r) -> MSStatement r
 printObj n prLnFn = prLnFn $ "Instance of " ++ n ++ " object"
@@ -361,13 +362,13 @@ print newLn f printFn v = zoom lensMStoVS v >>= print' . getType . valueType
           prLnFn
         print' (Object n) = printObj n prLnFn
         print' _ = S.printSt newLn f printFn v
-        prFn = maybe S.print printFile f
+        prFn = maybe IC.print printFile f
         prStrFn = maybe printStr printFileStr f
         prLnFn = if newLn then maybe printStrLn printFileStrLn f else maybe 
           printStr printFileStr f 
 
 closeFile :: (RenderSym r) => Label -> SValue r -> MSStatement r
-closeFile n f = S.valStmt $ objMethodCallNoParams S.void f n
+closeFile n f = IC.valStmt $ objMethodCallNoParams IC.void f n
 
 returnStmt :: (RenderSym r) => Terminator -> SValue r -> MSStatement r
 returnStmt t v' = do 
@@ -385,7 +386,7 @@ comment cs c = mkStmtNoEnd (R.comment c cs)
 throw :: (RenderSym r) => (r (Value r) -> Doc) -> Terminator -> Label -> 
   MSStatement r
 throw f t l = do 
-  msg <- zoom lensMStoVS (S.litString l)
+  msg <- zoom lensMStoVS (IC.litString l)
   stmtFromData (f msg) t
 
 newtype OptionalSpace = OSpace {oSpace :: Doc}
@@ -444,17 +445,17 @@ method :: (RenderSym r) => Label -> r (Scope r) -> r (Permanence r) -> VSType r
 method n s p t = intMethod False n s p (mType t)
 
 getMethod :: (RenderSym r) => SVariable r -> SMethod r
-getMethod v = zoom lensMStoVS v >>= (\vr -> S.method (getterName $ variableName 
+getMethod v = zoom lensMStoVS v >>= (\vr -> IC.method (getterName $ variableName 
   vr) public dynamic (toState $ variableType vr) [] getBody)
-  where getBody = oneLiner $ S.returnStmt (S.valueOf $ S.objVarSelf v)
+  where getBody = oneLiner $ IC.returnStmt (IC.valueOf $ IG.objVarSelf v)
 
 setMethod :: (RenderSym r) => SVariable r -> SMethod r
-setMethod v = zoom lensMStoVS v >>= (\vr -> S.method (setterName $ variableName 
-  vr) public dynamic S.void [S.param v] setBody)
-  where setBody = oneLiner $ S.objVarSelf v &= S.valueOf v
+setMethod v = zoom lensMStoVS v >>= (\vr -> IC.method (setterName $ variableName 
+  vr) public dynamic IC.void [IC.param v] setBody)
+  where setBody = oneLiner $ IG.objVarSelf v &= IC.valueOf v
 
 initStmts :: (RenderSym r) => Initializers r -> MSBody r
-initStmts = bodyStatements . map (\(vr, vl) -> S.objVarSelf vr &= vl)
+initStmts = bodyStatements . map (\(vr, vl) -> IG.objVarSelf vr &= vl)
 
 function :: (RenderSym r) => Label -> r (Scope r) -> VSType r -> 
   [MSParameter r] -> MSBody r -> SMethod r
diff --git a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/Macros.hs b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/Macros.hs
index 15be363723..ad87df7696 100644
--- a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/Macros.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/Macros.hs
@@ -8,18 +8,19 @@ module GOOL.Drasil.LanguageRenderer.Macros (
 ) where
 
 import GOOL.Drasil.CodeType (CodeType(..))
-import GOOL.Drasil.ClassInterface (Label, MSBody, MSBlock, VSType, SVariable, 
-  SValue, VSFunction, MSStatement, bodyStatements, oneLiner, TypeElim(getType),
+import GOOL.Drasil.InterfaceCommon (Label, MSBody, MSBlock, VSType, SVariable, 
+  SValue, MSStatement, bodyStatements, oneLiner, TypeElim(getType),
   VariableElim(variableType), listOf, ValueSym(valueType), 
   NumericExpression((#+), (#-), (#*), (#/)), Comparison(..),
-  BooleanExpression((?&&), (?||)), at, ($.), StatementSym(multi),
-  AssignStatement((&+=), (&-=), (&++)), (&=), observerListName)
-import qualified GOOL.Drasil.ClassInterface as S (BlockSym(block), 
+  BooleanExpression((?&&), (?||)), at, StatementSym(multi),
+  AssignStatement((&+=), (&-=), (&++)), (&=))
+import qualified GOOL.Drasil.InterfaceCommon as IC (BlockSym(block), 
   TypeSym(int, listInnerType), VariableSym(var), Literal(litInt), 
   VariableValue(valueOf), ValueExpression(notNull), 
   List(listSize, listAppend, listAccess, intToIndex), StatementSym(valStmt), 
   AssignStatement(assign), DeclStatement(varDecDef, listDec), 
   ControlStatement(ifCond, for, forRange), ValueExpression(inlineIf))
+import GOOL.Drasil.InterfaceGOOL (VSFunction, ($.), observerListName)
 import GOOL.Drasil.RendererClasses (RenderSym, RenderValue(cast), 
   ValueElim(valueInt))
 import qualified GOOL.Drasil.RendererClasses as S (
@@ -35,16 +36,16 @@ import Control.Lens.Zoom (zoom)
 import Text.PrettyPrint.HughesPJ (Doc, vcat)
 
 ifExists :: (RenderSym r) => SValue r -> MSBody r -> MSBody r -> MSStatement r
-ifExists v ifBody = S.ifCond [(S.notNull v, ifBody)]
+ifExists v ifBody = IC.ifCond [(IC.notNull v, ifBody)]
 
 decrement1 :: (RenderSym r) => SVariable r -> MSStatement r
-decrement1 v = v &-= S.litInt 1
+decrement1 v = v &-= IC.litInt 1
 
 increment :: (RenderSym r) => SVariable r -> SValue r -> MSStatement r
-increment vr vl = vr &= S.valueOf vr #+ vl
+increment vr vl = vr &= IC.valueOf vr #+ vl
 
 increment1 :: (RenderSym r) => SVariable r -> MSStatement r
-increment1 vr = vr &+= S.litInt 1
+increment1 vr = vr &+= IC.litInt 1
 
 strat :: (RenderSym r, Monad r) => MSStatement r -> MSBody r -> MS (r Doc)
 strat = on2StateValues (\result b -> toCode $ vcat [RC.body b, 
@@ -66,16 +67,16 @@ listSlice beg end step vnew vold = do
   
   l_temp <- genVarName [] "temp"
   l_i <- genLoopIndex
-  let var_temp = S.var l_temp (onStateValue variableType vnew)
-      v_temp = S.valueOf var_temp
-      var_i = S.var l_i S.int
-      v_i = S.valueOf var_i
+  let var_temp = IC.var l_temp (onStateValue variableType vnew)
+      v_temp = IC.valueOf var_temp
+      var_i = IC.var l_i IC.int
+      v_i = IC.valueOf var_i
 
-  let step' = fromMaybe (S.litInt 1) step
+  let step' = fromMaybe (IC.litInt 1) step
   stepV <- zoom lensMStoVS step'
   let mbStepV = valueInt stepV
-      (setBeg, begVal) = makeSetterVal "begIdx" step' mbStepV beg (S.litInt 0)    (S.listSize vold #- S.litInt 1)
-      (setEnd, endVal) = makeSetterVal "endIdx" step' mbStepV end (S.listSize vold) (S.litInt (-1))
+      (setBeg, begVal) = makeSetterVal "begIdx" step' mbStepV beg (IC.litInt 0)    (IC.listSize vold #- IC.litInt 1)
+      (setEnd, endVal) = makeSetterVal "endIdx" step' mbStepV end (IC.listSize vold) (IC.litInt (-1))
 
   mbBegV <- case beg of
         Nothing -> pure Nothing
@@ -91,17 +92,17 @@ listSlice beg end step vnew vold = do
                 -- If both bounds are litInt's, do a two-sided check.
                 -- Also, make sure step is in same direction as check.
                 (Just b, Just e) -> if e >= b 
-                    then begVal ?<= v_i ?&& v_i ?< endVal ?&& step' ?> S.litInt 0
-                    else endVal ?< v_i ?&& v_i ?<= begVal ?&& step' ?< S.litInt 0
+                    then begVal ?<= v_i ?&& v_i ?< endVal ?&& step' ?> IC.litInt 0
+                    else endVal ?< v_i ?&& v_i ?<= begVal ?&& step' ?< IC.litInt 0
                 -- If bounds are not litInt's, do both two-sided checks
-                _ ->  begVal ?<= v_i ?&& v_i ?< endVal ?&& step' ?> S.litInt 0 ?|| 
-                      endVal ?< v_i ?&& v_i ?<= begVal ?&& step' ?< S.litInt 0
+                _ ->  begVal ?<= v_i ?&& v_i ?< endVal ?&& step' ?> IC.litInt 0 ?|| 
+                      endVal ?< v_i ?&& v_i ?<= begVal ?&& step' ?< IC.litInt 0
 
-  S.block [
-    S.listDec 0 var_temp,
+  IC.block [
+    IC.listDec 0 var_temp,
     setBeg, setEnd,
-    S.for (S.varDecDef var_i begVal) cond (maybe (var_i &++) (var_i &+=) step)
-      (oneLiner $ S.valStmt $ S.listAppend v_temp (S.listAccess vold v_i)),
+    IC.for (IC.varDecDef var_i begVal) cond (maybe (var_i &++) (var_i &+=) step)
+      (oneLiner $ IC.valStmt $ IC.listAppend v_temp (IC.listAccess vold v_i)),
     vnew &= v_temp]
 
 -- Java, C#, C++, and Swift --
@@ -118,9 +119,9 @@ makeSetterVal :: RenderSym r => Label -> SValue r -> Maybe Integer -> Maybe (SVa
 makeSetterVal _     _    _      (Just v) _  _  = (S.emptyStmt, v)
 makeSetterVal _     _   (Just s) _       lb rb = (S.emptyStmt, if s > 0 then lb else rb)
 makeSetterVal vName step _       _       lb rb = 
-  let theVar = S.var vName S.int
-      theSetter = S.varDecDef theVar $ S.inlineIf (step ?> S.litInt 0) lb rb
-  in (theSetter, S.intToIndex $ S.valueOf theVar)
+  let theVar = IC.var vName IC.int
+      theSetter = IC.varDecDef theVar $ IC.inlineIf (step ?> IC.litInt 0) lb rb
+  in (theSetter, IC.intToIndex $ IC.valueOf theVar)
       
 stringListVals :: (RenderSym r) => [SVariable r] -> SValue r -> MSStatement r
 stringListVals vars sl = zoom lensMStoVS sl >>= (\slst -> multi $ checkList 
@@ -129,8 +130,8 @@ stringListVals vars sl = zoom lensMStoVS sl >>= (\slst -> multi $ checkList
         checkList _ = error 
           "Value passed to stringListVals must be a list of strings"
         assignVals [] _ = []
-        assignVals (v:vs) n = S.assign v (cast (onStateValue variableType v) 
-          (S.listAccess sl (S.litInt n))) : assignVals vs (n+1)
+        assignVals (v:vs) n = IC.assign v (cast (onStateValue variableType v) 
+          (IC.listAccess sl (IC.litInt n))) : assignVals vs (n+1)
 
 stringListLists :: (RenderSym r) => [SVariable r] -> SValue r -> MSStatement r
 stringListLists lsts sl = do
@@ -145,41 +146,41 @@ stringListLists lsts sl = do
     listVals (List _:vs) = listVals vs
     listVals _ = error
       "All values passed to stringListLists must have list types"
-    loop = S.forRange var_i (S.litInt 0) (S.listSize sl #/ numLists)
-      (S.litInt 1) (bodyStatements $ appendLists (map S.valueOf lsts) 0)
+    loop = IC.forRange var_i (IC.litInt 0) (IC.listSize sl #/ numLists)
+      (IC.litInt 1) (bodyStatements $ appendLists (map IC.valueOf lsts) 0)
     appendLists [] _ = []
-    appendLists (v:vs) n = S.valStmt (S.listAppend v (cast
-      (S.listInnerType $ onStateValue valueType v)
-      (S.listAccess sl ((v_i #* numLists) #+ S.litInt n))))
+    appendLists (v:vs) n = IC.valStmt (IC.listAppend v (cast
+      (IC.listInnerType $ onStateValue valueType v)
+      (IC.listAccess sl ((v_i #* numLists) #+ IC.litInt n))))
       : appendLists vs (n+1)
-    numLists = S.litInt (toInteger $ length lsts)
-    var_i = S.var l_i S.int
-    v_i = S.valueOf var_i
+    numLists = IC.litInt (toInteger $ length lsts)
+    var_i = IC.var l_i IC.int
+    v_i = IC.valueOf var_i
   checkList (getType $ valueType slst)
 
 forRange :: (RenderSym r) => SVariable r -> SValue r -> SValue r -> SValue r -> 
   MSBody r -> MSStatement r
-forRange i initv finalv stepv = S.for (S.varDecDef i initv) (S.valueOf i ?< 
+forRange i initv finalv stepv = IC.for (IC.varDecDef i initv) (IC.valueOf i ?< 
   finalv) (i &+= stepv)
 
 observerIndex :: (RenderSym r) => SVariable r
-observerIndex = S.var "observerIndex" S.int
+observerIndex = IC.var "observerIndex" IC.int
 
 observerIdxVal :: (RenderSym r) => SValue r
-observerIdxVal = S.valueOf observerIndex
+observerIdxVal = IC.valueOf observerIndex
 
 obsList :: (RenderSym r) => VSType r -> SValue r
-obsList t = S.valueOf $ observerListName `listOf` t
+obsList t = IC.valueOf $ observerListName `listOf` t
 
 notify :: (RenderSym r) => VSType r -> VSFunction r -> MSBody r
-notify t f = oneLiner $ S.valStmt $ at (obsList t) observerIdxVal $. f
+notify t f = oneLiner $ IC.valStmt $ at (obsList t) observerIdxVal $. f
 
 notifyObservers :: (RenderSym r) => VSFunction r -> VSType r -> MSStatement r
-notifyObservers f t = S.for initv (observerIdxVal ?< S.listSize (obsList t)) 
+notifyObservers f t = IC.for initv (observerIdxVal ?< IC.listSize (obsList t)) 
   (observerIndex &++) (notify t f)
-  where initv = S.varDecDef observerIndex $ S.litInt 0
+  where initv = IC.varDecDef observerIndex $ IC.litInt 0
 
 notifyObservers' :: (RenderSym r) => VSFunction r -> VSType r -> MSStatement r
-notifyObservers' f t = S.forRange observerIndex initv (S.listSize $ obsList t) 
-    (S.litInt 1) (notify t f)
-    where initv = S.litInt 0
+notifyObservers' f t = IC.forRange observerIndex initv (IC.listSize $ obsList t) 
+    (IC.litInt 1) (notify t f)
+    where initv = IC.litInt 0
diff --git a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/PythonRenderer.hs b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/PythonRenderer.hs
index baef3e904c..9542e9c07d 100644
--- a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/PythonRenderer.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/PythonRenderer.hs
@@ -9,23 +9,24 @@ module GOOL.Drasil.LanguageRenderer.PythonRenderer (
 import Utils.Drasil (blank, indent)
 
 import GOOL.Drasil.CodeType (CodeType(..))
-import GOOL.Drasil.ClassInterface (Label, Library, VSType, SVariable, SValue, 
-  VSFunction, MSStatement, MixedCtorCall, OOProg, ProgramSym(..), FileSym(..),
-  PermanenceSym(..), BodySym(..), BlockSym(..), TypeSym(..), OOTypeSym(..),
-  TypeElim(..), VariableSym(..), OOVariableSym(..), VariableElim(..),
-  ValueSym(..), OOValueSym, Argument(..), Literal(..), litZero, MathConstant(..),
-  VariableValue(..), OOVariableValue, CommandLineArgs(..), NumericExpression(..),
-  BooleanExpression(..), Comparison(..), ValueExpression(..),
-  OOValueExpression(..), funcApp, selfFuncApp, extFuncApp, extNewObj,
-  InternalValueExp(..), objMethodCall, FunctionSym(..), GetSet(..), List(..),
+import GOOL.Drasil.InterfaceCommon (SharedProg, Label, Library, VSType,
+  SVariable, SValue, MSStatement, MixedCtorCall, ProgramSym(..), FileSym(..),
+  PermanenceSym(..), BodySym(..), BlockSym(..), TypeSym(..), TypeElim(..),
+  VariableSym(..), VariableElim(..), ValueSym(..), Argument(..), Literal(..),
+  litZero, MathConstant(..), VariableValue(..), CommandLineArgs(..),
+  NumericExpression(..), BooleanExpression(..), Comparison(..),
+  ValueExpression(..), funcApp, extFuncApp, List(..),
   InternalList(..), ThunkSym(..), VectorType(..), VectorDecl(..),
   VectorThunk(..), VectorExpression(..), ThunkAssign(..), StatementSym(..),
-  AssignStatement(..), (&=), DeclStatement(..), OODeclStatement(..),
-  IOStatement(..), StringStatement(..), FuncAppStatement(..),
-  OOFuncAppStatement(..), CommentStatement(..), ControlStatement(..),
-  switchAsIf, ObserverPattern(..), StrategyPattern(..),
-  ScopeSym(..), ParameterSym(..), MethodSym(..), StateVarSym(..), ClassSym(..),
-  ModuleSym(..))
+  AssignStatement(..), (&=), DeclStatement(..), IOStatement(..),
+  StringStatement(..), FuncAppStatement(..), CommentStatement(..),
+  ControlStatement(..), switchAsIf, ScopeSym(..), ParameterSym(..),
+  MethodSym(..), StateVarSym(..), ClassSym(..), ModuleSym(..))
+import GOOL.Drasil.InterfaceGOOL (VSFunction, OOProg, OOTypeSym(..),
+  OOVariableSym(..), OOValueSym, OOVariableValue, InternalValueExp(..),
+  extNewObj, objMethodCall, FunctionSym(..), GetSet(..), OOValueExpression(..),
+  selfFuncApp, OODeclStatement(..), OOFuncAppStatement(..), ObserverPattern(..),
+  StrategyPattern(..))
 import GOOL.Drasil.RendererClasses (RenderSym, RenderFile(..), ImportSym(..), 
   ImportElim, PermElim(binding), RenderBody(..), BodyElim, RenderBlock(..), 
   BlockElim, RenderType(..), InternalTypeElim, UnaryOpSym(..), BinaryOpSym(..), 
@@ -114,6 +115,7 @@ instance Applicative PythonCode where
 instance Monad PythonCode where
   PC x >>= f = f x
 
+instance SharedProg PythonCode
 instance OOProg PythonCode
 
 instance ProgramSym PythonCode where
@@ -365,7 +367,6 @@ instance ValueExpression PythonCode where
   inlineIf = pyInlineIf
 
   funcAppMixedArgs = G.funcAppMixedArgs
-  selfFuncAppMixedArgs = G.selfFuncAppMixedArgs dot self
   extFuncAppMixedArgs l n t ps ns = do
     modify (addModuleImportVS l)
     CP.extFuncAppMixedArgs l n t ps ns
@@ -378,6 +379,7 @@ instance ValueExpression PythonCode where
   notNull = CP.notNull pyNull
 
 instance OOValueExpression PythonCode where
+  selfFuncAppMixedArgs = G.selfFuncAppMixedArgs dot self
   newObjMixedArgs = G.newObjMixedArgs ""
   extNewObjMixedArgs l tp ps ns = do
     modify (addModuleImportVS l)
diff --git a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/SwiftRenderer.hs b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/SwiftRenderer.hs
index 58d56a5184..a6b005f369 100644
--- a/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/SwiftRenderer.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil/LanguageRenderer/SwiftRenderer.hs
@@ -10,24 +10,25 @@ module GOOL.Drasil.LanguageRenderer.SwiftRenderer (
 import Utils.Drasil (indent)
 
 import GOOL.Drasil.CodeType (CodeType(..))
-import GOOL.Drasil.ClassInterface (Label, MSBody, MSBlock, VSType, SVariable,
-  SValue, MSStatement, MSParameter, SMethod, OOProg, Initializers,
+import GOOL.Drasil.InterfaceCommon (SharedProg, Label, MSBody, MSBlock, VSType,
+  SVariable, SValue, MSStatement, MSParameter, SMethod, Initializers,
   ProgramSym(..), FileSym(..), PermanenceSym(..), BodySym(..), oneLiner,
-  bodyStatements, BlockSym(..), TypeSym(..), OOTypeSym(..),
-  TypeElim(..), VariableSym(..), OOVariableSym(..), VariableElim(..),
-  ValueSym(..), OOValueSym, Argument(..), Literal(..), litZero, MathConstant(..),
-  VariableValue(..), OOVariableValue, CommandLineArgs(..), NumericExpression(..),
-  BooleanExpression(..), Comparison(..), ValueExpression(..),
-  OOValueExpression(..), funcApp, funcAppNamedArgs, selfFuncApp, extFuncApp,
-  newObj, InternalValueExp(..), objMethodCall, objMethodCallNamedArgs,
-  objMethodCallNoParams, FunctionSym(..), ($.), GetSet(..), List(..), listSlice,
-  InternalList(..), ThunkSym(..), VectorType(..), VectorDecl(..),
+  bodyStatements, BlockSym(..), TypeSym(..), TypeElim(..), VariableSym(..),
+  VariableElim(..), ValueSym(..), Argument(..), Literal(..), litZero,
+  MathConstant(..), VariableValue(..), CommandLineArgs(..),
+  NumericExpression(..), BooleanExpression(..), Comparison(..),
+  ValueExpression(..), funcApp, funcAppNamedArgs, extFuncApp, List(..),
+  listSlice, InternalList(..), ThunkSym(..), VectorType(..), VectorDecl(..),
   VectorThunk(..), VectorExpression(..), ThunkAssign(..), StatementSym(..),
-  AssignStatement(..), (&=), DeclStatement(..), OODeclStatement(..),
-  IOStatement(..), StringStatement(..), FuncAppStatement(..),
-  OOFuncAppStatement(..), CommentStatement(..), ControlStatement(..),
-  ObserverPattern(..), StrategyPattern(..), ScopeSym(..), ParameterSym(..),
-  MethodSym(..), StateVarSym(..), ClassSym(..), ModuleSym(..), convTypeOO)
+  AssignStatement(..), (&=), DeclStatement(..), IOStatement(..),
+  StringStatement(..), FuncAppStatement(..), CommentStatement(..),
+  ControlStatement(..), ScopeSym(..), ParameterSym(..), MethodSym(..),
+  StateVarSym(..), ClassSym(..), ModuleSym(..))
+import GOOL.Drasil.InterfaceGOOL (OOProg, OOTypeSym(..), OOVariableSym(..),
+  OOValueSym, OOVariableValue, OOValueExpression(..), selfFuncApp, newObj,
+  InternalValueExp(..), objMethodCall, objMethodCallNamedArgs,
+  objMethodCallNoParams, FunctionSym(..), ($.), GetSet(..), OODeclStatement(..),
+  OOFuncAppStatement(..), ObserverPattern(..), StrategyPattern(..), convTypeOO)
 import GOOL.Drasil.RendererClasses (MSMthdType, RenderSym,
   RenderFile(..), ImportSym(..), ImportElim, PermElim(binding), RenderBody(..),
   BodyElim, RenderBlock(..), BlockElim, RenderType(..), InternalTypeElim,
@@ -122,7 +123,8 @@ instance Applicative SwiftCode where
 instance Monad SwiftCode where
   SC x >>= f = f x
 
-instance OOProg SwiftCode where
+instance SharedProg SwiftCode
+instance OOProg SwiftCode
 
 instance ProgramSym SwiftCode where
   type Program SwiftCode = ProgData
@@ -373,7 +375,6 @@ instance ValueExpression SwiftCode where
   inlineIf = C.inlineIf
 
   funcAppMixedArgs = G.funcAppMixedArgs
-  selfFuncAppMixedArgs = G.selfFuncAppMixedArgs dot self
   extFuncAppMixedArgs = CP.extFuncAppMixedArgs
   libFuncAppMixedArgs = C.libFuncAppMixedArgs
 
@@ -382,6 +383,7 @@ instance ValueExpression SwiftCode where
   notNull = CP.notNull swiftNil
 
 instance OOValueExpression SwiftCode where
+  selfFuncAppMixedArgs = G.selfFuncAppMixedArgs dot self
   newObjMixedArgs = G.newObjMixedArgs ""
   extNewObjMixedArgs m tp vs ns = do
     t <- tp
diff --git a/code/drasil-gool/lib/GOOL/Drasil/RendererClasses.hs b/code/drasil-gool/lib/GOOL/Drasil/RendererClasses.hs
index 6dce898606..047d994840 100644
--- a/code/drasil-gool/lib/GOOL/Drasil/RendererClasses.hs
+++ b/code/drasil-gool/lib/GOOL/Drasil/RendererClasses.hs
@@ -14,19 +14,20 @@ module GOOL.Drasil.RendererClasses (
   ModuleElim(..), BlockCommentSym(..), BlockCommentElim(..)
 ) where
 
-import GOOL.Drasil.ClassInterface (Label, Library, SFile, MSBody, MSBlock, 
-  VSType, SVariable, SValue, VSFunction, MSStatement, MSParameter,
-  SMethod, CSStateVar, SClass, FSModule, MixedCall, FileSym(..),
-  PermanenceSym(..), BodySym(..), BlockSym(..), TypeSym(..), TypeElim(..),
-  VariableSym(..), OOVariableValue, VariableElim(..), ValueSym(..),
-  Argument(..), Literal(..), MathConstant(..), VariableValue(..),
-  CommandLineArgs(..), NumericExpression(..), BooleanExpression(..), Comparison(..),
+import GOOL.Drasil.InterfaceCommon (Label, Library, SFile, MSBody, MSBlock, 
+  VSType, SVariable, SValue, MSStatement, MSParameter, SMethod, CSStateVar,
+  SClass, FSModule, MixedCall, FileSym(..), PermanenceSym(..), BodySym(..),
+  BlockSym(..), TypeSym(..), TypeElim(..), VariableSym(..), VariableElim(..),
+  ValueSym(..), Argument(..), Literal(..), MathConstant(..), VariableValue(..),
+  CommandLineArgs(..), NumericExpression(..), BooleanExpression(..),
+  Comparison(..), List(..), InternalList(..), VectorExpression(..),
+  StatementSym(..), AssignStatement(..), DeclStatement(..), IOStatement(..),
+  StringStatement(..), FuncAppStatement(..), CommentStatement(..),
+  ControlStatement(..), ScopeSym(..), ParameterSym(..), MethodSym(..),
+  StateVarSym(..), ClassSym(..), ModuleSym(..))
+import GOOL.Drasil.InterfaceGOOL (VSFunction, OOVariableValue,
   OOValueExpression(..), InternalValueExp(..), FunctionSym(..), GetSet(..),
-  List(..), InternalList(..), VectorExpression(..), StatementSym(..),
-  AssignStatement(..), DeclStatement(..), IOStatement(..), StringStatement(..),
-  FuncAppStatement(..), CommentStatement(..), ControlStatement(..),
-  ObserverPattern(..), StrategyPattern(..), ScopeSym(..), ParameterSym(..),
-  MethodSym(..), StateVarSym(..), ClassSym(..), ModuleSym(..))
+  ObserverPattern(..), StrategyPattern(..))
 import GOOL.Drasil.CodeType (CodeType)
 import GOOL.Drasil.AST (Binding, Terminator, ScopeTag)
 import GOOL.Drasil.State (FS, CS, MS, VS)