Fix and re-apply formatter on all acceptance tests

Less noise, pretty tuples. Everyone's happy.

examples/acceptance_tests/006/lib/tests.ak

@@ -1,3 +1,3 @@
 test foo() {
-  #(1, []) == #(1, [])
+  (1, []) == (1, [])
 }

examples/acceptance_tests/007/lib/tests.ak

@@ -1,9 +1,9 @@
-pub fn unzip(xs: List<#(a, b)>) -> #(List<a>, List<b>) {
+pub fn unzip(xs: List<(a, b)>) -> (List<a>, List<b>) {
   when xs is {
-    [] -> #([], [])
+    [] -> ([], [])
-    [#(a, b), ..rest] -> {
+    [(a, b), ..rest] -> {
-      let #(a_tail, b_tail) = unzip(rest)
+      let (a_tail, b_tail) = unzip(rest)
-      #([a, ..a_tail], [b, ..b_tail])
+      ([a, ..a_tail], [b, ..b_tail])
     }
   }
 }

examples/acceptance_tests/013/lib/tests.ak

@@ -1,13 +1,13 @@
-pub fn unzip(xs: List<#(a, b)>) -> #(List<a>, List<b>) {
+pub fn unzip(xs: List<(a, b)>) -> (List<a>, List<b>) {
   when xs is {
-    [] -> #([], [])
+    [] -> ([], [])
-    [#(a, b), ..rest] -> {
+    [(a, b), ..rest] -> {
-      let #(a_tail, b_tail) = unzip(rest)
+      let (a_tail, b_tail) = unzip(rest)
-      #([a, ..a_tail], [b, ..b_tail])
+      ([a, ..a_tail], [b, ..b_tail])
     }
   }
 }
 
 test unzip_1() {
-  unzip([#(1, "a"), #(2, "b")]) == #([1, 2], ["a", "b"])
+  unzip([(1, "a"), (2, "b")]) == ([1, 2], ["a", "b"])
 }

examples/acceptance_tests/015/lib/tests.ak

@@ -1,5 +1,5 @@
 pub opaque type Map<key, value> {
-  inner: List<#(key, value)>,
+  inner: List<(key, value)>,
 }
 
 pub fn new() {

examples/acceptance_tests/016/lib/tests.ak

@@ -16,4 +16,3 @@ test drop_1() {
   let x = #[1, 2, 3, 4, 5, 6, 7]
   drop(x, 2) == #[3, 4, 5, 6, 7]
 }
-

examples/acceptance_tests/023/lib/tests.ak

@@ -1,12 +1,12 @@
 pub opaque type AssocList<key, value> {
-  inner: List<#(key, value)>,
+  inner: List<(key, value)>,
 }
 
 pub fn new() -> AssocList<key, value> {
   AssocList { inner: [] }
 }
 
-pub fn to_list(m: AssocList<key, value>) -> List<#(key, value)> {
+pub fn to_list(m: AssocList<key, value>) -> List<(key, value)> {
   m.inner
 }
 
@@ -19,17 +19,17 @@ pub fn insert(
 }
 
 fn do_insert(
-  elems: List<#(key, value)>,
+  elems: List<(key, value)>,
   k: key,
   v: value,
-) -> List<#(key, value)> {
+) -> List<(key, value)> {
   when elems is {
-    [] -> [#(k, v)]
+    [] -> [(k, v)]
-    [#(k2, v2), ..rest] ->
+    [(k2, v2), ..rest] ->
       if k == k2 {
-        [#(k, v), ..rest]
+        [(k, v), ..rest]
       } else {
-        [#(k2, v2), ..do_insert(rest, k, v)]
+        [(k2, v2), ..do_insert(rest, k, v)]
       }
   }
 }
@@ -41,5 +41,5 @@ fn fixture_1() {
 }
 
 test to_list_2() {
-  to_list(fixture_1()) == [#("foo", 42), #("bar", 14)]
+  to_list(fixture_1()) == [("foo", 42), ("bar", 14)]
 }

examples/acceptance_tests/024/lib/tests.ak

@@ -14,5 +14,5 @@ pub fn map2(
 }
 
 test map2_3() {
-  map2(Some(14), Some(42), fn(a, b) { #(a, b) }) == Some(#(14, 42))
+  map2(Some(14), Some(42), fn(a, b) { (a, b) }) == Some((14, 42))
 }

examples/acceptance_tests/029/lib/tests.ak

@@ -1,19 +1,19 @@
 pub opaque type AssocList<key, value> {
-  inner: List<#(key, value)>,
+  inner: List<(key, value)>,
 }
 
 pub fn new() -> AssocList<key, value> {
   AssocList { inner: [] }
 }
 
-pub fn from_list(xs: List<#(key, value)>) -> AssocList<key, value> {
+pub fn from_list(xs: List<(key, value)>) -> AssocList<key, value> {
   AssocList { inner: do_from_list(xs) }
 }
 
-fn do_from_list(xs: List<#(key, value)>) -> List<#(key, value)> {
+fn do_from_list(xs: List<(key, value)>) -> List<(key, value)> {
   when xs is {
     [] -> []
-    [#(k, v), ..rest] -> do_insert(do_from_list(rest), k, v)
+    [(k, v), ..rest] -> do_insert(do_from_list(rest), k, v)
   }
 }
 
@@ -26,35 +26,35 @@ pub fn insert(
 }
 
 fn do_insert(
-  elems: List<#(key, value)>,
+  elems: List<(key, value)>,
   k: key,
   v: value,
-) -> List<#(key, value)> {
+) -> List<(key, value)> {
   when elems is {
-    [] -> [#(k, v)]
+    [] -> [(k, v)]
-    [#(k2, v2), ..rest] ->
+    [(k2, v2), ..rest] ->
       if k == k2 {
-        [#(k, v), ..rest]
+        [(k, v), ..rest]
       } else {
-        [#(k2, v2), ..do_insert(rest, k, v)]
+        [(k2, v2), ..do_insert(rest, k, v)]
       }
   }
 }
 
 pub fn union(
-  left left: AssocList<key, value>,
+  left: AssocList<key, value>,
-  right right: AssocList<key, value>,
+  right: AssocList<key, value>,
 ) -> AssocList<key, value> {
   AssocList { inner: do_union(left.inner, right.inner) }
 }
 
 fn do_union(
-  left: List<#(key, value)>,
+  left: List<(key, value)>,
-  right: List<#(key, value)>,
+  right: List<(key, value)>,
-) -> List<#(key, value)> {
+) -> List<(key, value)> {
   when left is {
     [] -> right
-    [#(k, v), ..rest] -> do_union(rest, do_insert(right, k, v))
+    [(k, v), ..rest] -> do_union(rest, do_insert(right, k, v))
   }
 }
 

examples/acceptance_tests/032/lib/tests.ak

@@ -1,11 +1,9 @@
 fn is_negative(i: Int) -> Bool {
   if i < 0 {
     trace("is negative")
-
     True
   } else {
     trace("is non-negative")
-
     False
   }
 }

examples/acceptance_tests/033/lib/tests.ak

@@ -1,4 +1,4 @@
 test tuple_1() {
-  let coordinates = #(14, 42)
+  let coordinates = (14, 42)
   coordinates.1st == 14 && coordinates.2nd == 42
 }

examples/acceptance_tests/035/lib/aiken/dict.ak

@@ -1,7 +1,7 @@
 /// An opaque `Dict`. The type is opaque because the module maintains some
 /// invariant, namely: there's only one occurence of a given key in the dictionnary.
 pub opaque type Dict<key, value> {
-  inner: List<#(ByteArray, value)>,
+  inner: List<(ByteArray, value)>,
 }
 
 pub fn toList(self: Dict<ByteArray, value>) {
@@ -32,33 +32,33 @@ pub fn union_with(
 }
 
 fn do_union_with(
-  left: List<#(ByteArray, value)>,
+  left: List<(ByteArray, value)>,
-  right: List<#(ByteArray, value)>,
+  right: List<(ByteArray, value)>,
   with: fn(ByteArray, value, value) -> Option<value>,
-) -> List<#(ByteArray, value)> {
+) -> List<(ByteArray, value)> {
   when left is {
     [] -> right
-    [#(k, v), ..rest] ->
+    [(k, v), ..rest] ->
       do_union_with(rest, do_insert_with(right, k, v, with), with)
   }
 }
 
 fn do_insert_with(
-  self: List<#(ByteArray, value)>,
+  self: List<(ByteArray, value)>,
   key k: ByteArray,
   value v: value,
   with: fn(ByteArray, value, value) -> Option<value>,
-) -> List<#(ByteArray, value)> {
+) -> List<(ByteArray, value)> {
   when self is {
-    [] -> [#(k, v)]
+    [] -> [(k, v)]
-    [#(k2, v2), ..rest] ->
+    [(k2, v2), ..rest] ->
       if k == k2 {
         when with(k, v, v2) is {
-          Some(combined) -> [#(k, combined), ..rest]
+          Some(combined) -> [(k, combined), ..rest]
           None -> rest
         }
       } else {
-        [#(k2, v2), ..do_insert_with(rest, k, v, with)]
+        [(k2, v2), ..do_insert_with(rest, k, v, with)]
       }
   }
 }

examples/acceptance_tests/035/lib/tests.ak

@@ -30,7 +30,8 @@ pub fn add(left v0: Value, right v1: Value) -> Value {
     v0,
     v1,
     fn(_, a0, a1) {
-      let asset = dict.union_with(
+      let asset =
+        dict.union_with(
           a0,
           a1,
           fn(_, q0, q1) {

examples/acceptance_tests/036/aiken.lock

@@ -3,11 +3,11 @@
 
 [[requirements]]
 name = "aiken-lang/stdlib"
-version = "6b482fa00ec37fe936c93155e8c670f32288a686"
+version = "1cedbe85b7c7e9c4036d63d45cad4ced27b0d50b"
 source = "github"
 
 [[packages]]
 name = "aiken-lang/stdlib"
-version = "6b482fa00ec37fe936c93155e8c670f32288a686"
+version = "1cedbe85b7c7e9c4036d63d45cad4ced27b0d50b"
 requirements = []
 source = "github"

examples/acceptance_tests/036/aiken.toml

@@ -2,5 +2,5 @@ name = "aiken-lang/acceptance_test_036"
 version = "0.0.0"
 
 dependencies = [
-  { name = "aiken-lang/stdlib", version = "6b482fa00ec37fe936c93155e8c670f32288a686", source = "github" },
+  { name = "aiken-lang/stdlib", version = "1cedbe85b7c7e9c4036d63d45cad4ced27b0d50b", source = "github" },
 ]

examples/acceptance_tests/039/lib/tests.ak

@@ -1,13 +1,8 @@
-
-
-
 pub type Door {
   locked: Bool,
-  hinge_angle: Int 
+  hinge_angle: Int,
 }
 
-
-
 pub type Car {
   owner: ByteArray,
   wheels: Int,
@@ -15,46 +10,98 @@ pub type Car{
   vin: ByteArray,
 }
 
-
 pub fn update_owner(new_owner: ByteArray, car: Car) {
   Car { ..car, owner: new_owner }
-  
 }
 
 pub fn update_vin(new_vin: ByteArray, car: Car) {
   Car { ..car, vin: new_vin }
 }
 
-
 pub fn update_door_angle(new_hinge_angle: Int, car: Car) {
   Car { ..car, door: Door { ..car.door, hinge_angle: new_hinge_angle } }
 }
 
-pub fn update_door_locked_and_wheels(new_locked: Bool, new_wheels: Int, car: Car){
+pub fn update_door_locked_and_wheels(
-  Car{..car, door: Door{..car.door, locked: new_locked}, wheels: new_wheels}
+  new_locked: Bool,
-
+  new_wheels: Int,
+  car: Car,
+) {
+  Car {
+    ..car,
+    door: Door { ..car.door, locked: new_locked },
+    wheels: new_wheels,
+  }
 }
 
 test update_owner1() {
-  let initial_car = Car{owner: #[], wheels: 4, vin: #[1,1,1,1,1,1,1], door: Door{locked: False, hinge_angle: 45}}
+  let initial_car =
-  let final_car = Car{owner: #[244, 244, 244, 244], wheels: 4, vin: #[1,1,1,1,1,1,1], door: Door{locked: False, hinge_angle: 45}}
+    Car {
+      owner: #[],
+      wheels: 4,
+      vin: #[1, 1, 1, 1, 1, 1, 1],
+      door: Door { locked: False, hinge_angle: 45 },
+    }
+  let final_car =
+    Car {
+      owner: #[244, 244, 244, 244],
+      wheels: 4,
+      vin: #[1, 1, 1, 1, 1, 1, 1],
+      door: Door { locked: False, hinge_angle: 45 },
+    }
   update_owner(#[244, 244, 244, 244], initial_car) == final_car
 }
 
 test update_vin1() {
-  let initial_car = Car{owner: #[], wheels: 4, vin: #[1,1,1,1,1,1,1], door: Door{locked: False, hinge_angle: 45}}
+  let initial_car =
-  let final_car = Car{owner: #[], wheels: 4, vin: #[2,2,2,2,2,2,2,2,2], door: Door{locked: False, hinge_angle: 45}}
+    Car {
+      owner: #[],
+      wheels: 4,
+      vin: #[1, 1, 1, 1, 1, 1, 1],
+      door: Door { locked: False, hinge_angle: 45 },
+    }
+  let final_car =
+    Car {
+      owner: #[],
+      wheels: 4,
+      vin: #[2, 2, 2, 2, 2, 2, 2, 2, 2],
+      door: Door { locked: False, hinge_angle: 45 },
+    }
   update_vin(#[2, 2, 2, 2, 2, 2, 2, 2, 2], initial_car) == final_car
 }
 
 test update_door_angle1() {
-  let initial_car = Car{owner: #[], wheels: 4, vin: #[1,1,1,1,1,1,1], door: Door{locked: False, hinge_angle: 45}}
+  let initial_car =
-  let final_car = Car{owner: #[], wheels: 4, vin: #[1,1,1,1,1,1,1], door: Door{locked: False, hinge_angle: 90}}
+    Car {
+      owner: #[],
+      wheels: 4,
+      vin: #[1, 1, 1, 1, 1, 1, 1],
+      door: Door { locked: False, hinge_angle: 45 },
+    }
+  let final_car =
+    Car {
+      owner: #[],
+      wheels: 4,
+      vin: #[1, 1, 1, 1, 1, 1, 1],
+      door: Door { locked: False, hinge_angle: 90 },
+    }
   update_door_angle(90, initial_car) == final_car
 }
 
 test update_door_locked_and_wheels1() {
-  let initial_car = Car{owner: #[], wheels: 4, vin: #[1,1,1,1,1,1,1], door: Door{locked: False, hinge_angle: 45}}
+  let initial_car =
-  let final_car = Car{owner: #[], wheels: 5, vin: #[1,1,1,1,1,1,1], door: Door{locked: True, hinge_angle: 45}}
+    Car {
+      owner: #[],
+      wheels: 4,
+      vin: #[1, 1, 1, 1, 1, 1, 1],
+      door: Door { locked: False, hinge_angle: 45 },
+    }
+  let final_car =
+    Car {
+      owner: #[],
+      wheels: 5,
+      vin: #[1, 1, 1, 1, 1, 1, 1],
+      door: Door { locked: True, hinge_angle: 45 },
+    }
   update_door_locked_and_wheels(True, 5, initial_car) == final_car
 }