diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,6 +1,6 @@
 # Change Log
 
-## 0.4
+## 0.4.1
 
 * Allow a wide range of dynamically sorted values (not just expressions)
 * Utility for extracting array accesses
diff --git a/expressions.cabal b/expressions.cabal
--- a/expressions.cabal
+++ b/expressions.cabal
@@ -1,5 +1,5 @@
 name:                expressions
-version:             0.4
+version:             0.4.1
 synopsis:            Expressions and Formulae a la carte
 description:
   This package is aimed at providing means of fixing a first-order language and
diff --git a/src/Data/Expression.hs b/src/Data/Expression.hs
--- a/src/Data/Expression.hs
+++ b/src/Data/Expression.hs
@@ -40,6 +40,7 @@
                        , module Data.Expression.Utils.Indexed.Show
                        , module Data.Expression.Utils.Indexed.Sum
                        , module Data.Expression.Utils.Indexed.Traversable
+                       , module Data.Expression.Utils.Indexed.Tuple
 
                        -- Functors representing usual combinations of languages
                        , QFLogicF
@@ -154,6 +155,7 @@
 import Data.Expression.Utils.Indexed.Show
 import Data.Expression.Utils.Indexed.Sum
 import Data.Expression.Utils.Indexed.Traversable
+import Data.Expression.Utils.Indexed.Tuple
 
 import qualified Data.Functor.Const as F
 import qualified Prelude as P
diff --git a/src/Data/Expression/Array.hs b/src/Data/Expression/Array.hs
--- a/src/Data/Expression/Array.hs
+++ b/src/Data/Expression/Array.hs
@@ -20,7 +20,11 @@
 module Data.Expression.Array ( ArrayF(..)
                              , select
                              , store
-                             , accesses ) where
+                             , accesses
+                             , StaticallyValuedArrayAccess(..)
+                             , DynamicallyValuedArrayAccess(..)
+                             , StaticallyIndexedArrayAccess(..)
+                             , DynamicallyIndexedArrayAccess(..) ) where
 
 import Control.Monad.Trans.Writer
 import Data.Coerce
@@ -111,24 +115,25 @@
 store :: ( ArrayF :<: f, SingI i, SingI e ) => IFix f ('ArraySort i e) -> IFix f i -> IFix f e -> IFix f ('ArraySort i e)
 store a i v = inject (Store sing sing a i v)
 
-newtype Array1 f (i :: Sort) (e :: Sort) = Array1 (IFix f ('ArraySort i e))
-newtype Array2 f (i :: Sort)             = Array2 (DynamicallySorted (Array1 f i))
+newtype StaticallyValuedArrayAccess  f (s :: Sort) (e :: Sort) = StaticallyValuedArrayAccess (IFix f ('ArraySort s e))
+newtype DynamicallyValuedArrayAccess f (s :: Sort)             = DynamicallyValuedArrayAccess (DynamicallySorted (StaticallyValuedArrayAccess f s))
 
-type ArrayAccess f = DynamicallySorted (IT2 (Array2 f) (IFix f))
+newtype StaticallyIndexedArrayAccess  f (s :: Sort) = StaticallyIndexedArrayAccess (IT2 (DynamicallyValuedArrayAccess f) (IFix f) s)
+newtype DynamicallyIndexedArrayAccess f             = DynamicallyIndexedArrayAccess (DynamicallySorted (StaticallyIndexedArrayAccess f))
 
-instance ( IFunctor f, IShow f ) => Show (Array1 f i e) where
-  show (Array1 f) = show f
+instance ( IFunctor f, IShow f ) => Show (StaticallyValuedArrayAccess f i e) where
+  show (StaticallyValuedArrayAccess f) = show f
 
-instance ( IFunctor f, IShow f ) => Show (Array2 f i) where
-  show (Array2 f) = show f
+instance ( IFunctor f, IShow f ) => Show (DynamicallyValuedArrayAccess f i) where
+  show (DynamicallyValuedArrayAccess f) = show f
 
 -- | Collects pairs of arrays and indices that appear together in some @select@ and/or @store@ within an expression
-accesses :: forall f (s :: Sort). ( ArrayF :<: f, ITraversable f ) => IFix f s -> [ArrayAccess f]
+accesses :: forall f (s :: Sort). ( ArrayF :<: f, ITraversable f ) => IFix f s -> [DynamicallyIndexedArrayAccess f]
 accesses = execWriter . imapM accesses' where
-  accesses' :: forall (s' :: Sort). IFix f s' -> Writer [ArrayAccess f] (IFix f s')
+  accesses' :: forall (s' :: Sort). IFix f s' -> Writer [DynamicallyIndexedArrayAccess f] (IFix f s')
   accesses' e = do
     case match e of
-      Just (Select is es a i)   -> tell [ DynamicallySorted is (IT2 (Array2 (DynamicallySorted es (Array1 a)), i)) ]
-      Just (Store  is es a i _) -> tell [ DynamicallySorted is (IT2 (Array2 (DynamicallySorted es (Array1 a)), i)) ]
+      Just (Select is es a i)   -> tell [ DynamicallyIndexedArrayAccess (DynamicallySorted is (StaticallyIndexedArrayAccess (IT2 (DynamicallyValuedArrayAccess (DynamicallySorted es (StaticallyValuedArrayAccess a)), i)))) ]
+      Just (Store  is es a i _) -> tell [ DynamicallyIndexedArrayAccess (DynamicallySorted is (StaticallyIndexedArrayAccess (IT2 (DynamicallyValuedArrayAccess (DynamicallySorted es (StaticallyValuedArrayAccess a)), i)))) ]
       _                         -> return ()
     return e