rust-meth 0.1.6

Discover methods available on any Rust type with fuzzy filtering, inline documentation, interactive selection, and go-to-definition into standard library source code.
rust-meth-0.1.6 is not a library.

rust-meth

Crates.io Nix Flake Documentation License

Discover the methods available on any Rust type — with fuzzy filtering, inline docs, interactive selection, and go-to-definition into the standard library source. Powered by rust-analyzer.

Think of it as "method completion for any Rust type, anywhere in your terminal."

[!IMPORTANT]

  • Standard Toolchain: Fully supported (std, core, and alloc).
  • External Crates: Supported via the --deps flag (see 3rd party crates).

Highlights

  • Inspect any type's methods and full signatures
  • Fuzzy-filter results with partial or typo-ridden input
  • Show doc comments inline with --doc
  • Browse methods interactively with -i
  • Jump to the stdlib source of any method with --gd
  • Open that definition directly in your $EDITOR with --open
  • Open official documentation directly in your browser with --open-doc
  • Query 3rd party crate types with --deps

Why it's useful

Rust already gives you editor-side go-to-definition, but that only works inside an open project. rust-meth works anywhere — no project, no editor, no LSP session. Stay in the terminal while you discover methods, read signatures, and jump into the stdlib source. Because it uses rust-analyzer under the hood, the output reflects your actual installed toolchain: trait methods, blanket impls, deprecated methods, and nightly-only APIs. Not a static list.

Table of Contents

Requirements

  • A Rust toolchain (stable or nightly)
  • rust-analyzer on your PATH:
rustup component add rust-analyzer
  • rust-src (Rust standard library source code):
rustup component add rust-src

[!NOTE] While rust-analyzer will typically attempt to install the standard library source automatically, installing it manually ensures it is present.

Installation

cargo install rust-meth

Usage

First run may take a few seconds while rust-analyzer indexes the toolchain.

$ rust-meth <type> [filter | -i]

$ rust-meth u8 wrapping
Waiting for rust-analyzer to index… (this may take a moment on first run)
(attempt 1: not ready, retrying…)
rust-meth: methods on `u8` matching "wrapping"
  wrapping_add                const fn(self, u8) -> u8
  wrapping_add_signed         const fn(self, i8) -> u8
  wrapping_div                const fn(self, u8) -> u8
  wrapping_div_euclid         const fn(self, u8) -> u8
  wrapping_mul                const fn(self, u8) -> u8
  wrapping_neg                const fn(self) -> u8
  wrapping_next_power_of_two  const fn(self) -> u8
  wrapping_pow                const fn(self, u32) -> u8
  wrapping_rem                const fn(self, u8) -> u8
  wrapping_rem_euclid         const fn(self, u8) -> u8
  wrapping_shl                const fn(self, u32) -> u8
  wrapping_shr                const fn(self, u32) -> u8
  wrapping_sub                const fn(self, u8) -> u8
  wrapping_sub_signed         const fn(self, i8) -> u8
14 method(s)

More examples:

rust-meth '&str'
rust-meth String
rust-meth f64
rust-meth 'Vec<u8>'
rust-meth 'Option<u8>'
rust-meth 'HashMap<String, u32>'
rust-meth 'Option<Result<Vec<u8>, std::io::Error>>'

Fuzzy filter

The filter argument uses fuzzy matching, so typos and partials work:

$ rust-meth u8 wrapng       # finds all wrapping_* methods

$ rust-meth '&str' splt
Waiting for rust-analyzer to index… (this may take a moment on first run)
rust-meth: methods on `&str` matching "splt"
  split_terminator        fn(&self, P) -> SplitTerminator<'_, P>
  split                   fn(&self, P) -> Split<'_, P>
  split_ascii_whitespace  fn(&self) -> SplitAsciiWhitespace<'_>
  split_at                const fn(&self, usize) -> (&str, &str)
  split_at_checked        const fn(&self, usize) -> Option<(&str, &str)>
  split_at_mut            const fn(&mut self, usize) -> (&mut str, &mut str)
  split_at_mut_checked    const fn(&mut self, usize) -> Option<(&mut str, &mut str)>
  split_inclusive         fn(&self, P) -> SplitInclusive<'_, P>
  split_once              fn(&self, P) -> Option<(&str, &str)>
  split_whitespace        fn(&self) -> SplitWhitespace<'_>
  splitn                  fn(&self, usize, P) -> SplitN<'_, P>
  rsplit_terminator       fn(&self, P) -> RSplitTerminator<'_, P>
  rsplit                  fn(&self, P) -> RSplit<'_, P>
  rsplit_once             fn(&self, P) -> Option<(&str, &str)>
  rsplitn                 fn(&self, usize, P) -> RSplitN<'_, P>
  escape_default          fn(&self) -> EscapeDefault<'_>
16 method(s)

Results are sorted by match quality, best first.

Inline documentation

Pass --doc / -d to print the doc comment below each method signature:

$ rust-meth u8 strict_shr --doc
rust-meth: methods on `u8` matching "strict_shr"
  strict_shr  const fn(self, u32) -> u8
    Strict shift right. Computes `self >> rhs`, panicking if `rhs` is
    larger than or equal to the number of bits in `self`.
    # Panics
    ## Overflow behavior
1 method(s)

Works best combined with a filter:

$ rust-meth '&str' split_once --doc
$ rust-meth 'HashMap<String, u32>' entry --doc
$ rust-meth u8 checked --doc

Also works in interactive mode — select a method and its doc comment prints below the signature.

Interactive picker

Pass -i / --interactive instead of a filter to get a live fuzzy selector:

$ rust-meth u8 -i
$ rust-meth '&str' -i

$ rust-meth 'HashMap<String, u32>' -i
? Methods on `HashMap<String, u32>` ›
  capacity
  clear
  clone
  ...

Type to narrow the list, arrow keys to move, Enter to select. Esc to quit.

Combine with --doc to also show the doc comment for the selected method:

$ rust-meth u8 -i --doc

Example output when typing bitor:

✔ Methods on `u8` · bitor
  bitor  fn(self, Rhs) -> <Self as BitOr<Rhs>>::Output

    Performs the `|` operation.
    
    # Examples
    
    ```rust
    assert_eq!(true | false, true);

Go to definition

Pass --gd <method> to find where a method is defined in the standard library source:

$ rust-meth u8 --gd checked_add
u8::checked_add  library/core/src/num/uint_macros.rs:902
$ rust-meth '&str' --gd split_once
&str::split_once  library/core/src/str/mod.rs:2241

Add --open / -o to jump straight to that line in your $EDITOR:

$ rust-meth u8 --gd checked_add --open
u8::checked_add  library/core/src/num/uint_macros.rs:902
# opens uint_macros.rs at line 902 in $EDITOR

Supports hx / helix, nvim, vim, emacs, and code. Any editor that accepts +LINE file on the command line will also work.

Requires the rust-src component and $EDITOR to be set:

rustup component add rust-src
export EDITOR=hx  # or nvim, vim, etc.

Discovery Workflow

Pair it with -i to discover first, then open:

$ rust-meth u8 -i               # pick a method interactively
$ rust-meth u8 --gd isqrt       # find it
$ rust-meth u8 --gd isqrt --open  # open it
u8::isqrt  library/core/src/num/uint_macros.rs:3684

Open in browser

Pass --open-doc with --gd <method> to open the official documentation for that method directly in your browser:

$ rust-meth u8 --gd isqrt --open-doc
u8::isqrt  library/core/src/num/uint_macros.rs:3684
Opening in existing browser session.

Works for primitives, stdlib structs, and collections:

$ rust-meth u8 --gd isqrt --open-doc          # doc.rust-lang.org/std/primitive.u8.html#method.isqrt
$ rust-meth String --gd len --open-doc         # doc.rust-lang.org/std/string/struct.String.html#method.len
$ rust-meth 'Vec<u8>' --gd push --open-doc     # doc.rust-lang.org/std/vec/struct.Vec.html#method.push
$ rust-meth 'HashMap<String, u32>' --gd get --open-doc  # doc.rust-lang.org/std/collections/hash_map/struct.HashMap.html#method.get

[!NOTE] --open and --open-doc are mutually exclusive options

Limitation: --gd currently only works for standard library types. Go-to-definition for 3rd party crate methods is not yet supported.

3rd party crates

Use the --deps flag to query methods on types from external crates:

$ rust-meth 'serde_json::Value' --deps 'serde_json = "1.0"'
✓ Found 37 methods (5.7s)

rust-meth: methods on `serde_json::Value`

  as_array          fn(&self) -> Option<&Vec<Value, Global>>
  as_bool           fn(&self) -> Option<bool>
  as_f64            fn(&self) -> Option<f64>
  as_i64            fn(&self) -> Option<i64>
  as_null           fn(&self) -> Option<()>
  as_object         fn(&self) -> Option<&Map<String, Value>>
  as_str            fn(&self) -> Option<&str>
  as_u64            fn(&self) -> Option<u64>
  ...
37 method(s)

Works with all features:

# Interactive mode
$ rust-meth 'serde_json::Value' --deps 'serde_json = "1.0"' -i

# Fuzzy filter
$ rust-meth 'serde_json::Value' as_bool --deps 'serde_json = "1.0"'

# Show documentation
$ rust-meth 'serde_json::Value' --deps 'serde_json = "1.0"' --doc

Multiple dependencies:

$ rust-meth 'reqwest::Client' --deps 'reqwest = "0.11"
tokio = { version = "1", features = ["full"] }'

Complex dependency specifications:

$ rust-meth 'tokio::net::TcpStream' --deps 'tokio = { version = "1", features = ["net"] }'

[!NOTE] The --deps flag accepts raw TOML syntax exactly as it would appear in Cargo.toml. First-time queries with external crates may take longer (5-10 seconds) as rust-analyzer downloads and indexes the dependencies. Subsequent queries will be faster.

How it works

For each query, rust-meth:

  1. Creates a temporary Cargo project in /tmp with a probe file:
   use std::collections::*;
   // ... other common std imports ...
   fn main() {
       let _x: TYPE = todo!();
       _x.  // ← LSP completion trigger
   }
  1. If --deps is provided, adds those dependencies to the probe's Cargo.toml
  2. Spawns rust-analyzer as a subprocess
  3. Performs the LSP handshake (initialize → initialized → textDocument/didOpen)
  4. Waits for RA to finish indexing, then sends textDocument/completion at the dot
  5. Filters the response for CompletionItemKind::Method items
  6. Prints names and signatures, then shuts RA down

The temporary project is cleaned up automatically on exit.

License

MIT OR Apache-2.0