🧹 Remove redundant build() function

CHANGELOG.md

···
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
+## [Unreleased]
+
+### Changed
+
+- Removed the need for `glimit.build()` and `glimit.try_build()` functions. Now, the `glimit.apply()` function can be used directly with the limiter configuration.
+
+
 ## 0.2.0 - 2024-09-07
 
 ### Breaking changes
···
 - Added a `burst_limit` setting to the limiter configuration. This setting allows the user to set the maximum number of tokens that the bucket can hold.
 
 
-## v0.1.3 - 2024-09-04
+## 0.1.3 - 2024-09-04
 
 ### Added
 

README.md

···
   |> glimit.per_second(2)
   |> glimit.identifier(fn(x) { x })
   |> glimit.on_limit_exceeded(fn(_) { "Stop!" })
-  |> glimit.build
 
 let func =
   fn(_) { "OK" }

examples/mist/src/app.gleam

···
     |> glimit.burst_limit(5)
     |> glimit.identifier(get_ip_address)
     |> glimit.on_limit_exceeded(rate_limit_reached)
-    |> glimit.build
 
   let assert Ok(_) =
     handle_request

examples/wisp/src/app.gleam

···
       let body = string_builder.from_string("<h1>Too many requests</h1>")
       wisp.html_response(body, 429)
     })
-    |> glimit.build
 
   wisp.configure_logger()
 

src/glimit.gleam

···
 ////   |> glimit.burst_limit(100)
 ////   |> glimit.identifier(fn(request) { request.ip })
 ////   |> glimit.on_limit_exceeded(fn(_request) { "Rate limit reached" })
-////   |> glimit.build()
 ////
 //// let handler =
 ////   fn(_request) { "Hello, world!" }
···
 
 /// Build the rate limiter.
 ///
-/// Panics if the rate limiter registry cannot be started or if the `identifier`
-/// function or `on_limit_exceeded` function is missing.
+/// Note that using `apply` will already build the rate limiter, so this function is
+/// only useful if you want to build the rate limiter manually and apply it to multiple
+/// functions.
 ///
-/// To handle errors instead of panicking, use `try_build`.
+/// To apply the resulting rate limiter to a function or handler, use the `apply_built`
+/// function.
 ///
-pub fn build(config: RateLimiterBuilder(a, b, id)) -> RateLimiter(a, b, id) {
-  case try_build(config) {
-    Ok(limiter) -> limiter
-    Error(message) -> panic as message
-  }
-}
-
-/// Build the rate limiter, but return an error instead of panicking.
-///
-pub fn try_build(
+pub fn build(
   config: RateLimiterBuilder(a, b, id),
 ) -> Result(RateLimiter(a, b, id), String) {
   use per_second <- result.try(case config.per_second {
···
 
 /// Apply the rate limiter to a request handler or function.
 ///
-pub fn apply(func: fn(a) -> b, limiter: RateLimiter(a, b, id)) -> fn(a) -> b {
+/// Panics if the rate limiter registry cannot be started or if the `identifier`
+/// function or `on_limit_exceeded` function is missing.
+///
+pub fn apply(
+  func: fn(a) -> b,
+  config: RateLimiterBuilder(a, b, id),
+) -> fn(a) -> b {
+  let limiter = case build(config) {
+    Ok(limiter) -> limiter
+    Error(message) -> panic as message
+  }
+  apply_built(func, limiter)
+}
+
+/// Apply the rate limiter to a request handler or function.
+///
+/// This function is useful if you want to build the rate limiter manually using the
+/// `build` function.
+///
+pub fn apply_built(
+  func: fn(a) -> b,
+  limiter: RateLimiter(a, b, id),
+) -> fn(a) -> b {
   fn(input: a) -> b {
     let identifier = limiter.identifier(input)
     case limiter.rate_limiter_registry |> registry.get_or_create(identifier) {

test/glimit_test.gleam

···
     |> glimit.per_second(2)
     |> glimit.identifier(fn(_) { "id" })
     |> glimit.on_limit_exceeded(fn(_) { "Stop!" })
-    |> glimit.build
 
   let func =
     fn(_) { "OK" }
···
     |> glimit.per_second(2)
     |> glimit.identifier(fn(x) { x })
     |> glimit.on_limit_exceeded(fn(_) { "Stop!" })
-    |> glimit.build
 
   let func =
     fn(_) { "OK" }
···
 }
 
 pub fn burst_limit_test() {
-  let limiter =
+  let assert Ok(limiter) =
     glimit.new()
     |> glimit.per_second(1)
     |> glimit.burst_limit(3)
···
 
   let func =
     fn(_) { "OK" }
-    |> glimit.apply(limiter)
+    |> glimit.apply_built(limiter)
 
   let assert Ok(rate_limiter) =
     limiter.rate_limiter_registry