diff --git a/src/lenient_parse/internal/build.gleam b/src/lenient_parse/internal/build.gleam
index e39e9c0..1377401 100644
--- a/src/lenient_parse/internal/build.gleam
+++ b/src/lenient_parse/internal/build.gleam
@@ -18,7 +18,7 @@ pub fn float_value(
 ) -> Result(Float, ParseError) {
   let #(whole_digits, fractional_digits) =
     scale.deques(whole_digits, fractional_digits, scale_factor)
-  let exponent = fractional_digits |> deque.length
+  let exponent = deque.length(fractional_digits)
   let #(digits, _) = scale.deques(whole_digits, fractional_digits, exponent)
 
   // `bigi.undigits` documentation says it can fail if:
@@ -29,8 +29,8 @@ pub fn float_value(
   //   parser has already raised an error.
   // Therefore, the error case here should be unreachable. If not, there is a
   // bug in the prior code.
-  let digits_list = digits |> deque.to_list
-  case digits_list |> bigi.undigits(base_10) {
+  let digits_list = deque.to_list(digits)
+  case bigi.undigits(digits_list, base_10) {
     Error(_) -> panic as "unreachable"
     Ok(coefficient) -> {
       let sign =
@@ -47,15 +47,15 @@ pub fn float_value(
           exponent: bigi.from_int(-exponent),
         )
 
-      case decimal |> pilkku.to_float {
+      case pilkku.to_float(decimal) {
         // `pilkku.to_float` returns 0.0 for both 0.0 and -0.0
         Ok(float_value) if float_value == 0.0 && !is_positive -> Ok(-0.0)
         Ok(float_value) -> Ok(float_value)
         Error(_) -> {
           let float_string =
             float_string(
-              whole_digits: whole_digits |> deque.to_list,
-              fractional_digits: fractional_digits |> deque.to_list,
+              whole_digits: deque.to_list(whole_digits),
+              fractional_digits: deque.to_list(fractional_digits),
               is_positive: is_positive,
             )
           Error(OutOfFloatRange(float_string))
@@ -78,11 +78,11 @@ pub fn integer_value(
   //   parser has already raised an error.
   // Therefore, the error case here should be unreachable. If not, there is a
   // bug in the prior code.
-  let digits_list = digits |> deque.to_list
-  case digits_list |> bigi.undigits(base) {
+  let digits_list = deque.to_list(digits)
+  case bigi.undigits(digits_list, base) {
     Error(_) -> panic as "unreachable"
     Ok(big_int) ->
-      case big_int |> bigi.to_int {
+      case bigi.to_int(big_int) {
         Ok(value) -> {
           let value = case is_positive {
             True -> value
@@ -91,7 +91,7 @@ pub fn integer_value(
           Ok(value)
         }
         Error(_) -> {
-          let integer_string = digits_list |> integer_string(is_positive)
+          let integer_string = integer_string(digits_list, is_positive)
           Error(OutOfIntRange(integer_string))
         }
       }
diff --git a/src/lenient_parse/internal/parser.gleam b/src/lenient_parse/internal/parser.gleam
index 521262e..f7bac79 100644
--- a/src/lenient_parse/internal/parser.gleam
+++ b/src/lenient_parse/internal/parser.gleam
@@ -70,7 +70,7 @@ pub fn parse_float_tokens(
         parse_data,
       )
 
-      let parse_data = case exponent_digits |> deque.is_empty {
+      let parse_data = case deque.is_empty(exponent_digits) {
         True ->
           Error(InvalidExponentSymbolPosition(next_index - 1, exponent_symbol))
         False -> Ok(ParseData(exponent_digits, next_index, tokens))
@@ -79,7 +79,7 @@ pub fn parse_float_tokens(
         parse_data,
       )
 
-      let exponent_digit = exponent_digits |> digits_to_int
+      let exponent_digit = digits_to_int(exponent_digits)
       let exponent = case exponent_digit_is_positive {
         True -> exponent_digit
         False -> -exponent_digit
@@ -155,7 +155,7 @@ pub fn parse_int_tokens(
   )
 
   let parse_data =
-    parse_digits(tokens, next_index, base, prefix_data |> option.is_some)
+    parse_digits(tokens, next_index, base, option.is_some(prefix_data))
   use ParseData(digits, next_index, tokens) <- result.try(parse_data)
 
   let parse_data = parse_whitespace(tokens, next_index)
@@ -167,7 +167,7 @@ pub fn parse_int_tokens(
   }
   use _ <- result.try(remaining_token_result)
 
-  case leading_whitespace, prefix_data, digits |> deque.is_empty {
+  case leading_whitespace, prefix_data, deque.is_empty(digits) {
     None, None, True -> Error(EmptyString)
     _, Some(#(index_range, prefix)), True ->
       Error(BasePrefixOnly(index_range, prefix))
@@ -232,7 +232,7 @@ fn parse_base_prefix(
   case tokens {
     [Unknown(index, character), ..] -> Error(UnknownCharacter(index, character))
     [Digit(index, "0", _), ..rest] -> {
-      let lookahead = rest |> list.first
+      let lookahead = list.first(rest)
 
       case lookahead {
         Ok(Digit(_, specifier, _))
@@ -266,7 +266,7 @@ fn base_prefix_data(
   ParseData(
     data: Some(#(#(index, index + 2), "0" <> specifier, base)),
     next_index: index + 2,
-    tokens: tokens |> list.drop(1),
+    tokens: list.drop(tokens, 1),
   )
 }
 
@@ -327,7 +327,7 @@ fn parse_digits_loop(
     [Whitespace(index, data), ..] if at_beginning ->
       Error(UnknownCharacter(index, data.character))
     [Underscore(index), ..rest] -> {
-      let lookahead = rest |> list.first
+      let lookahead = list.first(rest)
       let at_end = case lookahead {
         Ok(Digit(_, _, _)) -> False
         _ -> True
@@ -364,7 +364,7 @@ fn parse_digits_loop(
         tokens: rest,
         index:,
         base:,
-        acc: acc |> deque.push_back(value),
+        acc: deque.push_back(acc, value),
         at_beginning: False,
         has_base_prefix:,
       )
diff --git a/src/lenient_parse/internal/pilkku/pilkku.gleam b/src/lenient_parse/internal/pilkku/pilkku.gleam
index d9aa241..fc63a46 100644
--- a/src/lenient_parse/internal/pilkku/pilkku.gleam
+++ b/src/lenient_parse/internal/pilkku/pilkku.gleam
@@ -181,7 +181,7 @@ fn decimal_to_float(sign: BigInt, num: BigInt, den: BigInt, exp: BigInt) {
     },
   )
 
-  let exp = bigi.add(exp, bigi.from_int(1023)) |> bigi.bitwise_shift_left(52)
+  let exp = exp |> bigi.add(bigi.from_int(1023)) |> bigi.bitwise_shift_left(52)
 
   use coef <- result.try(
     case
diff --git a/src/lenient_parse/internal/scale.gleam b/src/lenient_parse/internal/scale.gleam
index aa52e1b..5c926ff 100644
--- a/src/lenient_parse/internal/scale.gleam
+++ b/src/lenient_parse/internal/scale.gleam
@@ -12,7 +12,8 @@ pub fn deques(
     order.Eq -> #(whole_digits, fractional_digits)
     order.Gt -> {
       let #(digit, fractional_digits) =
-        deque.pop_front(fractional_digits)
+        fractional_digits
+        |> deque.pop_front
         |> result.unwrap(#(0, fractional_digits))
       deques(
         deque.push_back(whole_digits, digit),
@@ -22,7 +23,8 @@ pub fn deques(
     }
     order.Lt -> {
       let #(digit, whole_digits) =
-        deque.pop_back(whole_digits)
+        whole_digits
+        |> deque.pop_back
         |> result.unwrap(#(0, whole_digits))
       deques(
         whole_digits,
diff --git a/src/lenient_parse/internal/tokenizer.gleam b/src/lenient_parse/internal/tokenizer.gleam
index 464de94..b2b709b 100644
--- a/src/lenient_parse/internal/tokenizer.gleam
+++ b/src/lenient_parse/internal/tokenizer.gleam
@@ -29,7 +29,7 @@ fn tokenize_float_loop(
   acc acc: List(Token),
 ) -> List(Token) {
   case characters {
-    [] -> acc |> list.reverse
+    [] -> list.reverse(acc)
     [first, ..rest] -> {
       let token = case first {
         "." -> DecimalPoint(index)
@@ -74,7 +74,7 @@ fn tokenize_int_loop(
   acc acc: List(Token),
 ) -> List(Token) {
   case characters {
-    [] -> acc |> list.reverse
+    [] -> list.reverse(acc)
     [first, ..rest] -> {
       let token =
         common_token(
@@ -108,7 +108,7 @@ fn common_token(
     "+" -> Sign(index, "+", True)
     "_" -> Underscore(index)
     _ -> {
-      case whitespace_character_dict |> dict.get(character) {
+      case dict.get(whitespace_character_dict, character) {
         Ok(whitespace_data) -> Whitespace(index, data: whitespace_data)
         Error(_) -> {
           case character_to_value(character) {
diff --git a/test/build_test.gleam b/test/build_test.gleam
index 87fbf84..f9d2f57 100644
--- a/test/build_test.gleam
+++ b/test/build_test.gleam
@@ -67,12 +67,16 @@ pub fn build_float_explicit_0_whole_test() {
 // ------------------ int
 
 pub fn build_int_empty_test() {
-  build.integer_value(digits: deque.from_list([]), base: 10, is_positive: True)
+  []
+  |> deque.from_list
+  |> build.integer_value(base: 10, is_positive: True)
   |> expect.to_equal(Ok(0))
 }
 
 pub fn build_int_explicit_0_test() {
-  build.integer_value(digits: deque.from_list([0]), base: 10, is_positive: True)
+  [0]
+  |> deque.from_list()
+  |> build.integer_value(base: 10, is_positive: True)
   |> expect.to_equal(Ok(0))
 }
 
diff --git a/test/data.gleam b/test/data.gleam
index 6646b56..9d57710 100644
--- a/test/data.gleam
+++ b/test/data.gleam
@@ -7,12 +7,18 @@ import python/python_parse
 import test_data.{type FloatTestData, type IntegerTestData}
 
 pub fn float_test_data() -> List(FloatTestData) {
-  [valid_float_data.data(), invalid_float_data.data()]
+  [
+    valid_float_data.data(),
+    invalid_float_data.data(),
+  ]
   |> list.flatten
 }
 
 pub fn integer_test_data() -> List(IntegerTestData) {
-  [valid_integer_data.data(), invalid_integer_data.data()]
+  [
+    valid_integer_data.data(),
+    invalid_integer_data.data(),
+  ]
   |> list.flatten
 }
 
@@ -29,7 +35,7 @@ pub fn python_processed_float_data() {
     |> list.map(python_parse.to_floats)
     |> list.flatten
 
-  float_test_data |> list.zip(processed_values)
+  list.zip(float_test_data, processed_values)
 }
 
 pub fn python_processed_integer_data() {
@@ -41,5 +47,5 @@ pub fn python_processed_integer_data() {
     |> list.map(python_parse.to_ints)
     |> list.flatten
 
-  integer_test_data |> list.zip(processed_values)
+  list.zip(integer_test_data, processed_values)
 }
diff --git a/test/data/float/invalid_float_data.gleam b/test/data/float/invalid_float_data.gleam
index a1c5f3b..06324db 100644
--- a/test/data/float/invalid_float_data.gleam
+++ b/test/data/float/invalid_float_data.gleam
@@ -21,7 +21,7 @@ fn float_test_data(
   expected_program_output expected_program_output: Result(Float, ParseError),
   python_error_function python_error_function: fn(String) -> PythonError,
 ) -> FloatTestData {
-  let printable_text = input |> helpers.to_printable_text
+  let printable_text = helpers.to_printable_text(input)
 
   FloatTestData(
     input:,
diff --git a/test/data/integer/invalid_integer_data.gleam b/test/data/integer/invalid_integer_data.gleam
index 4f99702..ed9ec22 100644
--- a/test/data/integer/invalid_integer_data.gleam
+++ b/test/data/integer/invalid_integer_data.gleam
@@ -18,7 +18,7 @@ import test_data.{type IntegerTestData, IntegerTestData}
 fn invalid_literal_for_int_error(input: String, base: Int) -> PythonError {
   let message =
     "invalid literal for int() with base "
-    <> base |> int.to_string
+    <> int.to_string(base)
     <> ": '"
     <> input
     <> "'"
@@ -36,7 +36,7 @@ fn integer_test_data(
   expected_program_output expected_program_output: Result(Int, ParseError),
   python_error_function python_error_function: fn(String, Int) -> PythonError,
 ) -> IntegerTestData {
-  let printable_text = input |> helpers.to_printable_text
+  let printable_text = helpers.to_printable_text(input)
 
   IntegerTestData(
     input:,
diff --git a/test/helpers.gleam b/test/helpers.gleam
index d57e3c3..74360a0 100644
--- a/test/helpers.gleam
+++ b/test/helpers.gleam
@@ -11,7 +11,7 @@ import lenient_parse/parse_error.{
 
 pub fn to_printable_text(text: String) -> String {
   to_printable_text_loop(
-    characters: text |> string.to_graphemes,
+    characters: string.to_graphemes(text),
     whitespace_character_dict: whitespace.character_dict(),
     acc: "",
   )
@@ -28,7 +28,7 @@ fn to_printable_text_loop(
   case characters {
     [] -> acc
     [first, ..rest] -> {
-      let printable = case whitespace_character_dict |> dict.get(first) {
+      let printable = case dict.get(whitespace_character_dict, first) {
         Ok(whitespace_data) -> whitespace_data.printable
         Error(_) -> first
       }
@@ -47,43 +47,40 @@ pub fn error_to_string(error: ParseError) -> String {
     EmptyString -> "empty string"
     WhitespaceOnlyString -> "whitespace only string"
     InvalidUnderscorePosition(index) ->
-      "underscore at invalid position: " <> index |> int.to_string
+      "underscore at invalid position: " <> int.to_string(index)
     InvalidDecimalPosition(index) ->
-      "decimal at invalid position: " <> index |> int.to_string
+      "decimal at invalid position: " <> int.to_string(index)
     InvalidSignPosition(index, sign) ->
-      "sign \"" <> sign <> "\" at invalid position: " <> index |> int.to_string
+      "sign \"" <> sign <> "\" at invalid position: " <> int.to_string(index)
     InvalidDigitPosition(index, digit) ->
-      "digit \""
-      <> digit
-      <> "\" at invalid position: "
-      <> index |> int.to_string
+      "digit \"" <> digit <> "\" at invalid position: " <> int.to_string(index)
     BasePrefixOnly(#(start_index, end_index), prefix) ->
       "inferred base prefix only: "
       <> prefix
       <> " at index range: "
-      <> start_index |> int.to_string
+      <> int.to_string(start_index)
       <> ".."
-      <> end_index |> int.to_string
+      <> int.to_string(end_index)
     OutOfBaseRange(index, character, value, base) ->
       "digit character \""
       <> character
       <> "\" ("
-      <> value |> int.to_string
+      <> int.to_string(value)
       <> ") at position "
-      <> index |> int.to_string
+      <> int.to_string(value)
       <> " is out of range for base: "
-      <> base |> int.to_string
+      <> int.to_string(base)
     InvalidExponentSymbolPosition(index, exponent_symbol) ->
       "exponent symbol \""
       <> exponent_symbol
       <> "\" at invalid position: "
-      <> index |> int.to_string
+      <> int.to_string(index)
     UnknownCharacter(index, character) ->
       "unknown character \""
       <> character
       <> "\" at index: "
-      <> index |> int.to_string
-    InvalidBaseValue(base) -> "invalid base value: " <> base |> int.to_string
+      <> int.to_string(index)
+    InvalidBaseValue(base) -> "invalid base value: " <> int.to_string(base)
     OutOfIntRange(integer_string) ->
       "integer value \""
       <> integer_string
diff --git a/test/javascript_constants.gleam b/test/javascript_constants.gleam
index 6cc7709..b90d8d6 100644
--- a/test/javascript_constants.gleam
+++ b/test/javascript_constants.gleam
@@ -7,7 +7,7 @@ pub fn min_safe_integer() -> Int {
 }
 
 pub fn min_safe_integer_string() -> String {
-  min_safe_integer() |> int.to_string
+  int.to_string(min_safe_integer())
 }
 
 pub fn min_safe_integer_minus_1() -> Int {
@@ -15,7 +15,7 @@ pub fn min_safe_integer_minus_1() -> Int {
 }
 
 pub fn min_safe_integer_minus_1_string() -> String {
-  min_safe_integer_minus_1() |> int.to_string
+  int.to_string(min_safe_integer_minus_1())
 }
 
 pub fn max_safe_integer() -> Int {
@@ -23,7 +23,7 @@ pub fn max_safe_integer() -> Int {
 }
 
 pub fn max_safe_integer_string() -> String {
-  max_safe_integer() |> int.to_string
+  int.to_string(max_safe_integer())
 }
 
 pub fn max_safe_integer_plus_1() -> Int {
@@ -31,5 +31,5 @@ pub fn max_safe_integer_plus_1() -> Int {
 }
 
 pub fn max_safe_integer_plus_1_string() -> String {
-  max_safe_integer_plus_1() |> int.to_string
+  int.to_string(max_safe_integer_plus_1())
 }
diff --git a/test/python_parse_test.gleam b/test/python_parse_test.gleam
index 7dd52a5..20b6f75 100644
--- a/test/python_parse_test.gleam
+++ b/test/python_parse_test.gleam
@@ -17,7 +17,7 @@ pub fn check_against_python_tests() {
           let expected_python_output = { data.0 }.expected_python_output
           let actual_python_output = data.1
 
-          let input_printable_text = input |> helpers.to_printable_text
+          let input_printable_text = helpers.to_printable_text(input)
 
           let message = case expected_program_output, expected_python_output {
             Ok(_), Ok(python_output) -> {
@@ -37,14 +37,14 @@ pub fn check_against_python_tests() {
             Ok(output), Error(python_error) -> {
               panic as form_panic_message(
                   input_printable_text,
-                  output |> float.to_string,
+                  float.to_string(output),
                   python_error.message,
                 )
             }
             Error(output), Ok(python_output) -> {
               panic as form_panic_message(
                   input_printable_text,
-                  output |> helpers.error_to_string,
+                  helpers.error_to_string(output),
                   python_output,
                 )
             }
@@ -52,8 +52,7 @@ pub fn check_against_python_tests() {
 
           use <- it(message)
 
-          expected_python_output
-          |> expect.to_equal(actual_python_output)
+          expect.to_equal(expected_python_output, actual_python_output)
         }),
     ),
     describe(
@@ -66,11 +65,11 @@ pub fn check_against_python_tests() {
           let expected_python_output = { data.0 }.expected_python_output
           let actual_python_output = data.1
 
-          let input_printable_text = input |> helpers.to_printable_text
+          let input_printable_text = helpers.to_printable_text(input)
 
           let base_text = case base {
             10 -> ""
-            _ -> "(base: " <> base |> int.to_string <> ") "
+            _ -> "(base: " <> int.to_string(base) <> ") "
           }
 
           let message = case expected_program_output, expected_python_output {
@@ -95,14 +94,14 @@ pub fn check_against_python_tests() {
             Ok(output), Error(python_error) -> {
               panic as form_panic_message(
                   input_printable_text,
-                  output |> int.to_string,
+                  int.to_string(output),
                   python_error.message,
                 )
             }
             Error(output), Ok(python_output) -> {
               panic as form_panic_message(
                   input_printable_text,
-                  output |> helpers.error_to_string,
+                  helpers.error_to_string(output),
                   python_output,
                 )
             }
@@ -110,8 +109,7 @@ pub fn check_against_python_tests() {
 
           use <- it(message)
 
-          expected_python_output
-          |> expect.to_equal(actual_python_output)
+          expect.to_equal(expected_python_output, actual_python_output)
         }),
     ),
   ])
diff --git a/test/to_float_parse_test.gleam b/test/to_float_parse_test.gleam
index 0ff83fb..d398288 100644
--- a/test/to_float_parse_test.gleam
+++ b/test/to_float_parse_test.gleam
@@ -12,7 +12,7 @@ pub fn to_float_tests() {
     data.float_test_data()
       |> list.map(fn(data) {
         let input = data.input
-        let input_printable_text = input |> helpers.to_printable_text
+        let input_printable_text = helpers.to_printable_text(input)
         let expected_program_output = data.expected_program_output
 
         let message = case expected_program_output {
@@ -20,10 +20,10 @@ pub fn to_float_tests() {
             "should_parse: \""
             <> input_printable_text
             <> "\" -> "
-            <> output |> float.to_string
+            <> float.to_string(output)
           }
           Error(error) -> {
-            let error_string = error |> helpers.error_to_string
+            let error_string = helpers.error_to_string(error)
             "should_not_parse: \""
             <> input_printable_text
             <> "\" -> \""
diff --git a/test/to_int_parse_test.gleam b/test/to_int_parse_test.gleam
index b627a15..9f41e37 100644
--- a/test/to_int_parse_test.gleam
+++ b/test/to_int_parse_test.gleam
@@ -12,13 +12,13 @@ pub fn to_int_tests() {
     data.integer_test_data()
       |> list.map(fn(data) {
         let input = data.input
-        let input_printable_text = input |> helpers.to_printable_text
+        let input_printable_text = helpers.to_printable_text(input)
         let expected_program_output = data.expected_program_output
         let base = data.base
 
         let base_text = case base {
           10 -> ""
-          _ -> "(base: " <> base |> int.to_string <> ") "
+          _ -> "(base: " <> int.to_string(base) <> ") "
         }
 
         let message = case expected_program_output {
@@ -28,10 +28,10 @@ pub fn to_int_tests() {
             <> "\" "
             <> base_text
             <> "-> "
-            <> output |> int.to_string
+            <> int.to_string(output)
           }
           Error(error) -> {
-            let error_string = error |> helpers.error_to_string
+            let error_string = helpers.error_to_string(error)
             "should_not_parse: \""
             <> input_printable_text
             <> "\" -> "
diff --git a/test/tokenizer_test.gleam b/test/tokenizer_test.gleam
index ad28bd0..138508d 100644
--- a/test/tokenizer_test.gleam
+++ b/test/tokenizer_test.gleam
@@ -117,7 +117,7 @@ pub fn tokenize_int_test() {
 }
 
 pub fn tokenize_int_with_all_whitespace_characters_test() {
-  let whitespace_character_strings = whitespace.character_dict() |> dict.to_list
+  let whitespace_character_strings = dict.to_list(whitespace.character_dict())
 
   let expected_tokens =
     whitespace_character_strings
@@ -125,7 +125,7 @@ pub fn tokenize_int_with_all_whitespace_characters_test() {
       Whitespace(index, data: whitespace_data.1)
     })
 
-  let whitespace_character_strings = whitespace.character_dict() |> dict.keys()
+  let whitespace_character_strings = dict.keys(whitespace.character_dict())
 
   whitespace_character_strings
   |> string.join("")