Create list benchmarks

Makefile

···
 export-hex-tarball-test: ## Run `gleam export hex-tarball` and verify it is created
 	cd test/hextarball && make test
 
+.PHONY: benchmark
+benchmark: ## Run the benchmarks
+	cd benchmark/list && make
+
 # Debug print vars with `make print-VAR_NAME`
 print-%: ; @echo $*=$($*)

benchmark/list/.gitignore

···
+*.beam
+*.ez
+/build
+erl_crash.dump

benchmark/list/Makefile

···
+.PHONY: build
+build: clean erlang nodejs deno bun
+
+.PHONY: clean
+clean:
+	rm -rf build
+
+.PHONY: erlang
+erlang:
+	@echo test/language on Erlang
+	cargo run --quiet -- test --target erlang
+
+.PHONY: nodejs
+nodejs:
+	@echo test/language on JavaScript with Node
+	cargo run --quiet -- test --target javascript --runtime nodejs
+
+.PHONY: deno
+deno:
+	@echo test/language on JavaScript with Deno
+	cargo run --quiet -- test --target javascript --runtime deno
+
+.PHONY: bun
+bun:
+	@echo test/language on JavaScript with Bun
+	cargo run --quiet -- test --target javascript --runtime bun

benchmark/list/gleam.toml

···
+name = "list"
+version = "1.0.0"
+description = "Benchmarks for lists"
+licenses = ["Apache-2.0"]
+
+[dependencies]
+gleam_stdlib = "~> 0.28"
+gleamy_bench = ">= 0.6.0 and < 1.0.0"

benchmark/list/manifest.toml

···
+# This file was generated by Gleam
+# You typically do not need to edit this file
+
+packages = [
+  { name = "gleam_stdlib", version = "0.59.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "F8FEE9B35797301994B81AF75508CF87C328FE1585558B0FFD188DC2B32EAA95" },
+  { name = "gleamy_bench", version = "0.6.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleamy_bench", source = "hex", outer_checksum = "DEF68E4B097A56781282F0F9D48371A0ABBCDDCF89CAD05B28C3BEDD6B2E8DF3" },
+]
+
+[requirements]
+gleam_stdlib = { version = "~> 0.28" }
+gleamy_bench = { version = ">= 0.6.0 and < 1.0.0" }

benchmark/list/src/list.gleam

···
+pub fn main() {
+  Nil
+}

benchmark/list/test/benchmarks.gleam

···
+import gleamy/bench
+
+import gleam/io
+import gleam/list
+
+pub fn print_results(results: List(bench.BenchResults)) {
+  results
+  |> list.map(fn(result) {
+    result
+    |> bench.table([bench.IPS, bench.Min, bench.P(99)])
+    |> io.println()
+  })
+}

benchmark/list/test/list_test.gleam

···
+import benchmarks.{print_results}
+import gleam/list
+import gleamy/bench
+
+pub fn main() {
+  print_results([bench_odd_nums_between(), bench_count_ones(), bench_slice()])
+}
+
+fn bench_odd_nums_between() -> bench.BenchResults {
+  let odd_nums_between = fn(args) {
+    let #(start, end) = args
+    odd_nums_between(start, end, [])
+  }
+
+  bench.run(
+    [
+      bench.Input("[0, 100)", #(0, 100)),
+      bench.Input("[0, 1000)", #(0, 1000)),
+      bench.Input("[0, 10_000)", #(0, 10_000)),
+      bench.Input("[0, 100_000)", #(0, 100_000)),
+      bench.Input("[0, 1_000_000)", #(0, 1_000_000)),
+    ],
+    [bench.Function("odd_nums_between", odd_nums_between)],
+    [bench.Duration(1000), bench.Warmup(100)],
+  )
+}
+
+/// Returns a list of numbers from `start` up to, but not including, `end`.
+fn odd_nums_between(start: Int, end: Int, acc: List(Int)) -> List(Int) {
+  case start {
+    start if start >= end -> list.reverse(acc)
+    _ -> {
+      let acc = case start {
+        n if n % 2 == 1 -> [n, ..acc]
+        _ -> acc
+      }
+      odd_nums_between(start + 1, end, acc)
+    }
+  }
+}
+
+fn bench_count_ones() -> bench.BenchResults {
+  let create_list = fn(size) {
+    list.range(0, size)
+    |> list.map(fn(n) {
+      case n {
+        _ if n % 3 == 0 -> 1
+        _ -> 0
+      }
+    })
+  }
+
+  let count_ones = fn(list) { count_ones(list, 0) }
+
+  bench.run(
+    [
+      bench.Input("100 numbers", create_list(100)),
+      bench.Input("1000 numbers", create_list(1000)),
+      bench.Input("10_000 numbers", create_list(10_000)),
+      bench.Input("100_000 numbers", create_list(100_000)),
+      bench.Input("1_000_000 numbers", create_list(1_000_000)),
+    ],
+    [bench.Function("count_ones", count_ones)],
+    [bench.Duration(1000), bench.Warmup(100)],
+  )
+}
+
+/// Counts the number of ones in a list.
+fn count_ones(list: List(Int), count: Int) -> Int {
+  case list {
+    [] -> count
+    [1, ..tail] -> count_ones(tail, count + 1)
+    [_, ..tail] -> count_ones(tail, count)
+  }
+}
+
+fn bench_slice() -> bench.BenchResults {
+  let list = list.range(0, 1_000_000)
+
+  let slice = fn(args) {
+    let #(list, start, end) = args
+    slice(list, start, end, [])
+  }
+
+  bench.run(
+    [
+      bench.Input("[0, 1000)", #(list, 0, 1000)),
+      bench.Input("[0, 10_000)", #(list, 0, 10_000)),
+      bench.Input("[0, 100_000)", #(list, 0, 100_000)),
+      bench.Input("[999_000, 1_000_000)", #(list, 999_000, 1_000_000)),
+      bench.Input("[990_000, 1_000_000)", #(list, 990_000, 1_000_000)),
+      bench.Input("[900_000, 1_000_000)", #(list, 900_000, 1_000_000)),
+      bench.Input("[0, 1_000_000)", #(list, 0, 1_000_000)),
+    ],
+    [bench.Function("slice", slice)],
+    [bench.Duration(1000), bench.Warmup(100)],
+  )
+}
+
+/// Slices a list.
+fn slice(list: List(Int), start: Int, end: Int, acc: List(Int)) -> List(Int) {
+  case list {
+    // If the first element is before the slice, skip it.
+    [_, ..tail] if start > 0 -> {
+      slice(tail, start - 1, end - 1, acc)
+    }
+    // If the first element is within the slice, add it to the accumulator.
+    [head, ..tail] if end > 0 -> {
+      slice(tail, start - 1, end - 1, [head, ..acc])
+    }
+    // Otherwise, return the accumulator.
+    _ -> list.reverse(acc)
+  }
+}