Rename "vari" to "var"

Author: garyb

src/SqlSquared.purs

@@ -22,10 +22,10 @@ import Data.Functor.Mu (Mu)
 import Data.Json.Extended as EJ
 import Data.Traversable (traverse)
 import Matryoshka (cata, anaM)
-import SqlSquared.Constructors (array, as, binop, bool, buildSelect, groupBy, having, hugeNum, ident, int, invokeFunction, let_, map_, match, null, num, parens, projection, select, set, splice, string, switch, then_, unop, vari, when) as Constructors
-import SqlSquared.Lenses (_ArrayLiteral, _Binop, _BoolLiteral, _Case, _DecimalLiteral, _ExprRelation, _GroupBy, _Identifier, _IntLiteral, _InvokeFunction, _JoinRelation, _Let, _Literal, _MapLiteral, _Match, _NullLiteral, _OrderBy, _Parens, _Projection, _Select, _SetLiteral, _Splice, _StringLiteral, _Switch, _TableRelation, _Unop, _Vari, _VariRelation, _alias, _aliasName, _args, _bindTo, _cases, _clause, _cond, _else, _expr, _filter, _groupBy, _having, _ident, _in, _isDistinct, _joinType, _keys, _left, _lhs, _name, _op, _orderBy, _projections, _relations, _rhs, _right, _tablePath) as Lenses
+import SqlSquared.Constructors (array, as, binop, bool, buildSelect, groupBy, having, hugeNum, ident, int, invokeFunction, let_, map_, match, null, num, parens, projection, select, set, splice, string, switch, then_, unop, var, when) as Constructors
+import SqlSquared.Lenses (_ArrayLiteral, _Binop, _BoolLiteral, _Case, _DecimalLiteral, _ExprRelation, _GroupBy, _Identifier, _IntLiteral, _InvokeFunction, _JoinRelation, _Let, _Literal, _MapLiteral, _Match, _NullLiteral, _OrderBy, _Parens, _Projection, _Select, _SetLiteral, _Splice, _StringLiteral, _Switch, _TableRelation, _Unop, _Var, _VarRelation, _alias, _aliasName, _args, _bindTo, _cases, _clause, _cond, _else, _expr, _filter, _groupBy, _having, _ident, _in, _isDistinct, _joinType, _keys, _left, _lhs, _name, _op, _orderBy, _projections, _relations, _rhs, _right, _tablePath) as Lenses
 import SqlSquared.Parser (Literal(..), PositionedToken, parse, parseModule, parseQuery, prettyParse) as Parser
-import SqlSquared.Signature (type (×), BinaryOperator(..), BinopR, Case(..), ExprRelR, FunctionDeclR, GroupBy(..), Ident(..), InvokeFunctionR, JoinRelR, JoinType(..), LetR, MatchR, OrderBy(..), OrderType(..), Projection(..), Relation(..), SelectR, SqlDeclF(..), SqlF(..), SqlModuleF(..), SqlQueryF(..), SwitchR, TableRelR, UnaryOperator(..), UnopR, VariRelR, binopFromString, binopToString, genBinaryOperator, genCase, genGroupBy, genJoinType, genOrderBy, genOrderType, genProjection, genRelation, genSqlDeclF, genSqlF, genSqlModuleF, genSqlQueryF, genUnaryOperator, joinTypeFromString, orderTypeFromString, printBinaryOperator, printCase, printGroupBy, printIdent, printJoinType, printOrderBy, printOrderType, printProjection, printRelation, printSqlDeclF, printSqlF, printSqlModuleF, printSqlQueryF, printUnaryOperator, unopFromString, unopToString, (×), (∘), (⋙)) as Sig
+import SqlSquared.Signature (type (×), BinaryOperator(..), BinopR, Case(..), ExprRelR, FunctionDeclR, GroupBy(..), Ident(..), InvokeFunctionR, JoinRelR, JoinType(..), LetR, MatchR, OrderBy(..), OrderType(..), Projection(..), Relation(..), SelectR, SqlDeclF(..), SqlF(..), SqlModuleF(..), SqlQueryF(..), SwitchR, TableRelR, UnaryOperator(..), UnopR, VarRelR, binopFromString, binopToString, genBinaryOperator, genCase, genGroupBy, genJoinType, genOrderBy, genOrderType, genProjection, genRelation, genSqlDeclF, genSqlF, genSqlModuleF, genSqlQueryF, genUnaryOperator, joinTypeFromString, orderTypeFromString, printBinaryOperator, printCase, printGroupBy, printIdent, printJoinType, printOrderBy, printOrderType, printProjection, printRelation, printSqlDeclF, printSqlF, printSqlModuleF, printSqlQueryF, printUnaryOperator, unopFromString, unopToString, (×), (∘), (⋙)) as Sig
 
 type Sql = Mu (Sig.SqlF EJ.EJsonF)
 

src/SqlSquared/Constructors.purs

@@ -14,8 +14,8 @@ import Matryoshka (class Corecursive, embed)
 import SqlSquared.Signature as Sig
 import SqlSquared.Utils ((∘))
 
-vari ∷ ∀ t f. Corecursive t (Sig.SqlF f) ⇒ Sig.Ident → t
-vari = embed ∘ Sig.Vari
+var ∷ ∀ t f. Corecursive t (Sig.SqlF f) ⇒ Sig.Ident → t
+var = embed ∘ Sig.Var
 
 bool ∷ ∀ t. Corecursive t (Sig.SqlF EJsonF) ⇒ Boolean → t
 bool = embed ∘ Sig.Literal ∘ Boolean

src/SqlSquared/Lenses.purs

@@ -36,9 +36,9 @@ _ExprRelation = prism' S.ExprRelation case _ of
   S.ExprRelation r → M.Just r
   _ → M.Nothing
 
-_VariRelation ∷ ∀ a. Prism' (S.Relation a) S.VariRelR
-_VariRelation = prism' S.VariRelation case _ of
-  S.VariRelation r → M.Just r
+_VarRelation ∷ ∀ a. Prism' (S.Relation a) S.VarRelR
+_VarRelation = prism' S.VarRelation case _ of
+  S.VarRelation r → M.Just r
   _ → M.Nothing
 
 _TableRelation ∷ ∀ a. Prism' (S.Relation a) S.TableRelR
@@ -281,13 +281,13 @@ _BoolLiteral = prism' (embed ∘ S.Literal ∘ EJ.Boolean) $ project ⋙ case _
   S.Literal (EJ.Boolean b) → M.Just b
   _ → M.Nothing
 
-_Vari
+_Var
   ∷ ∀ t f
   . Recursive t (S.SqlF f)
   ⇒ Corecursive t (S.SqlF f)
   ⇒ Prism' t S.Ident
-_Vari = prism' (embed ∘ S.Vari) $ project ⋙ case _ of
-  S.Vari r → M.Just r
+_Var = prism' (embed ∘ S.Var) $ project ⋙ case _ of
+  S.Var r → M.Just r
   _ → M.Nothing
 
 _Select

src/SqlSquared/Parser.purs

@@ -306,7 +306,7 @@ primaryExpr = asErrorMessage "primary expression" $ PC.choice
       xs → embed $ Sig.SetLiteral xs
   , unaryOperator
   , functionExpr
-  , variable
+  , varable
   , literal
   , wildcard
   , arrayLiteral
@@ -397,7 +397,7 @@ functionDecl parseExpr = asErrorMessage "function declaration" do
   _ ← PC.try $ keyword "create" *> keyword "function"
   name ← ident
   operator "("
-  args ← PC.sepBy variableString $ operator ","
+  args ← PC.sepBy varableString $ operator ","
   operator ")"
   _ ← keyword "begin"
   body ← parseExpr
@@ -414,11 +414,11 @@ import_ = asErrorMessage "import declaration" do
   path ← Pt.parseAnyDirPath P.fail s
   pure $ Sig.Import path
 
-variable ∷ ∀ m t. SqlParser' m t
-variable = C.vari <$> variableString
+varable ∷ ∀ m t. SqlParser' m t
+varable = C.var <$> varableString
 
-variableString ∷ ∀ m. Monad m ⇒ P.ParserT TokenStream m Ident
-variableString = asErrorMessage "variable" $ PC.try do
+varableString ∷ ∀ m. Monad m ⇒ P.ParserT TokenStream m Ident
+varableString = asErrorMessage "varable" $ PC.try do
   operator ":"
   PP.Position pos1 ← P.position
   s ← ident <|> anyKeyword
@@ -557,7 +557,7 @@ relation = do
 simpleRelation ∷ ∀ m t. SqlParser m t (Sig.Relation t)
 simpleRelation =
   tableRelation
-  <|> variRelation
+  <|> varRelation
   <|> PC.try exprRelation
   <|> parenRelation
 
@@ -577,13 +577,13 @@ tableRelation = do
     ident
   pure $ Sig.TableRelation { alias: Ident <$> a, path }
 
-variRelation ∷ ∀ m t. SqlParser m t (Sig.Relation t)
-variRelation = do
-  vari ← variableString
+varRelation ∷ ∀ m t. SqlParser m t (Sig.Relation t)
+varRelation = do
+  var ← varableString
   a ← PC.optionMaybe do
     _ ← keyword "as"
     ident
-  pure $ Sig.VariRelation { alias: Ident <$> a, vari }
+  pure $ Sig.VarRelation { alias: Ident <$> a, var }
 
 exprRelation ∷ ∀ m t. SqlParser m t (Sig.Relation t)
 exprRelation = do

src/SqlSquared/Signature.purs

@@ -61,7 +61,7 @@ import SqlSquared.Signature.JoinType (JoinType(..), genJoinType, joinTypeFromStr
 import SqlSquared.Signature.OrderBy (OrderBy(..), genOrderBy, printOrderBy) as OB
 import SqlSquared.Signature.OrderType (OrderType(..), genOrderType, orderTypeFromString, printOrderType) as OT
 import SqlSquared.Signature.Projection (Projection(..), genProjection, printProjection) as PR
-import SqlSquared.Signature.Relation (ExprRelR, JoinRelR, Relation(..), TableRelR, VariRelR, genRelation, printRelation) as RL
+import SqlSquared.Signature.Relation (ExprRelR, JoinRelR, Relation(..), TableRelR, VarRelR, genRelation, printRelation) as RL
 import SqlSquared.Signature.UnaryOperator (UnaryOperator(..), genUnaryOperator, printUnaryOperator, unopFromString, unopToString) as UO
 import SqlSquared.Utils (type (×), (×), (∘), (⋙))
 
@@ -124,7 +124,7 @@ data SqlF literal a
   | Match (MatchR a)
   | Switch (SwitchR a)
   | Let (LetR a)
-  | Vari ID.Ident
+  | Var ID.Ident
   | Select (SelectR a)
   | Parens a
 
@@ -175,7 +175,7 @@ instance foldableSqlF ∷ F.Foldable l ⇒ F.Foldable (SqlF l) where
     Match { expr, cases, else_ } → f expr <> F.foldMap (F.foldMap f) cases <> F.foldMap f else_
     Switch { cases, else_} → F.foldMap (F.foldMap f) cases <> F.foldMap f else_
     Let { bindTo, in_ } → f bindTo <> f in_
-    Vari _ → mempty
+    Var _ → mempty
     Select { projections, relations, filter, groupBy, orderBy } →
       F.foldMap (F.foldMap f) projections
       <> F.foldMap (F.foldMap f) relations
@@ -197,7 +197,7 @@ instance foldableSqlF ∷ F.Foldable l ⇒ F.Foldable (SqlF l) where
       F.foldl f (F.foldl (F.foldl f) a cases) else_
     Let { bindTo, in_} →
       f (f a bindTo) in_
-    Vari _ → a
+    Var _ → a
     Select { projections, relations, filter, groupBy, orderBy } →
       F.foldl (F.foldl f)
       (F.foldl (F.foldl f)
@@ -224,7 +224,7 @@ instance foldableSqlF ∷ F.Foldable l ⇒ F.Foldable (SqlF l) where
       F.foldr f (F.foldr (flip $ F.foldr f) a cases) else_
     Let { bindTo, in_ } →
       f bindTo $ f in_ a
-    Vari _ → a
+    Var _ → a
     Select { projections, relations, filter, groupBy, orderBy } →
       F.foldr (flip $ F.foldr f)
       (F.foldr (flip $ F.foldr f)
@@ -288,7 +288,7 @@ instance traversableSqlF ∷ T.Traversable l ⇒ T.Traversable (SqlF l) where
       $ { bindTo: _, in_: _, ident }
       <$> f bindTo
       <*> f in_
-    Vari s → pure $ Vari s
+    Var s → pure $ Var s
     Parens p → map Parens $ f p
     Select { isDistinct, projections, relations, filter, groupBy, orderBy } →
       map Select
@@ -349,7 +349,7 @@ printSqlF printLiteralF = case _ of
     <> " END"
   Let { ident, bindTo, in_ } →
     ID.printIdent ident <> " := " <> bindTo <> "; " <> in_
-  Vari s →
+  Var s →
     ":" <> ID.printIdent s
   Select { isDistinct, projections, relations, filter, groupBy, orderBy } →
     "SELECT "
@@ -390,7 +390,7 @@ genSqlF genLiteral n
   | n < 2 =
   Gen.oneOf $ (Literal <$> genLiteral n) :|
     [ map Identifier genIdent
-    , map Vari genIdent
+    , map Var genIdent
     , pure $ Splice Nothing
     , pure $ SetLiteral L.Nil
     ]

src/SqlSquared/Signature/Relation.purs

@@ -29,8 +29,8 @@ type ExprRelR a =
   , alias ∷ ID.Ident
   }
 
-type VariRelR =
-  { vari ∷ ID.Ident
+type VarRelR =
+  { var ∷ ID.Ident
   , alias ∷ Maybe ID.Ident
   }
 
@@ -42,7 +42,7 @@ type TableRelR =
 data Relation a
   = JoinRelation (JoinRelR a)
   | ExprRelation (ExprRelR a)
-  | VariRelation VariRelR
+  | VarRelation VarRelR
   | TableRelation TableRelR
 
 derive instance functorRelation ∷ Functor Relation
@@ -76,16 +76,16 @@ instance traversableRelation ∷ T.Traversable Relation where
     ExprRelation  { expr, alias } →
       (ExprRelation ∘ { expr: _, alias })
       <$> f expr
-    VariRelation v → pure $ VariRelation v
+    VarRelation v → pure $ VarRelation v
     TableRelation i → pure $ TableRelation i
   sequence = T.sequenceDefault
 
 printRelation ∷ Algebra Relation String
 printRelation = case _ of
   ExprRelation { expr, alias } →
     "(" <> expr <> ") AS " <> ID.printIdent alias
-  VariRelation { vari, alias } →
-    ":" <> ID.printIdent vari <> F.foldMap (\a → " AS " <> ID.printIdent a) alias
+  VarRelation { var, alias } →
+    ":" <> ID.printIdent var <> F.foldMap (\a → " AS " <> ID.printIdent a) alias
   TableRelation { path, alias } →
     "`"
     <> either Pt.printAnyDirPath Pt.printAnyFilePath path
@@ -105,19 +105,19 @@ genRelation n =
   if n < 1
   then
     Gen.oneOf $ genTable :|
-      [ genVari
+      [ genVar
       ]
   else
     Gen.oneOf $ genTable :|
-      [ genVari
+      [ genVar
       , genJoin
       , genExpr
       ]
   where
-  genVari = do
-    vari ← ID.Ident <$> GenS.genUnicodeString
+  genVar = do
+    var ← ID.Ident <$> GenS.genUnicodeString
     alias ← map ID.Ident <$> GenC.genMaybe GenS.genUnicodeString
-    pure $ VariRelation { vari, alias }
+    pure $ VarRelation { var, alias }
   genTable = do
     path ← Right <$> Pt.genAnyFilePath
     alias ← map ID.Ident <$> GenC.genMaybe GenS.genUnicodeString