diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # language-ats
 
+## 1.7.7.1
+
+  * Use `these-skinny`
+
 ## 1.7.7.0
 
   * Improved parse errors
diff --git a/language-ats.cabal b/language-ats.cabal
--- a/language-ats.cabal
+++ b/language-ats.cabal
@@ -1,6 +1,6 @@
 cabal-version:   1.18
 name:            language-ats
-version:         1.7.7.0
+version:         1.7.7.1
 license:         BSD3
 license-file:    LICENSE
 copyright:       Copyright: (c) 2018-2019 Vanessa McHale
@@ -69,7 +69,8 @@
         ansi-wl-pprint >=0.6.8,
         composition-prelude >=2.0.4.0,
         containers -any,
-        transformers -any
+        transformers -any,
+        these-skinny -any
 
     if !flag(cross)
         build-tools: happy >=1.17.1, alex -any
diff --git a/src/Language/ATS.hs b/src/Language/ATS.hs
--- a/src/Language/ATS.hs
+++ b/src/Language/ATS.hs
@@ -37,7 +37,6 @@
                     , PreFunction (..)
                     , StaticExpression (..)
                     , StackFunction (..)
-                    , Paired (..)
                     , Fixity (..)
                     , SortArg (..)
                     , Sort (..)
diff --git a/src/Language/ATS/Parser.y b/src/Language/ATS/Parser.y
--- a/src/Language/ATS/Parser.y
+++ b/src/Language/ATS/Parser.y
@@ -19,6 +19,7 @@
 import Data.Char (toLower)
 import Data.List.NonEmpty (NonEmpty (..))
 import Data.Foldable (toList)
+import Data.These (These (..))
 import GHC.Generics (Generic)
 import Language.ATS.Types
 import Language.ATS.Types.Lens
@@ -332,14 +333,14 @@
      | { [] }
 
 TypeArg :: { Arg AlexPosn }
-        : IdentifierOr { Arg (First $1) }
-        | IdentifierOr colon Type { Arg (Both $1 $3) }
-        | Type { Arg (Second $1) }
+        : IdentifierOr { Arg (This $1) }
+        | IdentifierOr colon Type { Arg (These $1 $3) }
+        | Type { Arg (That $1) }
         | exclamation IdentifierOr colon {% left $ OneOf $3 [",", ")"] ":" }
 
 Arg :: { Arg AlexPosn }
     : TypeArg { $1 }
-    | StaticExpression { Arg (Second (ConcreteType $1)) } -- TODO: have some sort of state showing bound variables that we can use to disambiguate types vs. static expressions?
+    | StaticExpression { Arg (That (ConcreteType $1)) } -- TODO: have some sort of state showing bound variables that we can use to disambiguate types vs. static expressions?
 
 -- | Parse a literal
 Literal :: { Expression AlexPosn }
diff --git a/src/Language/ATS/PrettyPrint.hs b/src/Language/ATS/PrettyPrint.hs
--- a/src/Language/ATS/PrettyPrint.hs
+++ b/src/Language/ATS/PrettyPrint.hs
@@ -18,6 +18,7 @@
 import           Data.List                    (isPrefixOf)
 import           Data.List.NonEmpty           (NonEmpty (..))
 import qualified Data.List.NonEmpty           as NE
+import           Data.These                   (These (..))
 import           Language.ATS.Types
 import           Lens.Micro
 import           Prelude                      hiding ((<$>))
@@ -236,10 +237,10 @@
         a (BinPatternF _ op p p')             = p <+> pretty op <+> p'
 
 argHelper :: Eq a => (Doc -> Doc -> Doc) -> Arg a -> Doc
-argHelper _ (Arg (First s))   = pretty s
-argHelper _ (Arg (Second t))  = pretty t
-argHelper op (Arg (Both s t)) = pretty s `op` colon `op` pretty t
-argHelper op (PrfArg a a')    = prettyArgs' ", " mempty mempty a </> "|" `op` pretty a'
+argHelper _ (Arg (This s))     = pretty s
+argHelper _ (Arg (That t))     = pretty t
+argHelper op (Arg (These s t)) = pretty s `op` colon `op` pretty t
+argHelper op (PrfArg a a')     = prettyArgs' ", " mempty mempty a </> "|" `op` pretty a'
 
 instance Eq a => Pretty (SortArg a) where
     pretty (SortArg n st) = text n <> ":" <+> pretty st
diff --git a/src/Language/ATS/Types.hs b/src/Language/ATS/Types.hs
--- a/src/Language/ATS/Types.hs
+++ b/src/Language/ATS/Types.hs
@@ -34,7 +34,6 @@
     , Addendum (..)
     , DataPropLeaf (..)
     , PreFunction (..)
-    , Paired (..)
     , Leaf (..)
     , StaticExpression (..)
     , StaticExpressionF (..)
@@ -55,6 +54,7 @@
 import           Data.Function      (on)
 import           Data.List.NonEmpty (NonEmpty)
 import qualified Data.Map           as M
+import           Data.These         (These)
 import           GHC.Generics       (Generic)
 import           GHC.Natural        (Natural)
 import           Language.ATS.Lexer (Addendum (..))
@@ -232,17 +232,12 @@
 
 type instance Base (Pattern a) = PatternF a
 
-data Paired a b = Both a b
-                | First a
-                | Second b
-                deriving (Show, Eq, Generic, NFData)
-
 data SortArg a = SortArg String (Sort a)
                | Anonymous (Sort a)
     deriving (Show, Eq, Generic, NFData)
 
 -- | An argument to a function.
-data Arg a = Arg (Paired String (Type a))
+data Arg a = Arg (These String (Type a))
            | PrfArg [Arg a] (Arg a)
            deriving (Show, Eq, Generic, NFData)
 
diff --git a/test/Spec.hs b/test/Spec.hs
--- a/test/Spec.hs
+++ b/test/Spec.hs
@@ -1,4 +1,5 @@
 {-# LANGUAGE OverloadedStrings #-}
+-- vim: syntax=hspec
 
 import           Data.Foldable
 import qualified Filesystem.Path.CurrentOS as F
diff --git a/test/data/stack.sats b/test/data/stack.sats
new file mode 100644
--- /dev/null
+++ b/test/data/stack.sats
@@ -0,0 +1,12 @@
+absprop gc_ptr(l:addr, a:t@ype)
+
+typedef stack_t(a: t@ype+) = $extype "struct stack_t"
+
+fun new {a:t@ype+}(&stack_t(a)? >> stack_t(a)) : void =
+  "ext#"
+
+fun {a:t@ype+} push(&stack_t(a) >> stack_t(a), a) : void =
+  "ext#"
+
+fun {a:t@ype+} pop(&stack_t(a) >> stack_t(a)) : Option(a) =
+  "ext#"