Format jscomp/test (#6983)

Author: cknitt

jscomp/test/AsInUncurriedExternals.res

@@ -12,5 +12,4 @@ let mo = makeOptions
 
 let options = mo(~name="foo", ())
 
-let shouldNotFail: (~objectMode: _, ~name: string) => int = (~objectMode, ~name) =>
-  3
+let shouldNotFail: (~objectMode: _, ~name: string) => int = (~objectMode, ~name) => 3

jscomp/test/Coercion.res

@@ -2,10 +2,10 @@ let x = 1
 
 let xx = (x :> float)
 
-type r1 = {x:int}
-type r2 = {x:int}
+type r1 = {x: int}
+type r2 = {x: int}
 
 type t1 = array<r1>
 type t2 = array<r2>
 
-let foo = (x: t1) => { x :> t2 }
+let foo = (x: t1) => {(x :> t2)}

jscomp/test/DerivingAccessorsCurried.res

@@ -2,10 +2,10 @@
 //In curried mode
 
 @deriving(accessors)
-type myRecord = { myField: int }
+type myRecord = {myField: int}
 
 @deriving(accessors)
-type variant = | NoParam | Num(int) | DoubleNum(int, int)
+type variant = NoParam | Num(int) | DoubleNum(int, int)
 
 //Asserts the correct signature for derived accessor
 let _myFieldAlias: myRecord => int = myField
@@ -16,6 +16,5 @@ let _doubleNumAlias: (int, int) => variant = doubleNum
 //Asserts that inference works when composing
 //with derived functions
 let compose = (a, accessor) => accessor(a)
-let _composedMyField = compose({ myField: 1 }, myField)
+let _composedMyField = compose({myField: 1}, myField)
 let _composedNum = compose(1, num)
-

jscomp/test/DerivingAccessorsUncurried.res

@@ -3,10 +3,10 @@
 @@uncurried
 
 @deriving(accessors)
-type myRecord = { myField: int }
+type myRecord = {myField: int}
 
 @deriving(accessors)
-type variant = | NoParam | Num(int) | DoubleNum(int, int)
+type variant = NoParam | Num(int) | DoubleNum(int, int)
 
 //Asserts the correct signature for derived accessor
 let _myFieldAlias: myRecord => int = myField
@@ -17,6 +17,5 @@ let _doubleNumAlias: (int, int) => variant = doubleNum
 //Asserts that inference works when composing
 //with derived functions
 let compose = (a, accessor) => accessor(a)
-let _composedMyField = compose({ myField: 1 }, myField)
+let _composedMyField = compose({myField: 1}, myField)
 let _composedNum = compose(1, num)
-

jscomp/test/DisambiguateOptionalFields.res

@@ -1,8 +1,8 @@
-type t1 = {x:int, y:int}
-type t2 = {x:int, y:int, z?:int}
+type t1 = {x: int, y: int}
+type t2 = {x: int, y: int, z?: int}
 
-let f1 = (v:t1) => v.x
-let f2 = (v:t2) => v.x
+let f1 = (v: t1) => v.x
+let f2 = (v: t2) => v.x
 
-let v = {x:3, y:4}
+let v = {x: 3, y: 4}
 let res = f2(v) // Check that t2 shadows t1

jscomp/test/EmptyRecord.res

@@ -1,10 +1,10 @@
-type allOptRec = {n?: int, s?:string}
+type allOptRec = {n?: int, s?: string}
 
-let construct = (b) => b ? {n:0} : {}
+let construct = b => b ? {n: 0} : {}
 
 // let z = {}
 // Error: Empty record literal {} should be type annotated or used in a record context.
 
 type emptyrec = {}
 
-let er : emptyrec = {}
+let er: emptyrec = {}

jscomp/test/Import.res

@@ -3,7 +3,7 @@ let eachIntAsync = async (list: list<int>, f: int => unit) => {
 }
 
 let eachIntLazy = (list: list<int>, f: int => unit) =>
-  Js.import(Belt.List.forEach) |> Js.Promise.then_(each => list->each(f)->Js.Promise.resolve)
+  Js.Promise.then_(each => list->each(f)->Js.Promise.resolve, Js.import(Belt.List.forEach))
 
 let _ = list{1, 2, 3}->eachIntLazy(n => Js.log2("lazy", n))
 let _ = list{1, 2, 3}->eachIntAsync(n => Js.log2("async", n))

jscomp/test/RecordOrObject.res

@@ -1,10 +1,10 @@
 type rx = {x: int}
 type ry = {y: string}
-type rxi = {...rx, i?:int}
+type rxi = {...rx, i?: int}
 type rxy = {...rx, ...ry} // this is a record
 
 let vxy: rxy = {x: 10, y: "abc"}
-let xxi : rxi = {x:10}
+let xxi: rxi = {x: 10}
 
 type ox = {"x": int}
 type oy = {"y": int}

jscomp/test/SafePromises.res

@@ -3,17 +3,17 @@
 let nestedPromise = async (xxx: promise<promise<int>>) => {
   let xx = await xxx
 
-  let _ = xx->Js.Promise2.then(x => Js.log2("Promise2.then", x) |> Js.Promise.resolve)
+  let _ = xx->Js.Promise2.then(x => Js.Promise.resolve(Js.log2("Promise2.then", x)))
   let _ = xx->Js.Promise2.catch(x => {
     Js.log2("Promise2.catch_", x)
-    0 |> Js.Promise.resolve
+    Js.Promise.resolve(0)
   })
 
   // This crashes
-  let _ = Js.Promise.then_(x => Js.log2("Promise.then_", x) |> Js.Promise.resolve, xx)
+  let _ = Js.Promise.then_(x => Js.Promise.resolve(Js.log2("Promise.then_", x)), xx)
 }
 
-let create = async (x) => {
+let create = async x => {
   Js.log2("create", x)
   x
 }

jscomp/test/UncurriedAlways.res

@@ -2,21 +2,21 @@
 
 let foo = (x, y) => x + y
 
-let z = foo(. 3, 4)
+let z = foo(3, 4)
 
-let bar = (. x, y) => x + y
+let bar = (x, y) => x + y
 
 let b = bar(3, 4)
 
 let w = 3->foo(4)
 
-let a = 3->foo(. 4)
+let a = 3->foo(4)
 
 Js.log(a) // Test automatic uncurried application
 
-let _ = Js.Array2.map([1], (. x) => x + 1)
+let _ = Js.Array2.map([1], x => x + 1)
 
-let ptl = @res.partial foo(10) // force partial application
+let ptl = foo(10, ...) // force partial application
 
 let foo2 = (x, y) => x + y
 let bar2: _ => _ = foo2(_, 3)
@@ -31,7 +31,7 @@ let q: cmp = _ => Jsx.null // Check that subtyping works past type definitions
 let inl = () => ()
 
 @inline
-let inl2 = (x,y) => x+y
+let inl2 = (x, y) => x + y
 
 module AllLabels = {
   let foo = (~x, ~y, ~z) => (x, y, z)
@@ -54,7 +54,17 @@ module OptAtEnd = {
 }
 
 module OptMixed = {
-  let foo = (~d1="d1=0", ~x, ~d2="d2=0",  ~y, ~d3="d3=0", ~z, ~d4="d4=0", ~w, ~d5="d5=0") => (d1, x, d2, y, d3, z, d4, w, d5)
+  let foo = (~d1="d1=0", ~x, ~d2="d2=0", ~y, ~d3="d3=0", ~z, ~d4="d4=0", ~w, ~d5="d5=0") => (
+    d1,
+    x,
+    d2,
+    y,
+    d3,
+    z,
+    d4,
+    w,
+    d5,
+  )
 
   let ptl = foo(~y="y", ~w="w", ...)
 
@@ -72,7 +82,7 @@ let fn = cb => {
 
 fn(s => Js.log(#foo(s)))
 
-let fn1 = (a, b, ()) => a() + b 
+let fn1 = (a, b, ()) => a() + b
 
 let a = fn1(() => 1, 2, _)
 
@@ -93,7 +103,7 @@ module PartialApplication = {
 
 module ReverseApplication = {
   let hello1 = (y, f) => f(y)
-  let hello2 = (y, f) => y |> f
+  let hello2 = (y, f) => f(y)
 }
 
 module Pipe = {
@@ -104,4 +114,4 @@ module Pipe = {
   let f3 = (foo, x) => foo(x)
 
   let f4 = (x, f) => x->f(3)
-}
+}