Clean up overuse of pipes

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))
         }
       }

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:,
       )

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

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,

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) {

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))
 }
 

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)
 }

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:,

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:,

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

test/javascript_constants.gleam

@@ -7,29 +7,29 @@ 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 {
   min_safe_integer() - 1
 }
 
 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 {
   safe_integer
 }
 
 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 {
   safe_integer + 1
 }
 
 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())
 }