anchor.diff:     , constraints => Constraints
      }.
   
  +%% @doc Gets the `path_match` from the given `trail` map.
   -spec path_match(map()) -> string() | binary().
   path_match(Trail) ->
    maps:get(path_match, Trail, []).
   
  +%% @doc Gets the `handler` from the given `trail` map.
   -spec handler(map()) -> module().
   handler(Trail) ->
    maps:get(handler, Trail, []).
   
  +%% @doc Gets the `options` from the given `trail` map.
    -spec options(map()) -> list().
   options(Trail) ->
    maps:get(options, Trail, []).
   
  +%% @doc Gets the `metadata` from the given `trail` map.
    -spec metadata(map()) -> map().
   metadata(Trail) ->
    maps:get(metadata, Trail, []).
   
  +%% @doc Gets the `constraints` from the given `trail` map.
    -spec constraints(map()) -> list().
   constraints(Trail) ->
    maps:get(constraints, Trail, []).
   
  +%% @doc This function enables to define the routes on each resource handler,
  +%%      instead of define them all in one place (as usually with `cowboy`).
  +%%      Your handler must implement the callback `trails/0` and return the
  +%%      specific routes for that handler. That callback is invoked for each
  +%%      given module and then concatenates the results.
   -spec trails(module() | [module()]) -> cowboy_router:routes().
   trails(Handlers) when is_list(Handlers) ->
     trails(Handlers, []);
   trails(Handler) ->
     trails([Handler], []).
   
  +%% @doc Store the given list of trails in order that they can be retrieved
  +%%      by any other handler/process.
   -spec store([trail()]) -> ok.
   store(Trails) ->
     application:ensure_all_started(trails),
     NormalizedPaths = normalize_store_input(Trails),
     store1(NormalizedPaths).
   
  +%% @doc Retrieves all stored set of trails.
   -spec all() -> [trail()].
   all() ->
     case application:get_application(trails) of
  
positive.code: -type metadata() :: #{method() => map()}.
  -export_type([metadata/0]).
  
  -spec single_host_compile([route_path()]) ->
    cowboy_router:dispatch_rules().
  single_host_compile(Trails) ->
    compile([{'_', Trails}]).
  
  -spec compile([{Host::route_match(), Trails::trails()}]) ->
    cowboy_router:dispatch_rules().
  compile([]) -> [];
  
negative.code: -export([constraints/1]).
  -export([store/1, all/0, retrieve/1]).
  
  %% Trail specification
  -opaque trail() ::
    #{ path_match  => cowboy_router:route_match()
     , constraints => cowboy_router:constraints()
  