Start gleam application, using modem for URI management, and pulling query params from url

app.gleam

import app/init.{init}
import app/models.{Coordinates, QueryParams}
import app/update.{update}
import app/view.{view}
import gleam/dict
import gleam/float
import gleam/int
import gleam/option.{None, Some}
import gleam/uri
import lustre
import modem

pub fn main() {
  let app = lustre.application(init, update, view)

  // defaults can be overridden via url query string params
  let default_params = [#("lat", "40.0"), #("lng", "-100.0"), #("zoom", "5")]
  let default_map = dict.from_list(default_params)

  let query_params = case modem.initial_uri() {
    Ok(uri) -> {
      case uri.query {
        Some(query_string) -> {
          case uri.parse_query(query_string) {
            Ok(params) -> {
              let params_map = dict.from_list(params)
              let merged_map = dict.merge(default_map, params_map)
              Some(QueryParams(
                Coordinates(
                  get_float(merged_map, "lat", 40.0),
                  get_float(merged_map, "lng", -100.0),
                ),
                get_int(merged_map, "zoom", 5),
              ))
            }
            Error(_) -> None
          }
        }
        None -> None
      }
    }
    Error(_) -> None
  }

  case query_params {
    None -> {
      let def_qp =
        QueryParams(
          Coordinates(
            get_float(default_map, "lat", 40.0),
            get_float(default_map, "lng", -100.0),
          ),
          get_int(default_map, "zoom", 5),
        )
      let assert Ok(_) = lustre.start(app, "#app", def_qp)
    }
    Some(qp) -> {
      let assert Ok(_) = lustre.start(app, "#app", qp)
    }
  }
}

fn get_float(d: dict.Dict(String, String), key: String, default: Float) -> Float {
  case dict.get(d, key) {
    Ok(v) -> {
      case float.parse(v) {
        Ok(r) -> r
        Error(_) -> default
      }
    }
    Error(_) -> default
  }
}

fn get_int(d: dict.Dict(String, String), key: String, default: Int) -> Int {
  case dict.get(d, key) {
    Ok(v) -> {
      case int.parse(v) {
        Ok(r) -> r
        Error(_) -> default
      }
    }
    Error(_) -> default
  }
}