code cleanup with fsharp-refactor tool

Author: Thorium

src/SQLProvider.Fable.Core/Crud.fs

@@ -88,7 +88,7 @@ module Insert =
     /// would otherwise take the previous row's value for it.
     let combine (inserts: Insert list) : InsertMany =
         match inserts with
-        | [] -> failwith "Insert.combine: no rows"
+        | [] -> failwith $"Insert.combine: no rows, calling combine with inserts: {inserts}"
         | first :: _ ->
             let columns = first.Assignments |> Array.map (fun a -> a.Column)
 
@@ -104,7 +104,7 @@ module Insert =
                 let theseColumns = i.Assignments |> Array.map (fun a -> a.Column)
 
                 if theseColumns.Length <> columns.Length then
-                    failwith "Insert.combine: rows set different numbers of columns"
+                    failwith $"Insert.combine: rows set different numbers of columns, calling combine with inserts: {inserts}"
 
                 Array.iteri
                     (fun n (c: string) ->

src/SQLProvider.Fable.Core/Dialect.fs

@@ -74,7 +74,7 @@ module Dialect =
 
                         match style with
                         | Numbered -> out.Append('$').Append(ordered.Count) |> ignore
-                        | _ -> out.Append('?') |> ignore
+                        | Named | Positional -> out.Append('?') |> ignore
 
                         i <- last
                     | None ->

src/SQLProvider.Fable.Core/Execute.fs

@@ -37,9 +37,8 @@ module Db =
     /// `tryHead` when an empty result is an answer rather than a bug.
     let head (conn: ISqlConnector) (q: Query) : Async<SqlRow> =
         async {
-            let! row = tryHead conn q
 
-            match row with
+            match! tryHead conn q with
             | Some r -> return r
             | None -> return failwith "head: the query returned no rows"
         }
@@ -62,9 +61,8 @@ module Db =
     /// LINQ's `exactlyOne`.
     let exactlyOne (conn: ISqlConnector) (q: Query) : Async<SqlRow> =
         async {
-            let! row = tryExactlyOne conn q
 
-            match row with
+            match! tryExactlyOne conn q with
             | Some r -> return r
             | None -> return failwith "exactlyOne: the query returned no rows"
         }

src/SQLProvider.Fable.Core/Query.fs

@@ -234,7 +234,7 @@ module Col =
     let int64 table name : Column<int64> = make table name SqlInt
 
     let int table name : Column<int> =
-        make table name (fun v -> SqlInt(widen v))
+        make table name (widen >> SqlInt)
 
     let text table name : Column<string> = make table name SqlText
     let float table name : Column<float> = make table name SqlFloat
@@ -355,8 +355,7 @@ module Expr =
         // Indexed rather than `for ch in value`: a string has no enumerator on
         // Fable's Rust target (G27), and indexing is what the rest of this
         // library already uses to walk one.
-        for i in 0 .. value.Length - 1 do
-            let ch = value.[i]
+        for ch in value do
 
             if ch = '%' || ch = '_' || ch = likeEscapeChar then
                 parts.Add(string likeEscapeChar)

src/SQLProvider.Fable.Core/SqlGen.fs

@@ -76,54 +76,54 @@ module SqlGen =
     /// reordering. Returns None where the engine has no equivalent.
     let private fnName (vendor: Vendor) (fn: SqlFn) =
         match fn, vendor with
-        | Upper, _ -> Some "UPPER"
-        | Lower, _ -> Some "LOWER"
-        | Trim, _ -> Some "TRIM"
-        | Replace, _ -> Some "REPLACE"
-        | Abs, _ -> Some "ABS"
-
-        | Length, Sqlite -> Some "LENGTH"
-        | Length, Postgres -> Some "CHAR_LENGTH"
-        | Length, MySql -> Some "CHAR_LENGTH"
-        | Length, Generic -> Some "LENGTH"
-
-        | Substring, MySql -> Some "MID"
-        | Substring, Sqlite -> Some "SUBSTR"
-        | Substring, _ -> Some "SUBSTRING"
-
-        | IndexOf, Postgres -> Some "STRPOS"
-        | IndexOf, MySql -> Some "LOCATE"
-        | IndexOf, Sqlite -> Some "INSTR"
-        | IndexOf, Generic -> Some "INSTR"
+        | Upper, _ -> ValueSome "UPPER"
+        | Lower, _ -> ValueSome "LOWER"
+        | Trim, _ -> ValueSome "TRIM"
+        | Replace, _ -> ValueSome "REPLACE"
+        | Abs, _ -> ValueSome "ABS"
+
+        | Length, Sqlite -> ValueSome "LENGTH"
+        | Length, Postgres -> ValueSome "CHAR_LENGTH"
+        | Length, MySql -> ValueSome "CHAR_LENGTH"
+        | Length, Generic -> ValueSome "LENGTH"
+
+        | Substring, MySql -> ValueSome "MID"
+        | Substring, Sqlite -> ValueSome "SUBSTR"
+        | Substring, _ -> ValueSome "SUBSTRING"
+
+        | IndexOf, Postgres -> ValueSome "STRPOS"
+        | IndexOf, MySql -> ValueSome "LOCATE"
+        | IndexOf, Sqlite -> ValueSome "INSTR"
+        | IndexOf, Generic -> ValueSome "INSTR"
 
         // Every engine's plain-rounding function has the same name.
-        | Round, _ -> Some "ROUND"
+        | Round, _ -> ValueSome "ROUND"
 
         // The rest are not plain function calls on every engine, so they are
         // handled separately below and never reach this table.
-        | (Year | Month | Day | Hour | Minute | Second | DateOnly), _ -> None
-        | (Ceiling | Floor | RoundTo _ | Truncate | Greatest | Least), _ -> None
-        | (CastText | CastInt | DateDiffDays | DateDiffSecs), _ -> None
+        | (Year | Month | Day | Hour | Minute | Second | DateOnly), _ -> ValueNone
+        | (Ceiling | Floor | RoundTo _ | Truncate | Greatest | Least), _ -> ValueNone
+        | (CastText | CastInt | DateDiffDays | DateDiffSecs), _ -> ValueNone
 
     /// SQLite has no YEAR(); it has STRFTIME with a format string. PostgreSQL
     /// wants EXTRACT(field FROM x). MySQL has the plain function.
     let private datePartName (fn: SqlFn) =
         match fn with
-        | Year -> Some("YEAR", "%Y")
-        | Month -> Some("MONTH", "%m")
-        | Day -> Some("DAY", "%d")
-        | Hour -> Some("HOUR", "%H")
-        | Minute -> Some("MINUTE", "%M")
-        | Second -> Some("SECOND", "%S")
-        | _ -> None
+        | Year -> ValueSome("YEAR", "%Y")
+        | Month -> ValueSome("MONTH", "%m")
+        | Day -> ValueSome("DAY", "%d")
+        | Hour -> ValueSome("HOUR", "%H")
+        | Minute -> ValueSome("MINUTE", "%M")
+        | Second -> ValueSome("SECOND", "%S")
+        | _ -> ValueNone
 
     let rec private renderExpr (b: Builder) (e: SqlExpr) =
         let append (s: string) = write b s
 
         match e with
         | ColumnRef(table, column) ->
             if b.Qualify then
-                append (table + "." + column)
+                append ($"{table}.{column}")
             else
                 append column
 
@@ -385,7 +385,7 @@ module SqlGen =
         match b.Vendor with
         | Sqlite
         | Generic -> append (sqliteName + "(")
-        | _ -> append (name + "(")
+        | Postgres | MySql -> append (name + "(")
 
         renderExpr b first
         append ", "
@@ -491,29 +491,29 @@ module SqlGen =
         let append (s: string) = write b s
 
         match datePartName fn with
-        | Some(name, strftime) ->
+        | ValueSome(name, strftime) ->
             let arg = oneArg fn args
 
             (match b.Vendor with
              | Sqlite ->
                  // STRFTIME returns text, so cast back to a number to keep
                  // comparisons behaving like the other engines.
-                 append ("CAST(STRFTIME('" + strftime + "', ")
+                 append ($"CAST(STRFTIME('{strftime}', ")
                  renderExpr b arg
                  append ") AS INTEGER)"
              | Postgres ->
-                 append ("EXTRACT(" + name + " FROM ")
+                 append ($"EXTRACT({name} FROM ")
                  renderExpr b arg
                  append ")"
              | MySql
              | Generic ->
                  append (name + "(")
                  renderExpr b arg
                  append ")")
-        | None ->
+        | ValueNone ->
             match fnName b.Vendor fn with
-            | None -> failwith ("SqlGen: no SQL mapping for " + string fn)
-            | Some name ->
+            | ValueNone -> failwith ("SqlGen: no SQL mapping for " + string fn)
+            | ValueSome name ->
                 // PostgreSQL's STRPOS takes (haystack, needle) like .NET's
                 // IndexOf; MySQL's LOCATE takes (needle, haystack).
                 let args =
@@ -585,15 +585,15 @@ module SqlGen =
 
             append "DATETIME("
             renderExpr b inner
-            append (", '" + signed + " " + unitName + "s')")
+            append ($", '{signed} {unitName}s')")
 
     and private renderSource (b: Builder) (s: Source) =
         let append (t: string) = write b t
 
         if s.Alias = s.Table then
             append s.Table
         else
-            append (s.Table + " AS " + s.Alias)
+            append ($"{s.Table} AS {s.Alias}")
 
     /// Renders a query into an existing builder, so a subquery shares the outer
     /// statement's parameter list and stays numbered in the order the SQL
@@ -766,7 +766,7 @@ module SqlGen =
         // Columns are bare here, not qualified: an INSERT names exactly one
         // table and every engine rejects `INSERT INTO t (t.c) ..`.
         let b = newBuilder vendor false
-        write b ("INSERT INTO " + i.Table + " (")
+        write b ($"INSERT INTO {i.Table} (")
 
         i.Assignments
         |> Array.iteri (fun n a ->
@@ -802,7 +802,7 @@ module SqlGen =
             failwith "SqlGen: the insert has no rows"
 
         let b = newBuilder vendor false
-        write b ("INSERT INTO " + i.Table + " (")
+        write b ($"INSERT INTO {i.Table} (")
 
         i.Columns
         |> Array.iteri (fun n c ->
@@ -840,7 +840,7 @@ module SqlGen =
         match vendor with
         | Postgres ->
             let sql, ps = renderInsert vendor i
-            Some(sql + " RETURNING " + keyColumn, ps)
+            Some($"{sql} RETURNING {keyColumn}", ps)
         | _ -> None
 
     /// The query that reports the key the last insert on this connection
@@ -861,7 +861,7 @@ module SqlGen =
             failwith "SqlGen: the update has no WHERE and would rewrite every row -- say Update.all if that is meant"
 
         let b = newBuilder vendor false
-        write b ("UPDATE " + u.Table + " SET ")
+        write b ($"UPDATE {u.Table} SET ")
         renderAssignments b u.Assignments
 
         match u.Where with

src/SQLProvider.Fable.Core/SqlValue.fs

@@ -121,11 +121,11 @@ module Convert =
                     // range instead of overflowing at 19.
                     let mutable mantissa = 0M
 
-                    for i in 0 .. intPart.Length - 1 do
-                        mantissa <- mantissa * 10M + decimal (int intPart.[i] - int '0')
+                    for x in intPart do
+                        mantissa <- mantissa * 10M + decimal (int x - int '0')
 
-                    for i in 0 .. fracPart.Length - 1 do
-                        mantissa <- mantissa * 10M + decimal (int fracPart.[i] - int '0')
+                    for x in fracPart do
+                        mantissa <- mantissa * 10M + decimal (int x - int '0')
 
                     let mutable scale = 1M
 

src/SQLProvider.Fable.Design/CodeGen.fs

@@ -67,7 +67,7 @@ module CodeGen =
     /// The identifier a name becomes in the generated source.
     let identifier (name: string) =
         if keywords.Contains name then
-            "``" + name + "``"
+            $"``{name}``"
         else
             // Anything that is not a plain identifier gets backticks too, which
             // covers spaces and punctuation without renaming the column.
@@ -76,7 +76,7 @@ module CodeGen =
                 && (System.Char.IsLetter name.[0] || name.[0] = '_')
                 && name |> Seq.forall (fun c -> System.Char.IsLetterOrDigit c || c = '_')
 
-            if isPlain then name else "``" + name + "``"
+            if isPlain then name else $"``{name}``"
 
     let private colFactory (kind: ColumnKind) =
         match kind with
@@ -131,7 +131,7 @@ module CodeGen =
         line ("/// " + t.Name + (if t.IsView then " (view -- readable, not writable)" else ""))
         line ("module " + identifier t.Name + " =")
         line ""
-        line ("    let table = \"" + t.Name + "\"")
+        line ($"    let table = \"{t.Name}\"")
         line ""
 
         for c in t.Columns do
@@ -265,7 +265,7 @@ module CodeGen =
                 let condition =
                     fk.Columns
                     |> Array.map pairExpr
-                    |> Array.reduce (fun acc part -> "Expr.andAlso (" + acc + ") (" + part + ")")
+                    |> Array.reduce (fun acc part -> $"Expr.andAlso ({acc}) ({part})")
 
                 line ("        /// " + (fk.Columns |> Array.map pairDoc |> String.concat ", "))
                 line ("        let " + identifier name + " = " + condition)

tests/Beam/Program.fs

@@ -30,8 +30,8 @@ let private convertChecks () =
         Harness.isTrue "guid round-trips" (Convert.tryParseGuid "0f8fad5b-d9cb-469f-a165-70867728950e" = Some theId)
     )
 
-    results.Add(Harness.isTrue "junk decimal is rejected" (Convert.tryParseDecimal "1,5" = None))
-    results.Add(Harness.isTrue "junk date is rejected" (Convert.tryParseDate "not a date" = None))
+    results.Add(Harness.isTrue "junk decimal is rejected" ((Convert.tryParseDecimal "1,5") |> Option.isNone))
+    results.Add(Harness.isTrue "junk date is rejected" ((Convert.tryParseDate "not a date") |> Option.isNone))
 
     results.ToArray()
 
@@ -51,7 +51,7 @@ let private rowChecks () =
     results.Add(Harness.check "text column" "Alfreds" (Row.text rows.[0] "Name"))
     results.Add(Harness.check "int column" "2" (string (Row.int rows.[1] "Id")))
     results.Add(Harness.check "case-insensitive lookup" "Alfreds" (Row.text rows.[0] "nAmE"))
-    results.Add(Harness.isTrue "null maps to None" (Row.textOpt rows.[0] "Country" = None))
+    results.Add(Harness.isTrue "null maps to None" ((Row.textOpt rows.[0] "Country") |> Option.isNone))
     results.Add(Harness.isTrue "non-null maps to Some" (Row.textOpt rows.[1] "Country" = Some "Sweden"))
     // An integer storage class in a float column has to widen, not fail.
     results.Add(Harness.isTrue "int widens to float" (Row.float rows.[1] "Balance" = 250.0))

tests/SQLProvider.Fable.SmokeTests/DialectTests.fs

@@ -20,7 +20,7 @@ let private render (sql: string, values: SqlValue[]) =
             | other -> SqlValue.typeName other)
         |> String.concat ","
 
-    sql + " | " + vs
+    $"{sql} | {vs}"
 
 let run () : TestResult[] =
     let results = ResizeArray<TestResult>()

tests/SQLProvider.Fable.SmokeTests/Harness.fs

@@ -24,7 +24,7 @@ let check name expected actual =
     if expected = actual then
         pass name
     else
-        fail name ("expected " + expected + ", got " + actual)
+        fail name ($"expected {expected}, got {actual}")
 
 /// Asserts a condition without stringifying it. `string true` is "True" on
 /// .NET and Rust but "true" on JavaScript, so a boolean must never reach
@@ -45,7 +45,7 @@ let report (results: TestResult[]) =
             if r.Passed then
                 "  PASS  " + r.Name
             else
-                "  FAIL  " + r.Name + " -- " + r.Detail)
+                $"  FAIL  {r.Name} -- {r.Detail}")
 
     let summary =
         "  "