Struct TagsRequest 

pub struct TagsRequest<'a> { /* private fields */ }

A builder for the tag-listing endpoints — the whole-vocabulary pair Client::tags (fred/tags) / Client::related_tags (fred/related_tags), and the scoped variants that list the tags of one category, release, or series search: Client::category_tags, Client::category_related_tags, Client::release_tags, Client::release_related_tags, Client::series_search_tags, and Client::series_search_related_tags.

All share optional tag-filter text, sort, and paging and return TagsResults. Each *_related_tags variant additionally carries a seed tag_names set (the tags to find co-occurring tags for); each scoped variant carries its scope facet (category_id / release_id / series_search_text). Finish with send.

let results = client.tags().search_text("gdp").limit(10).send().await?;
for tag in &results.tags {
    println!("{} ({} series)", tag.name, tag.series_count);
}

Implementations

impl<'a> TagsRequest<'a>

pub fn search_text(self, text: impl Into<String>) -> Self

Restrict to tags matching these words (search_text, or tag_search_text for the series/search/* endpoints).

pub fn sort_order(self, order: SortOrder) -> Self

Sort order of the results (sort_order); tags are ordered by series count by default.

pub fn limit(self, limit: u32) -> Self

Maximum number of results to return, 1..=1000 (limit).

pub fn offset(self, offset: u32) -> Self

Number of results to skip from the start (offset), for paging.

pub async fn send(self) -> Result<TagsResults>

Run the request and return a page of tags with pagination metadata.

Errors

Returns an error if the request fails to send, FRED returns a non-success status, or the response body cannot be deserialized.

Trait Implementations

impl<'a> Clone for TagsRequest<'a>

fn clone(&self) -> TagsRequest<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for TagsRequest<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Paginate for TagsRequest<'_>

const MAX_PAGE: u32 = 1000

FRED’s maximum page size for this endpoint — the largest limit it honors. 1000 for most lists; 10000 for release dates and vintage dates.

type Page = TagsResults

The page type this request returns.

fn requested_limit(&self) -> Option<u32>

The caller’s requested limit, if set. send_all treats it as a ceiling on the total number of items returned.

fn requested_offset(&self) -> Option<u32>

The caller’s requested offset, if set — the point send_all starts paging from.

fn with_paging(self, limit: u32, offset: u32) -> Self

Return a copy of this request with limit and offset set.

fn send_page(self) -> impl Future<Output = Result<Self::Page>> + Send

Send a single page — equivalent to the builder’s own send.

fn send_all( self, ) -> impl Future<Output = Result<Vec<<Self::Page as Page>::Item>>> + Send

Fetch every result across all pages, in order.

fn stream(self) -> impl Stream<Item = Result<<Self::Page as Page>::Item>> + Send

Stream every result across all pages, lazily — items are yielded as they arrive, and the next page is fetched only once the current one is drained.