Rename arithPromote* to lift* (unrelated to arith ops, really)

2 files changed, 80 insertions, 80 deletions

diff --git a/src/Data/Array/Nested/Internal/Ranked.hs b/src/Data/Array/Nested/Internal/Ranked.hs
index 9493bc6..1c6b789 100644
--- a/src/Data/Array/Nested/Internal/Ranked.hs
+++ b/src/Data/Array/Nested/Internal/Ranked.hs
@@ -188,60 +188,60 @@ instance (KnownNat n, KnownElt a) => KnownElt (Ranked n a) where
     = MV_Ranked <$> mvecsNewEmpty (Proxy @(Mixed (Replicate n Nothing) a))
 
 
-arithPromoteRanked :: forall n a b.
-                      (Mixed (Replicate n Nothing) a -> Mixed (Replicate n Nothing) b)
-                   -> Ranked n a -> Ranked n b
-arithPromoteRanked = coerce
+liftRanked1 :: forall n a b.
+               (Mixed (Replicate n Nothing) a -> Mixed (Replicate n Nothing) b)
+            -> Ranked n a -> Ranked n b
+liftRanked1 = coerce
 
-arithPromoteRanked2 :: forall n a b c.
-                       (Mixed (Replicate n Nothing) a -> Mixed (Replicate n Nothing) b -> Mixed (Replicate n Nothing) c)
-                    -> Ranked n a -> Ranked n b -> Ranked n c
-arithPromoteRanked2 = coerce
+liftRanked2 :: forall n a b c.
+               (Mixed (Replicate n Nothing) a -> Mixed (Replicate n Nothing) b -> Mixed (Replicate n Nothing) c)
+            -> Ranked n a -> Ranked n b -> Ranked n c
+liftRanked2 = coerce
 
 instance (NumElt a, PrimElt a) => Num (Ranked n a) where
-  (+) = arithPromoteRanked2 (+)
-  (-) = arithPromoteRanked2 (-)
-  (*) = arithPromoteRanked2 (*)
-  negate = arithPromoteRanked negate
-  abs = arithPromoteRanked abs
-  signum = arithPromoteRanked signum
+  (+) = liftRanked2 (+)
+  (-) = liftRanked2 (-)
+  (*) = liftRanked2 (*)
+  negate = liftRanked1 negate
+  abs = liftRanked1 abs
+  signum = liftRanked1 signum
   fromInteger = error "Data.Array.Nested(Ranked).fromInteger: No singletons available, use explicit rreplicateScal"
 
 instance (FloatElt a, PrimElt a) => Fractional (Ranked n a) where
   fromRational _ = error "Data.Array.Nested(Ranked).fromRational: No singletons available, use explicit rreplicateScal"
-  recip = arithPromoteRanked recip
-  (/) = arithPromoteRanked2 (/)
+  recip = liftRanked1 recip
+  (/) = liftRanked2 (/)
 
 instance (FloatElt a, PrimElt a) => Floating (Ranked n a) where
   pi = error "Data.Array.Nested(Ranked).pi: No singletons available, use explicit rreplicateScal"
-  exp = arithPromoteRanked exp
-  log = arithPromoteRanked log
-  sqrt = arithPromoteRanked sqrt
-  (**) = arithPromoteRanked2 (**)
-  logBase = arithPromoteRanked2 logBase
-  sin = arithPromoteRanked sin
-  cos = arithPromoteRanked cos
-  tan = arithPromoteRanked tan
-  asin = arithPromoteRanked asin
-  acos = arithPromoteRanked acos
-  atan = arithPromoteRanked atan
-  sinh = arithPromoteRanked sinh
-  cosh = arithPromoteRanked cosh
-  tanh = arithPromoteRanked tanh
-  asinh = arithPromoteRanked asinh
-  acosh = arithPromoteRanked acosh
-  atanh = arithPromoteRanked atanh
-  log1p = arithPromoteRanked GHC.Float.log1p
-  expm1 = arithPromoteRanked GHC.Float.expm1
-  log1pexp = arithPromoteRanked GHC.Float.log1pexp
-  log1mexp = arithPromoteRanked GHC.Float.log1mexp
+  exp = liftRanked1 exp
+  log = liftRanked1 log
+  sqrt = liftRanked1 sqrt
+  (**) = liftRanked2 (**)
+  logBase = liftRanked2 logBase
+  sin = liftRanked1 sin
+  cos = liftRanked1 cos
+  tan = liftRanked1 tan
+  asin = liftRanked1 asin
+  acos = liftRanked1 acos
+  atan = liftRanked1 atan
+  sinh = liftRanked1 sinh
+  cosh = liftRanked1 cosh
+  tanh = liftRanked1 tanh
+  asinh = liftRanked1 asinh
+  acosh = liftRanked1 acosh
+  atanh = liftRanked1 atanh
+  log1p = liftRanked1 GHC.Float.log1p
+  expm1 = liftRanked1 GHC.Float.expm1
+  log1pexp = liftRanked1 GHC.Float.log1pexp
+  log1mexp = liftRanked1 GHC.Float.log1mexp
 
 rquotArray, rremArray :: (IntElt a, PrimElt a) => Ranked n a -> Ranked n a -> Ranked n a
-rquotArray = arithPromoteRanked2 mquotArray
-rremArray = arithPromoteRanked2 mremArray
+rquotArray = liftRanked2 mquotArray
+rremArray = liftRanked2 mremArray
 
 ratan2Array :: (FloatElt a, PrimElt a) => Ranked n a -> Ranked n a -> Ranked n a
-ratan2Array = arithPromoteRanked2 matan2Array
+ratan2Array = liftRanked2 matan2Array
 
 
 remptyArray :: KnownElt a => Ranked 1 a
diff --git a/src/Data/Array/Nested/Internal/Shaped.hs b/src/Data/Array/Nested/Internal/Shaped.hs
index 03631b0..35628db 100644
--- a/src/Data/Array/Nested/Internal/Shaped.hs
+++ b/src/Data/Array/Nested/Internal/Shaped.hs
@@ -186,60 +186,60 @@ instance (KnownShS sh, KnownElt a) => KnownElt (Shaped sh a) where
     = MV_Shaped <$> mvecsNewEmpty (Proxy @(Mixed (MapJust sh) a))
 
 
-arithPromoteShaped :: forall sh a b.
-                      (Mixed (MapJust sh) a -> Mixed (MapJust sh) b)
-                   -> Shaped sh a -> Shaped sh b
-arithPromoteShaped = coerce
+liftShaped1 :: forall sh a b.
+               (Mixed (MapJust sh) a -> Mixed (MapJust sh) b)
+            -> Shaped sh a -> Shaped sh b
+liftShaped1 = coerce
 
-arithPromoteShaped2 :: forall sh a b c.
-                       (Mixed (MapJust sh) a -> Mixed (MapJust sh) b -> Mixed (MapJust sh) c)
-                    -> Shaped sh a -> Shaped sh b -> Shaped sh c
-arithPromoteShaped2 = coerce
+liftShaped2 :: forall sh a b c.
+               (Mixed (MapJust sh) a -> Mixed (MapJust sh) b -> Mixed (MapJust sh) c)
+            -> Shaped sh a -> Shaped sh b -> Shaped sh c
+liftShaped2 = coerce
 
 instance (NumElt a, PrimElt a) => Num (Shaped sh a) where
-  (+) = arithPromoteShaped2 (+)
-  (-) = arithPromoteShaped2 (-)
-  (*) = arithPromoteShaped2 (*)
-  negate = arithPromoteShaped negate
-  abs = arithPromoteShaped abs
-  signum = arithPromoteShaped signum
+  (+) = liftShaped2 (+)
+  (-) = liftShaped2 (-)
+  (*) = liftShaped2 (*)
+  negate = liftShaped1 negate
+  abs = liftShaped1 abs
+  signum = liftShaped1 signum
   fromInteger = error "Data.Array.Nested.fromInteger: No singletons available, use explicit sreplicateScal"
 
 instance (FloatElt a, PrimElt a) => Fractional (Shaped sh a) where
   fromRational = error "Data.Array.Nested.fromRational: No singletons available, use explicit sreplicateScal"
-  recip = arithPromoteShaped recip
-  (/) = arithPromoteShaped2 (/)
+  recip = liftShaped1 recip
+  (/) = liftShaped2 (/)
 
 instance (FloatElt a, PrimElt a) => Floating (Shaped sh a) where
   pi = error "Data.Array.Nested.pi: No singletons available, use explicit sreplicateScal"
-  exp = arithPromoteShaped exp
-  log = arithPromoteShaped log
-  sqrt = arithPromoteShaped sqrt
-  (**) = arithPromoteShaped2 (**)
-  logBase = arithPromoteShaped2 logBase
-  sin = arithPromoteShaped sin
-  cos = arithPromoteShaped cos
-  tan = arithPromoteShaped tan
-  asin = arithPromoteShaped asin
-  acos = arithPromoteShaped acos
-  atan = arithPromoteShaped atan
-  sinh = arithPromoteShaped sinh
-  cosh = arithPromoteShaped cosh
-  tanh = arithPromoteShaped tanh
-  asinh = arithPromoteShaped asinh
-  acosh = arithPromoteShaped acosh
-  atanh = arithPromoteShaped atanh
-  log1p = arithPromoteShaped GHC.Float.log1p
-  expm1 = arithPromoteShaped GHC.Float.expm1
-  log1pexp = arithPromoteShaped GHC.Float.log1pexp
-  log1mexp = arithPromoteShaped GHC.Float.log1mexp
+  exp = liftShaped1 exp
+  log = liftShaped1 log
+  sqrt = liftShaped1 sqrt
+  (**) = liftShaped2 (**)
+  logBase = liftShaped2 logBase
+  sin = liftShaped1 sin
+  cos = liftShaped1 cos
+  tan = liftShaped1 tan
+  asin = liftShaped1 asin
+  acos = liftShaped1 acos
+  atan = liftShaped1 atan
+  sinh = liftShaped1 sinh
+  cosh = liftShaped1 cosh
+  tanh = liftShaped1 tanh
+  asinh = liftShaped1 asinh
+  acosh = liftShaped1 acosh
+  atanh = liftShaped1 atanh
+  log1p = liftShaped1 GHC.Float.log1p
+  expm1 = liftShaped1 GHC.Float.expm1
+  log1pexp = liftShaped1 GHC.Float.log1pexp
+  log1mexp = liftShaped1 GHC.Float.log1mexp
 
 squotArray, sremArray :: (IntElt a, PrimElt a) => Shaped sh a -> Shaped sh a -> Shaped sh a
-squotArray = arithPromoteShaped2 mquotArray
-sremArray = arithPromoteShaped2 mremArray
+squotArray = liftShaped2 mquotArray
+sremArray = liftShaped2 mremArray
 
 satan2Array :: (FloatElt a, PrimElt a) => Shaped sh a -> Shaped sh a -> Shaped sh a
-satan2Array = arithPromoteShaped2 matan2Array
+satan2Array = liftShaped2 matan2Array
 
 
 semptyArray :: KnownElt a => ShS sh -> Shaped (0 : sh) a