♻️ Implement pipe function

eslint.config.js

@@ -45,7 +45,7 @@ export default [
             "id-length": [
                 "error",
                 {
-                    exceptions: ["λ", "_", "$", "c", "r", "U"],
+                    exceptions: ["λ", "_", "$", "c", "l", "r", "U"],
                 },
             ],
             "no-restricted-syntax": [

src/04/index.ts

@@ -13,7 +13,7 @@ const solve = (
 /* --------------------------------- part01 --------------------------------- */
 
 export const part01 = (input: string): number =>
-    solve(U.grid(input), (cell, position, grid) =>
+    solve(U.grid(input, ""), (cell, position, grid) =>
         cell === "X" ?
             U.count(
                 [U.east, U.southEast],
@@ -30,7 +30,7 @@ export const part01 = (input: string): number =>
 /* --------------------------------- part02 --------------------------------- */
 
 export const part02 = (input: string): number =>
-    solve(U.grid(input), (cell, position, grid) =>
+    solve(U.grid(input, ""), (cell, position, grid) =>
         cell === "A" ?
             Number(
                 [

src/06/index.ts

@@ -10,7 +10,7 @@ const parse = (
     guard: { facing: string; position: U.Position }
     obstacles: Set<string>
 } => {
-    const grid = U.map2D(U.grid(input), (cell, position) => ({
+    const grid = U.map2D(U.grid(input, ""), (cell, position) => ({
         cell,
         position,
     }))

src/08/index.ts

@@ -3,7 +3,7 @@ import * as U from "@/utils"
 const parse = (
     input: string,
 ): { antennas: Record<string, Set<string>>; grid: string[][] } => {
-    const grid = U.grid(input)
+    const grid = U.grid(input, "")
     const positions = U.map2D(grid, U.index)
 
     return {

src/10/index.ts

@@ -1,6 +1,6 @@
 import * as U from "@/utils"
 
-const parse = (input: string): number[][] => U.map2D(U.grid(input), Number)
+const parse = (input: string): number[][] => U.map2D(U.grid(input, ""), Number)
 
 const getStarts = (grid: number[][]): U.Position[] =>
     U.map2D(grid, U.index)

src/12/index.ts

@@ -1,6 +1,6 @@
 import * as U from "@/utils"
 
-const parse = (input: string): string[][] => U.grid(input)
+const parse = (input: string): string[][] => U.grid(input, "")
 
 const getPositionHash = (position: U.Position): string =>
     U.join([U.r(position), U.c(position)], "_")

src/utils.ts

@@ -1,6 +1,11 @@
 export type Flip<T extends unknown[]> =
     T extends [infer U, ...infer V] ? [...Flip<V>, U] : []
 
+export type Pipe<T extends unknown[]> = {
+    l: <U>(function_: (...arguments_: T) => U) => Pipe<[U]>
+    return: () => T[0]
+}
+
 export type Position = Record<"c" | "r", number>
 
 /* -------------------------------------------------------------------------- */
@@ -136,10 +141,8 @@ export const flatMap = <T, U>(
 export const fromEntries = <T>(entries: [string, T][]): Record<string, T> =>
     Object.fromEntries(entries)
 
-export const grid = (
-    string: string,
-    separator: RegExp | string = "",
-): string[][] => map(lines(string), λ(_(split), separator))
+export const grid = (string: string, separator: RegExp | string): string[][] =>
+    map(lines(string), λ(_(split), separator))
 
 export const guard = <T>(value: T): NonNullable<T> =>
     isDefined(value) ? value : panic(`${String(value)} did not pass guard!`)
@@ -211,6 +214,11 @@ export const int = (value: unknown): number => Number(value) // eslint-disable-l
 export const join = (array: (number | string)[], separator = ""): string =>
     array.join(separator)
 
+export const l = <T extends unknown[]>(...arguments_: T): Pipe<T> => ({
+    l: (function_) => l(function_(...arguments_)),
+    return: () => arguments_[0], // eslint-disable-line functional/functional-parameters
+})
+
 export const last = <T>(array: T[]): T => at(array, -1)
 
 export const lastIndexOf = (string: string, value: string): number =>