Merge pull request #4649 from JacquesCarette/BoolBinaryOp

balacij · web-flow · commit c3655dd09dc1 · 2026-01-19T22:10:12.000-05:00
Get rid of some unused boolean binary operation
diff --git a/code/drasil-code/lib/Data/Drasil/ExternalLibraries/ODELibraries.hs b/code/drasil-code/lib/Data/Drasil/ExternalLibraries/ODELibraries.hs
@@ -646,8 +646,6 @@ modifiedODESyst sufx info = map replaceDepVar (odeSyst info)
     replaceDepVar (UnaryOpVN u e)         = UnaryOpVN u $ replaceDepVar e
     replaceDepVar (ArithBinaryOp b e1 e2) = ArithBinaryOp b
       (replaceDepVar e1) (replaceDepVar e2)
-    replaceDepVar (BoolBinaryOp b e1 e2)  = BoolBinaryOp b
-      (replaceDepVar e1) (replaceDepVar e2)
     replaceDepVar (EqBinaryOp b e1 e2)    = EqBinaryOp b
       (replaceDepVar e1) (replaceDepVar e2)
     replaceDepVar (LABinaryOp b e1 e2)    = LABinaryOp b
diff --git a/code/drasil-code/lib/Language/Drasil/Code/Imperative/Import.hs b/code/drasil-code/lib/Language/Drasil/Code/Imperative/Import.hs
@@ -18,7 +18,7 @@ import Data.List ((\\), intersect)
 import Drasil.Code.CodeExpr (sy, ($<), ($>), ($<=), ($>=), ($&&), in')
 import qualified Drasil.Code.CodeExpr.Development as S (CodeExpr(..))
 import Drasil.Code.CodeExpr.Development (CodeExpr(..), ArithBinOp(..),
-  AssocArithOper(..), AssocBoolOper(..), AssocConcatOper(..), BoolBinOp(..), EqBinOp(..),
+  AssocArithOper(..), AssocBoolOper(..), AssocConcatOper(..), EqBinOp(..),
   LABinOp(..), OrdBinOp(..), UFunc(..), UFuncB(..), UFuncVV(..), UFuncVN(..),
   VVNBinOp(..), VVVBinOp(..), NVVBinOp(..), ESSBinOp(..), ESBBinOp(..))
 import Drasil.Database (UID, HasUID(..))
@@ -345,7 +345,6 @@ convExpr (ArithBinaryOp Frac (Lit (Int a)) (Lit (Int b))) = do -- hack to deal w
       getLiteral _ = error "convExpr: Rational space matched to invalid CodeType; should be Double or Float"
   return $ getLiteral sm
 convExpr (ArithBinaryOp o a b) = liftM2 (arithBfunc o) (convExpr a) (convExpr b)
-convExpr (BoolBinaryOp o a b)  = liftM2 (boolBfunc o) (convExpr a) (convExpr b)
 convExpr (LABinaryOp o a b)    = liftM2 (laBfunc o) (convExpr a) (convExpr b)
 convExpr (EqBinaryOp o a b)    = liftM2 (eqBfunc o) (convExpr a) (convExpr b)
 convExpr (OrdBinaryOp o a b)   = liftM2 (ordBfunc o) (convExpr a) (convExpr b)
@@ -459,11 +458,6 @@ arithBfunc Pow  = (#^)
 arithBfunc Subt = (#-)
 arithBfunc Frac = (#/)
 
--- Maps a 'BoolBinOp' to it's corresponding GOOL binary function.
-boolBfunc :: BoolBinOp -> (SValue r -> SValue r -> SValue r)
-boolBfunc Impl = error "convExpr :=>"
-boolBfunc Iff  = error "convExpr :<=>"
-
 -- Maps an 'EqBinOp' to it's corresponding GOOL binary function.
 eqBfunc :: (SharedProg r) => EqBinOp -> (SValue r -> SValue r -> SValue r)
 eqBfunc Eq  = (?==)
@@ -1045,7 +1039,6 @@ convExprProc (ArithBinaryOp Frac (Lit (Int a)) (Lit (Int b))) = do -- hack to de
       getLiteral _ = error "convExprProc: Rational space matched to invalid CodeType; should be Double or Float"
   return $ getLiteral sm
 convExprProc (ArithBinaryOp o a b) = liftM2 (arithBfunc o) (convExprProc a) (convExprProc b)
-convExprProc (BoolBinaryOp o a b)  = liftM2 (boolBfunc o) (convExprProc a) (convExprProc b)
 convExprProc (LABinaryOp o a b)    = liftM2 (laBfunc o) (convExprProc a) (convExprProc b)
 convExprProc (EqBinaryOp o a b)    = liftM2 (eqBfunc o) (convExprProc a) (convExprProc b)
 convExprProc (OrdBinaryOp o a b)   = liftM2 (ordBfunc o) (convExprProc a) (convExprProc b)
diff --git a/code/drasil-lang/lib/Drasil/Code/CodeExpr/Convert.hs b/code/drasil-lang/lib/Drasil/Code/CodeExpr/Convert.hs
@@ -40,7 +40,6 @@ expr (LD.UnaryOpB uo e)        = UnaryOpB uo (expr e)
 expr (LD.UnaryOpVV uo e)       = UnaryOpVV uo (expr e)
 expr (LD.UnaryOpVN uo e)       = UnaryOpVN uo (expr e)
 expr (LD.ArithBinaryOp bo l r) = ArithBinaryOp bo (expr l) (expr r)
-expr (LD.BoolBinaryOp bo l r)  = BoolBinaryOp bo (expr l) (expr r)
 expr (LD.EqBinaryOp bo l r)    = EqBinaryOp bo (expr l) (expr r)
 expr (LD.LABinaryOp bo l r)    = LABinaryOp bo (expr l) (expr r)
 expr (LD.OrdBinaryOp bo l r)   = OrdBinaryOp bo (expr l) (expr r)
diff --git a/code/drasil-lang/lib/Drasil/Code/CodeExpr/Development.hs b/code/drasil-lang/lib/Drasil/Code/CodeExpr/Development.hs
@@ -3,7 +3,7 @@ module Drasil.Code.CodeExpr.Development (
     -- CodeExpr
     CodeExpr(..),
     -- re-export from Expr
-    ArithBinOp(..), EqBinOp(..), BoolBinOp(..), LABinOp(..),
+    ArithBinOp(..), EqBinOp(..), LABinOp(..),
     OrdBinOp(..), VVVBinOp(..), VVNBinOp(..), NVVBinOp(..),
     ESSBinOp(..), ESBBinOp(..),
     AssocArithOper(..), AssocBoolOper(..), AssocConcatOper(..),
@@ -21,7 +21,7 @@ module Drasil.Code.CodeExpr.Development (
 
 import Drasil.Code.CodeExpr.Lang (CodeExpr(..))
 import Language.Drasil.Expr.Lang (ArithBinOp(..), EqBinOp(..),
-    BoolBinOp(..), LABinOp(..), OrdBinOp(..), VVVBinOp(..),
+    LABinOp(..), OrdBinOp(..), VVVBinOp(..),
     VVNBinOp(..), NVVBinOp(..),
     ESSBinOp(..), ESBBinOp(..),
     AssocBoolOper(..), AssocArithOper(..), AssocConcatOper(..),
diff --git a/code/drasil-lang/lib/Drasil/Code/CodeExpr/Extract.hs b/code/drasil-lang/lib/Drasil/Code/CodeExpr/Extract.hs
@@ -30,7 +30,6 @@ eNames (UnaryOpB _ u)        = eNames u
 eNames (UnaryOpVV _ u)       = eNames u
 eNames (UnaryOpVN _ u)       = eNames u
 eNames (ArithBinaryOp _ a b) = eNames a ++ eNames b
-eNames (BoolBinaryOp _ a b)  = eNames a ++ eNames b
 eNames (EqBinaryOp _ a b)    = eNames a ++ eNames b
 eNames (LABinaryOp _ a b)    = eNames a ++ eNames b
 eNames (OrdBinaryOp _ a b)   = eNames a ++ eNames b
@@ -74,7 +73,6 @@ eNames' (UnaryOpB _ u)        = eNames' u
 eNames' (UnaryOpVV _ u)       = eNames' u
 eNames' (UnaryOpVN _ u)       = eNames' u
 eNames' (ArithBinaryOp _ a b) = eNames' a ++ eNames' b
-eNames' (BoolBinaryOp _ a b)  = eNames' a ++ eNames' b
 eNames' (EqBinaryOp _ a b)    = eNames' a ++ eNames' b
 eNames' (LABinaryOp _ a b)    = eNames' a ++ eNames' b
 eNames' (OrdBinaryOp _ a b)   = eNames' a ++ eNames' b
diff --git a/code/drasil-lang/lib/Drasil/Code/CodeExpr/Lang.hs b/code/drasil-lang/lib/Drasil/Code/CodeExpr/Lang.hs
@@ -7,7 +7,7 @@ import Control.Lens ((^.))
 import Drasil.Database (UID, HasUID(..))
 
 import Language.Drasil.Expr.Lang
-  (Completeness(..), ArithBinOp(..), EqBinOp(..), BoolBinOp(..),
+  (Completeness(..), ArithBinOp(..), EqBinOp(..),
    LABinOp(..), OrdBinOp(..), EqBinOp(..),
    VVVBinOp(..), VVNBinOp(..), NVVBinOp(..), ESSBinOp(..), ESBBinOp(..),
    AssocArithOper(..), AssocBoolOper(..), AssocConcatOper(..),
@@ -73,8 +73,6 @@ data CodeExpr where
 
   -- | Binary operator for arithmetic between expressions (fractional, power, and subtraction).
   ArithBinaryOp :: ArithBinOp -> CodeExpr -> CodeExpr -> CodeExpr
-  -- | Binary operator for boolean operators (implies, iff).
-  BoolBinaryOp  :: BoolBinOp -> CodeExpr -> CodeExpr -> CodeExpr
   -- | Binary operator for equality between expressions.
   EqBinaryOp    :: EqBinOp -> CodeExpr -> CodeExpr -> CodeExpr
   -- | Binary operator for indexing two expressions.
@@ -160,11 +158,6 @@ instance ExprC CodeExpr where
   -- | Smart constructor for rasing the first expression to the power of the second.
   ($^) = ArithBinaryOp Pow
 
-  -- | Smart constructor to show that one expression implies the other (conditional operator).
-  ($=>) = BoolBinaryOp Impl
-  -- | Smart constructor to show that an expression exists if and only if another expression exists (biconditional operator).
-  ($<=>) = BoolBinaryOp Iff
-
   -- | Smart constructor for the boolean /and/ operator.
   a $&& b = AssocB And [a, b]
   -- | Smart constructor for the boolean /or/ operator.
diff --git a/code/drasil-lang/lib/Drasil/Code/CodeExpr/Precedence.hs b/code/drasil-lang/lib/Drasil/Code/CodeExpr/Precedence.hs
@@ -1,7 +1,7 @@
 module Drasil.Code.CodeExpr.Precedence (precA, precB, eprec) where
 
 import Drasil.Code.CodeExpr.Lang (CodeExpr(..))
-import Language.Drasil.Expr.Precedence (prec2Arith, prec2Eq, prec2Bool,
+import Language.Drasil.Expr.Precedence (prec2Arith, prec2Eq,
   prec2LA, prec2Ord, prec2VVV, prec2VVN, prec2NVV, prec2ESS, prec2ESB,
   precA, precB, precC, prec1, prec1B, prec1VV, prec1VN)
 
@@ -30,7 +30,6 @@ eprec (UnaryOpVV fn _)       = prec1VV fn
 eprec (UnaryOpVN fn _)       = prec1VN fn
 eprec (Operator o _ _)       = precA o
 eprec (ArithBinaryOp bo _ _) = prec2Arith bo
-eprec (BoolBinaryOp bo _ _)  = prec2Bool bo
 eprec (EqBinaryOp bo _ _)    = prec2Eq bo
 eprec (LABinaryOp bo _ _)    = prec2LA bo
 eprec (OrdBinaryOp bo _ _)   = prec2Ord bo
diff --git a/code/drasil-lang/lib/Language/Drasil/Expr/Class.hs b/code/drasil-lang/lib/Language/Drasil/Expr/Class.hs
@@ -113,8 +113,6 @@ class ExprC r where
 
   ($-), ($/), ($^) :: r -> r -> r
 
-  ($=>), ($<=>) :: r -> r -> r
-
   ($&&), ($||) :: r -> r -> r
 
   -- | Smart constructor for set-theoretic membership relation. Added ' to avoid conflict.
@@ -278,11 +276,6 @@ instance ExprC Expr where
   -- | Smart constructor for rasing the first expression to the power of the second.
   ($^) = ArithBinaryOp Pow
 
-  -- | Smart constructor to show that one expression implies the other (conditional operator).
-  ($=>)  = BoolBinaryOp Impl
-  -- | Smart constructor to show that an expression exists if and only if another expression exists (biconditional operator).
-  ($<=>) = BoolBinaryOp Iff
-
   -- | Smart constructor for the boolean /and/ operator.
   a $&& b = AssocB And [a, b]
   -- | Smart constructor for the boolean /or/ operator.
@@ -443,11 +436,6 @@ instance ExprC M.ModelExpr where
   -- | Smart constructor for rasing the first expression to the power of the second.
   ($^) = M.ArithBinaryOp Pow
 
-  -- | Smart constructor to show that one expression implies the other (conditional operator).
-  ($=>)  = M.BoolBinaryOp Impl
-  -- | Smart constructor to show that an expression exists if and only if another expression exists (biconditional operator).
-  ($<=>) = M.BoolBinaryOp Iff
-
   -- | Smart constructor for the boolean /and/ operator.
   a $&& b = M.AssocB M.And [a, b]
   -- | Smart constructor for the boolean /or/ operator.
diff --git a/code/drasil-lang/lib/Language/Drasil/Expr/Development.hs b/code/drasil-lang/lib/Language/Drasil/Expr/Development.hs
@@ -1,7 +1,7 @@
 module Language.Drasil.Expr.Development (
   -- Expr
     Expr(..), UFunc(..), UFuncB(..), UFuncVV(..), UFuncVN(..)
-  , ArithBinOp(..), BoolBinOp(..), EqBinOp(..), LABinOp(..), OrdBinOp(..)
+  , ArithBinOp(..), EqBinOp(..), LABinOp(..), OrdBinOp(..)
   , VVVBinOp(..), VVNBinOp(..), NVVBinOp(..), ESSBinOp(..), ESBBinOp(..)
   , AssocArithOper(..), AssocBoolOper(..), AssocConcatOper(..)
   , Completeness(..), Relation
diff --git a/code/drasil-lang/lib/Language/Drasil/Expr/Extract.hs b/code/drasil-lang/lib/Language/Drasil/Expr/Extract.hs
@@ -23,7 +23,6 @@ eNames (UnaryOpB _ u)        = eNames u
 eNames (UnaryOpVV _ u)       = eNames u
 eNames (UnaryOpVN _ u)       = eNames u
 eNames (ArithBinaryOp _ a b) = eNames a ++ eNames b
-eNames (BoolBinaryOp _ a b)  = eNames a ++ eNames b
 eNames (EqBinaryOp _ a b)    = eNames a ++ eNames b
 eNames (LABinaryOp _ a b)    = eNames a ++ eNames b
 eNames (OrdBinaryOp _ a b)   = eNames a ++ eNames b
@@ -61,7 +60,6 @@ eNames' (UnaryOpB _ u)        = eNames' u
 eNames' (UnaryOpVV _ u)       = eNames' u
 eNames' (UnaryOpVN _ u)       = eNames' u
 eNames' (ArithBinaryOp _ a b) = eNames' a ++ eNames' b
-eNames' (BoolBinaryOp _ a b)  = eNames' a ++ eNames' b
 eNames' (EqBinaryOp _ a b)    = eNames' a ++ eNames' b
 eNames' (LABinaryOp _ a b)    = eNames' a ++ eNames' b
 eNames' (OrdBinaryOp _ a b)   = eNames' a ++ eNames' b
diff --git a/code/drasil-lang/lib/Language/Drasil/Expr/Lang.hs b/code/drasil-lang/lib/Language/Drasil/Expr/Lang.hs
@@ -38,11 +38,6 @@ data ArithBinOp = Frac | Pow | Subt
 data EqBinOp = Eq | NEq
   deriving Eq
 
--- | Conditional and Biconditional operators (Expressions can imply
--- one another, or exist if and only if another expression exists).
-data BoolBinOp = Impl | Iff
-  deriving Eq
-
 -- | Index operator. `Index` represents accessing an element at a specific
 -- index, while `IndexOf` represents finding the index of a specific element.
 data LABinOp = Index | IndexOf
@@ -142,8 +137,6 @@ data Expr where
 
   -- | Binary operator for arithmetic between expressions (fractional, power, and subtraction).
   ArithBinaryOp :: ArithBinOp -> Expr -> Expr -> Expr
-  -- | Binary operator for boolean operators (implies, iff).
-  BoolBinaryOp  :: BoolBinOp -> Expr -> Expr -> Expr
   -- | Binary operator for equality between expressions.
   EqBinaryOp    :: EqBinOp -> Expr -> Expr -> Expr
   -- | Binary operator for indexing two expressions.
@@ -180,7 +173,6 @@ instance Eq Expr where
   UnaryOpVV a b       == UnaryOpVV c d       =   a == c && b == d
   UnaryOpVN a b       == UnaryOpVN c d       =   a == c && b == d
   ArithBinaryOp o a b == ArithBinaryOp p c d =   o == p && a == c && b == d
-  BoolBinaryOp o a b  == BoolBinaryOp p c d  =   o == p && a == c && b == d
   EqBinaryOp o a b    == EqBinaryOp p c d    =   o == p && a == c && b == d
   OrdBinaryOp o a b   == OrdBinaryOp p c d   =   o == p && a == c && b == d
   LABinaryOp o a b    == LABinaryOp p c d    =   o == p && a == c && b == d
@@ -402,14 +394,6 @@ instance Typed Expr Space where
       (\ls rs -> "Subtraction should only be applied to the same numeric typed operands. Received `" ++ ls ++ "` - `" ++ rs ++ "`.")
     pure lt
 
-  infer cxt (BoolBinaryOp _ l r) = do
-    lt <- infer cxt l
-    rt <- infer cxt r
-    let msg = const $ "Boolean expression contains non-boolean operand. Received `" ++ show lt ++ "` & `" ++ show rt ++ "`."
-    assertBoolean lt msg
-    assertBoolean rt msg
-    pure S.Boolean
-
   infer cxt (EqBinaryOp _ l r) = do
     lt <- infer cxt l
     rt <- infer cxt r
diff --git a/code/drasil-lang/lib/Language/Drasil/Expr/Precedence.hs b/code/drasil-lang/lib/Language/Drasil/Expr/Precedence.hs
@@ -2,7 +2,7 @@
 module Language.Drasil.Expr.Precedence where
 
 import Language.Drasil.Expr.Lang (Expr(..),
-  ArithBinOp(..), BoolBinOp, EqBinOp(..), LABinOp, OrdBinOp, VVNBinOp,
+  ArithBinOp(..), EqBinOp(..), LABinOp, OrdBinOp, VVNBinOp,
   UFunc(..), UFuncB(..), UFuncVV(..), UFuncVN(..),
   AssocBoolOper(..), AssocArithOper(..), VVVBinOp, NVVBinOp, ESSBinOp, ESBBinOp, AssocConcatOper(..))
 
@@ -16,10 +16,6 @@ prec2Arith Frac = 190
 prec2Arith Pow = 200
 prec2Arith Subt = 180
 
--- | prec2Bool - precedence for boolean-related binary operations.
-prec2Bool :: BoolBinOp -> Int
-prec2Bool _ = 130
-
 -- | prec2Eq - precedence for equality-related binary operations.
 prec2Eq :: EqBinOp -> Int
 prec2Eq _  = 130
@@ -101,7 +97,6 @@ eprec (UnaryOpVV fn _)       = prec1VV fn
 eprec (UnaryOpVN fn _)       = prec1VN fn
 eprec (Operator o _ _)       = precA o
 eprec (ArithBinaryOp bo _ _) = prec2Arith bo
-eprec (BoolBinaryOp bo _ _)  = prec2Bool bo
 eprec (EqBinaryOp bo _ _)    = prec2Eq bo
 eprec (LABinaryOp bo _ _)    = prec2LA bo
 eprec (OrdBinaryOp bo _ _)   = prec2Ord bo
diff --git a/code/drasil-lang/lib/Language/Drasil/ModelExpr/Convert.hs b/code/drasil-lang/lib/Language/Drasil/ModelExpr/Convert.hs
@@ -29,7 +29,6 @@ expr (E.UnaryOpB u e)        = UnaryOpB u (expr e)
 expr (E.UnaryOpVV u e)       = UnaryOpVV u (expr e)
 expr (E.UnaryOpVN u e)       = UnaryOpVN u (expr e)
 expr (E.ArithBinaryOp a l r) = ArithBinaryOp a (expr l) (expr r)
-expr (E.BoolBinaryOp b l r)  = BoolBinaryOp b (expr l) (expr r)
 expr (E.EqBinaryOp e l r)    = EqBinaryOp e (expr l) (expr r)
 expr (E.LABinaryOp la l r)   = LABinaryOp la (expr l) (expr r)
 expr (E.OrdBinaryOp o l r)   = OrdBinaryOp o (expr l) (expr r)
diff --git a/code/drasil-lang/lib/Language/Drasil/ModelExpr/Development.hs b/code/drasil-lang/lib/Language/Drasil/ModelExpr/Development.hs
@@ -8,7 +8,7 @@ module Language.Drasil.ModelExpr.Development (
   , AssocBoolOper(..)
   , DerivType(..)
   -- Expr.Lang
-  , ArithBinOp(..), BoolBinOp(..), EqBinOp(..), LABinOp(..)
+  , ArithBinOp(..), EqBinOp(..), LABinOp(..)
   , OrdBinOp(..), VVVBinOp(..), VVNBinOp(..), NVVBinOp(..)
   , ESSBinOp(..), ESBBinOp(..)
   , AssocArithOper(..), AssocConcatOper(..)
@@ -23,7 +23,7 @@ module Language.Drasil.ModelExpr.Development (
   , precC, precA
 ) where
 
-import Language.Drasil.Expr.Lang (ArithBinOp(..), BoolBinOp(..),
+import Language.Drasil.Expr.Lang (ArithBinOp(..),
   EqBinOp(..), LABinOp(..), OrdBinOp(..), VVVBinOp(..),
   VVNBinOp(..), NVVBinOp(..), ESSBinOp(..), ESBBinOp(..),
   AssocArithOper(..), AssocConcatOper(..),
diff --git a/code/drasil-lang/lib/Language/Drasil/ModelExpr/Extract.hs b/code/drasil-lang/lib/Language/Drasil/ModelExpr/Extract.hs
@@ -25,7 +25,6 @@ meNames (UnaryOpB _ u)        = meNames u
 meNames (UnaryOpVV _ u)       = meNames u
 meNames (UnaryOpVN _ u)       = meNames u
 meNames (ArithBinaryOp _ a b) = meNames a ++ meNames b
-meNames (BoolBinaryOp _ a b)  = meNames a ++ meNames b
 meNames (EqBinaryOp _ a b)    = meNames a ++ meNames b
 meNames (LABinaryOp _ a b)    = meNames a ++ meNames b
 meNames (SpaceBinaryOp _ a b) = meNames a ++ meNames b
@@ -68,7 +67,6 @@ meNames' (UnaryOpB _ u)        = meNames' u
 meNames' (UnaryOpVV _ u)       = meNames' u
 meNames' (UnaryOpVN _ u)       = meNames' u
 meNames' (ArithBinaryOp _ a b) = meNames' a ++ meNames' b
-meNames' (BoolBinaryOp _ a b)  = meNames' a ++ meNames' b
 meNames' (EqBinaryOp _ a b)    = meNames' a ++ meNames' b
 meNames' (LABinaryOp _ a b)    = meNames' a ++ meNames' b
 meNames' (OrdBinaryOp _ a b)   = meNames' a ++ meNames' b
diff --git a/code/drasil-lang/lib/Language/Drasil/ModelExpr/Lang.hs b/code/drasil-lang/lib/Language/Drasil/ModelExpr/Lang.hs
@@ -8,7 +8,7 @@ import Prelude hiding (sqrt)
 import Drasil.Database (UID)
 
 import Language.Drasil.Expr.Lang
-  (Completeness, ArithBinOp, EqBinOp, BoolBinOp, LABinOp, OrdBinOp,
+  (Completeness, ArithBinOp, EqBinOp, LABinOp, OrdBinOp,
    VVVBinOp, VVNBinOp, NVVBinOp, ESSBinOp, ESBBinOp, AssocArithOper,
    AssocConcatOper,
    UFunc, UFuncB, UFuncVV, UFuncVN)
@@ -78,8 +78,6 @@ data ModelExpr where
 
   -- | Binary operator for arithmetic between expressions (fractional, power, and subtraction).
   ArithBinaryOp :: ArithBinOp -> ModelExpr -> ModelExpr -> ModelExpr
-  -- | Binary operator for boolean operators (implies, iff).
-  BoolBinaryOp  :: BoolBinOp -> ModelExpr -> ModelExpr -> ModelExpr
   -- | Binary operator for equality between expressions.
   EqBinaryOp    :: EqBinOp -> ModelExpr -> ModelExpr -> ModelExpr
   -- | Binary operator for indexing two expressions.
@@ -150,7 +148,6 @@ instance Eq ModelExpr where
   UnaryOpVV a b       == UnaryOpVV c d       =   a == c && b == d
   UnaryOpVN a b       == UnaryOpVN c d       =   a == c && b == d
   ArithBinaryOp o a b == ArithBinaryOp p c d =   o == p && a == c && b == d
-  BoolBinaryOp o a b  == BoolBinaryOp p c d  =   o == p && a == c && b == d
   EqBinaryOp o a b    == EqBinaryOp p c d    =   o == p && a == c && b == d
   OrdBinaryOp o a b   == OrdBinaryOp p c d   =   o == p && a == c && b == d
   SpaceBinaryOp o a b == SpaceBinaryOp p c d =   o == p && a == c && b == d
diff --git a/code/drasil-lang/lib/Language/Drasil/ModelExpr/Precedence.hs b/code/drasil-lang/lib/Language/Drasil/ModelExpr/Precedence.hs
@@ -3,7 +3,7 @@ module Language.Drasil.ModelExpr.Precedence where
 
 import Language.Drasil.ModelExpr.Lang
 import Language.Drasil.Expr.Lang (ArithBinOp(..))
-import Language.Drasil.Expr.Precedence (prec2Arith, prec2Bool, prec2Eq,
+import Language.Drasil.Expr.Precedence (prec2Arith, prec2Eq,
   prec2LA, prec2Ord, prec2VVV, prec2VVN, prec2NVV, prec2ESS, prec2ESB,
   precA, precC, prec1, prec1B, prec1VV, prec1VN)
 
@@ -43,7 +43,6 @@ mePrec (UnaryOpVV fn _)       = prec1VV fn
 mePrec (UnaryOpVN fn _)       = prec1VN fn
 mePrec (Operator o _ _)       = precA o
 mePrec (ArithBinaryOp bo _ _) = prec2Arith bo
-mePrec (BoolBinaryOp bo _ _)  = prec2Bool bo
 mePrec (EqBinaryOp bo _ _)    = prec2Eq bo
 mePrec (LABinaryOp bo _ _)    = prec2LA bo
 mePrec (SpaceBinaryOp bo _ _) = prec2Spc bo
diff --git a/code/drasil-printers/lib/Language/Drasil/Printing/Import/CodeExpr.hs b/code/drasil-printers/lib/Language/Drasil/Printing/Import/CodeExpr.hs
@@ -146,8 +146,6 @@ codeExpr sm (UnaryOpVV NegV u)          = neg sm u
 codeExpr sm (ArithBinaryOp Frac a b)    = P.Div (codeExpr sm a) (codeExpr sm b)
 codeExpr sm (ArithBinaryOp Pow a b)     = pow sm a b
 codeExpr sm (ArithBinaryOp Subt a b)    = P.Row [codeExpr sm a, P.MO P.Subt, codeExpr sm b]
-codeExpr sm (BoolBinaryOp Impl a b)     = mkBOp sm P.Impl a b
-codeExpr sm (BoolBinaryOp Iff a b)      = mkBOp sm P.Iff a b
 codeExpr sm (EqBinaryOp Eq a b)         = mkBOp sm P.Eq a b
 codeExpr sm (EqBinaryOp NEq a b)        = mkBOp sm P.NEq a b
 codeExpr sm (LABinaryOp Index a b)      = indx sm a b
diff --git a/code/drasil-printers/lib/Language/Drasil/Printing/Import/Expr.hs b/code/drasil-printers/lib/Language/Drasil/Printing/Import/Expr.hs
@@ -9,7 +9,7 @@ import Drasil.Database (UID)
 import Language.Drasil hiding (neg, sec, symbol, isIn, Matrix, Set)
 import qualified Language.Drasil.Display as S (Symbol(..))
 import Language.Drasil.Expr.Development (ArithBinOp(..), AssocArithOper(..),
-  AssocBoolOper(..), BoolBinOp(..), EqBinOp(..), Expr(..),
+  AssocBoolOper(..), EqBinOp(..), Expr(..),
   LABinOp(..), OrdBinOp(..), UFunc(..), UFuncB(..), UFuncVN(..), UFuncVV(..),
   VVNBinOp(..), VVVBinOp(..), NVVBinOp(..), ESSBinOp(..), ESBBinOp(..), AssocConcatOper(..), eprec, precA, precB, precC)
 import Language.Drasil.Literal.Development (Literal(..))
@@ -142,8 +142,6 @@ expr (UnaryOpVV NegV u)       sm = neg sm u
 expr (ArithBinaryOp Frac a b) sm = P.Div (expr a sm) (expr b sm)
 expr (ArithBinaryOp Pow a b)  sm = pow sm a b
 expr (ArithBinaryOp Subt a b) sm = P.Row [expr a sm, P.MO P.Subt, expr b sm]
-expr (BoolBinaryOp Impl a b)  sm = mkBOp sm P.Impl a b
-expr (BoolBinaryOp Iff a b)   sm = mkBOp sm P.Iff a b
 expr (EqBinaryOp Eq a b)      sm = mkBOp sm P.Eq a b
 expr (EqBinaryOp NEq a b)     sm = mkBOp sm P.NEq a b
 expr (LABinaryOp Index a b)   sm = indx sm a b
diff --git a/code/drasil-printers/lib/Language/Drasil/Printing/Import/ModelExpr.hs b/code/drasil-printers/lib/Language/Drasil/Printing/Import/ModelExpr.hs
