SYMBOL INDEX (510 symbols across 63 files)

FILE: examples/c.rs
  function main (line 4) | fn main() -> anyhow::Result<()> {

FILE: examples/csharp.rs
  function main (line 5) | fn main() -> anyhow::Result<()> {

FILE: examples/dart.rs
  function main (line 4) | fn main() -> anyhow::Result<()> {

FILE: examples/go.rs
  function main (line 4) | fn main() -> anyhow::Result<()> {

FILE: examples/java.rs
  function main (line 4) | fn main() -> anyhow::Result<()> {

FILE: examples/js.rs
  function main (line 4) | fn main() -> anyhow::Result<()> {

FILE: examples/kotlin.rs
  function main (line 5) | fn main() -> anyhow::Result<()> {

FILE: examples/nix.rs
  function main (line 4) | fn main() -> anyhow::Result<()> {

FILE: examples/python.rs
  function main (line 4) | fn main() -> anyhow::Result<()> {

FILE: examples/rust.rs
  function main (line 4) | fn main() -> anyhow::Result<()> {

FILE: genco-macros/build.rs
  function main (line 5) | fn main() {
  type RustcVersion (line 22) | struct RustcVersion {
  function rustc_version (line 27) | fn rustc_version() -> Option<RustcVersion> {

FILE: genco-macros/src/ast.rs
  type MatchArm (line 9) | pub(crate) struct MatchArm {
  type Delimiter (line 18) | pub(crate) enum Delimiter {
    method encode_open (line 25) | pub(crate) fn encode_open(self, output: &mut StaticBuffer) {
    method encode_close (line 35) | pub(crate) fn encode_close(self, output: &mut StaticBuffer) {
  type LiteralName (line 46) | pub(crate) enum LiteralName<'a> {
  function fmt (line 54) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Name (line 63) | pub(crate) enum Name {
    method as_literal_name (line 74) | pub(crate) fn as_literal_name(&self) -> LiteralName<'_> {
    method to_tokens (line 84) | fn to_tokens(&self, tokens: &mut TokenStream) {
  type ControlKind (line 94) | pub(crate) enum ControlKind {
  type Control (line 101) | pub(crate) struct Control {
    method from_char (line 108) | pub(crate) fn from_char(span: Span, c: char) -> Option<Self> {
  type Ast (line 128) | pub(crate) enum Ast {

FILE: genco-macros/src/cursor.rs
  type Cursor (line 6) | pub(crate) struct Cursor {
    method new (line 17) | pub(crate) fn new(span: Span, start: LineColumn, end: LineColumn) -> C...
    method first_character (line 22) | pub(crate) fn first_character(self) -> Self {
    method last_character (line 34) | pub(crate) fn last_character(self) -> Self {

FILE: genco-macros/src/encoder.rs
  type Encoder (line 12) | pub(crate) struct Encoder<'a> {
  function new (line 41) | pub(crate) fn new(
  function encode (line 60) | pub(crate) fn encode(&mut self, cursor: Cursor, ast: Ast) -> Result<()> {
  function into_output (line 128) | pub(crate) fn into_output(mut self) -> Result<(Requirements, TokenStream...
  function step (line 133) | pub(crate) fn step(&mut self, next: Cursor) -> Result<()> {
  function encode_open_delimiter (line 145) | pub(crate) fn encode_open_delimiter(&mut self, d: Delimiter) {
  function encode_close_delimiter (line 149) | pub(crate) fn encode_close_delimiter(&mut self, d: Delimiter) {
  function encode_literal (line 153) | pub(crate) fn encode_literal(&mut self, string: &str) {
  function encode_string (line 157) | pub(crate) fn encode_string(&mut self, has_eval: bool, stream: TokenStre...
  function encode_quoted (line 169) | pub(crate) fn encode_quoted(&mut self, s: syn::LitStr) {
  function encode_control (line 181) | pub(crate) fn encode_control(&mut self, control: Control) {
  function encode_scope (line 202) | pub(crate) fn encode_scope(&mut self, binding: Option<syn::Ident>, conte...
  function encode_eval_ident (line 218) | pub(crate) fn encode_eval_ident(&mut self, ident: syn::Ident) {
  function encode_eval (line 228) | pub(crate) fn encode_eval(&mut self, expr: syn::Expr) {
  function encode_repeat (line 237) | pub(crate) fn encode_repeat(
  function encode_condition (line 270) | pub(crate) fn encode_condition(
  function encode_match (line 286) | pub(crate) fn encode_match(&mut self, condition: syn::Expr, arms: Vec<Ma...
  function encode_let (line 310) | pub(crate) fn encode_let(&mut self, name: syn::Pat, expr: syn::Expr) {
  function from (line 318) | fn from(&mut self) -> Option<LineColumn> {
  function finalize (line 355) | fn finalize(&mut self) -> Result<()> {
  function tokenize_whitespace (line 377) | fn tokenize_whitespace(

FILE: genco-macros/src/fake.rs
  constant ERROR (line 9) | const ERROR: &str = "Your compiler does not support spans which are requ...
  type LineColumn (line 13) | pub(crate) struct LineColumn {
    method start (line 22) | pub(crate) fn start(span: Span) -> Option<Self> {
    method end (line 32) | pub(crate) fn end(span: Span) -> Option<Self> {
    method start (line 42) | pub(crate) fn start(_: Span) -> Option<Self> {
    method end (line 47) | pub(crate) fn end(_: Span) -> Option<Self> {
  type Buf (line 53) | pub(crate) struct Buf {
    method format (line 59) | fn format(&self, args: Arguments<'_>) -> RefMut<'_, str> {
    method cursor (line 68) | pub(crate) fn cursor(&self, span: Span) -> syn::Result<Cursor> {
    method start (line 93) | pub(crate) fn start(&mut self, span: Span) -> syn::Result<LineColumn> {
    method end (line 104) | pub(crate) fn end(&mut self, span: Span) -> syn::Result<LineColumn> {
    method join (line 115) | pub(crate) fn join(&mut self, a: Span, b: Span) -> syn::Result<Cursor> {
    method find_line_column (line 125) | fn find_line_column(&self, span: Span) -> syn::Result<(usize, usize)> {
    method find_line_column_inner (line 132) | fn find_line_column_inner(&self, span: Span) -> Option<(usize, usize)> {

FILE: genco-macros/src/lib.rs
  type Ctxt (line 14) | struct Ctxt {
  method default (line 20) | fn default() -> Self {
  function quote (line 49) | pub fn quote(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
  function quote_in (line 80) | pub fn quote_in(input: proc_macro::TokenStream) -> proc_macro::TokenStre...
  function quote_fn (line 86) | pub fn quote_fn(input: proc_macro::TokenStream) -> proc_macro::TokenStre...

FILE: genco-macros/src/quote.rs
  type Quote (line 14) | pub(crate) struct Quote<'a> {
  function new (line 35) | pub(crate) fn new(cx: &'a Ctxt) -> Self {
  function new_until_comma (line 46) | pub(crate) fn new_until_comma(cx: &'a Ctxt) -> Self {
  function with_span (line 57) | pub(crate) fn with_span(mut self, span: Span) -> syn::Result<Self> {
  function parse (line 80) | pub(crate) fn parse(mut self, input: ParseStream) -> Result<(Requirement...
  function parse_condition (line 87) | fn parse_condition(&self, input: ParseStream) -> Result<(Requirements, A...
  function parse_loop (line 138) | fn parse_loop(&self, input: ParseStream) -> Result<(Requirements, Ast)> {
  function parse_match (line 188) | fn parse_match(&self, input: ParseStream) -> Result<(Requirements, Ast)> {
  function parse_let (line 247) | fn parse_let(&self, input: ParseStream) -> Result<(Requirements, Ast)> {
  function parse_scope (line 262) | fn parse_scope(&self, input: ParseStream) -> Result<Ast> {
  function parse_expression (line 288) | fn parse_expression(&mut self, encoder: &mut Encoder, input: ParseStream...
  function parse_inner (line 336) | fn parse_inner(
  function parse_group (line 474) | fn parse_group(
  function parse_internal_function (line 502) | pub(crate) fn parse_internal_function<'a>(

FILE: genco-macros/src/quote_fn.rs
  type QuoteFn (line 7) | pub(crate) struct QuoteFn {
  method parse (line 12) | fn parse(input: ParseStream) -> Result<Self> {

FILE: genco-macros/src/quote_in.rs
  type QuoteIn (line 8) | pub(crate) struct QuoteIn {
  method parse (line 13) | fn parse(input: ParseStream) -> Result<Self> {

FILE: genco-macros/src/requirements.rs
  type Requirements (line 4) | pub(crate) struct Requirements {
    method merge_with (line 10) | pub fn merge_with(&mut self, other: Self) {
    method into_check (line 15) | pub fn into_check(self, receiver: &syn::Ident) -> TokenStream {

FILE: genco-macros/src/static_buffer.rs
  type StaticBuffer (line 6) | pub(crate) struct StaticBuffer<'a> {
  function new (line 13) | pub(crate) fn new(cx: &'a Ctxt) -> Self {
  function push (line 21) | pub(crate) fn push(&mut self, c: char) {
  function push_str (line 26) | pub(crate) fn push_str(&mut self, s: &str) {
  function flush (line 31) | pub(crate) fn flush(&mut self, tokens: &mut TokenStream) {

FILE: genco-macros/src/string_parser.rs
  type Options (line 20) | pub(crate) struct Options {
  function adjust_start (line 25) | fn adjust_start(start: LineColumn) -> LineColumn {
  function adjust_end (line 32) | fn adjust_end(end: LineColumn) -> LineColumn {
  type Encoder (line 39) | struct Encoder<'a> {
  function new (line 50) | pub fn new(cx: &'a Ctxt, cursor: LineColumn, span: Span) -> Self {
  function finalize (line 62) | pub(crate) fn finalize(self, end: LineColumn) -> Result<(Options, TokenS...
  function encode_char (line 69) | pub(crate) fn encode_char(&self, c: char, from: LineColumn, to: LineColu...
  function encode_str (line 77) | pub(crate) fn encode_str(
  function eval_ident (line 89) | pub(crate) fn eval_ident(
  function eval_stream (line 112) | pub(crate) fn eval_stream(
  function raw_expr (line 133) | pub(crate) fn raw_expr(
  function extend_tt (line 149) | pub(crate) fn extend_tt(
  function flush (line 161) | pub fn flush(&self, from: Option<LineColumn>, to: Option<LineColumn>) ->...
  function flush_whitespace (line 187) | pub(crate) fn flush_whitespace(
  type StringParser (line 210) | pub struct StringParser<'a> {
  function new (line 219) | pub(crate) fn new(cx: &'a Ctxt, buf: &'a Buf, span: Span) -> syn::Result...
  function parse (line 234) | pub(crate) fn parse(self, input: ParseStream) -> Result<(Options, Requir...
  function is_lit_str_opt (line 312) | pub(crate) fn is_lit_str_opt(content: ParseBuffer<'_>) -> syn::Result<bo...

FILE: src/fmt/config.rs
  type Indentation (line 34) | pub enum Indentation {
  type Config (line 43) | pub struct Config {
    method from_lang (line 53) | pub fn from_lang<L>() -> Self
    method with_indentation (line 64) | pub fn with_indentation(self, indentation: Indentation) -> Self {
    method with_newline (line 72) | pub fn with_newline(self, newline: &'static str) -> Self {

FILE: src/fmt/cursor.rs
  type Parse (line 5) | pub(super) trait Parse {
    method parse (line 9) | fn parse(item: &Item) -> fmt::Result<&Self::Output>;
    method peek (line 12) | fn peek(item: &Item) -> bool;
    type Output (line 19) | type Output = str;
    method peek (line 22) | fn peek(item: &Item) -> bool {
    method parse (line 27) | fn parse(item: &Item) -> fmt::Result<&Self::Output> {
    type Output (line 39) | type Output = ();
    method peek (line 42) | fn peek(item: &Item) -> bool {
    method parse (line 47) | fn parse(item: &Item) -> fmt::Result<&Self::Output> {
  type Literal (line 16) | pub(super) struct Literal(());
  type CloseEval (line 36) | pub(super) struct CloseEval(());
  type Cursor (line 56) | pub(super) struct Cursor<'a, T> {
  function new (line 63) | pub(super) fn new(lang: &'a [T], items: &'a [Item]) -> Self {
  function lang (line 68) | pub(super) fn lang(&self, index: usize) -> fmt::Result<&'a T> {
  function next (line 73) | pub(super) fn next(&mut self) -> Option<&Item> {
  function peek (line 80) | pub(super) fn peek<P>(&self) -> bool
  function peek1 (line 92) | pub(super) fn peek1<P>(&self) -> bool
  function parse (line 104) | pub(super) fn parse<P>(&mut self) -> fmt::Result<&P::Output>

FILE: src/fmt/fmt_writer.rs
  type FmtWriter (line 35) | pub struct FmtWriter<W>
  function new (line 47) | pub fn new(writer: W) -> Self {
  function as_formatter (line 52) | pub fn as_formatter<'a>(&'a mut self, config: &'a fmt::Config) -> fmt::F...
  function into_inner (line 57) | pub fn into_inner(self) -> W {
  function write_char (line 67) | fn write_char(&mut self, c: char) -> core::fmt::Result {
  function write_str (line 72) | fn write_str(&mut self, s: &str) -> core::fmt::Result {
  function write_line (line 82) | fn write_line(&mut self, config: &fmt::Config) -> fmt::Result {

FILE: src/fmt/formatter.rs
  type Whitespace (line 18) | enum Whitespace {
    method into_indent (line 31) | fn into_indent(self) -> Option<usize> {
  type Formatter (line 43) | pub struct Formatter<'a> {
  function new (line 62) | pub(crate) fn new(write: &'a mut (dyn fmt::Write + 'a), config: &'a Conf...
  function format_items (line 73) | pub(crate) fn format_items<L>(
  function write_trailing_line (line 90) | pub(crate) fn write_trailing_line(&mut self) -> fmt::Result {
  function write_str (line 98) | fn write_str(&mut self, s: &str) -> fmt::Result {
  function push (line 107) | fn push(&mut self) {
  function line (line 118) | fn line(&mut self) {
  function space (line 128) | fn space(&mut self) {
  function indentation (line 133) | fn indentation(&mut self, n: i16) {
  function format_cursor (line 139) | fn format_cursor<L>(
  function quoted_quote (line 247) | fn quoted_quote<L>(
  function flush_whitespace (line 269) | fn flush_whitespace(&mut self) -> fmt::Result {
  function write_str (line 306) | fn write_str(&mut self, s: &str) -> fmt::Result {
  function fmt (line 316) | fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {

FILE: src/fmt/io_writer.rs
  type IoWriter (line 37) | pub struct IoWriter<W>
  function new (line 49) | pub fn new(writer: W) -> Self {
  function as_formatter (line 54) | pub fn as_formatter<'a>(&'a mut self, config: &'a fmt::Config) -> fmt::F...
  function into_inner (line 59) | pub fn into_inner(self) -> W {
  function write_char (line 69) | fn write_char(&mut self, c: char) -> core::fmt::Result {
  function write_str (line 76) | fn write_str(&mut self, s: &str) -> core::fmt::Result {
  function write_line (line 88) | fn write_line(&mut self, config: &fmt::Config) -> fmt::Result {

FILE: src/fmt/mod.rs
  type Result (line 64) | pub type Result<T = ()> = core::result::Result<T, core::fmt::Error>;
  type Error (line 66) | pub type Error = core::fmt::Error;
  type Write (line 69) | pub(crate) trait Write: core::fmt::Write {
    method write_line (line 71) | fn write_line(&mut self, config: &Config) -> Result;
    method write_trailing_line (line 75) | fn write_trailing_line(&mut self, config: &Config) -> Result {

FILE: src/fmt/vec_writer.rs
  type VecWriter (line 44) | pub struct VecWriter {
    method new (line 51) | pub fn new() -> Self {
    method as_formatter (line 56) | pub fn as_formatter<'a>(&'a mut self, config: &'a fmt::Config) -> fmt:...
    method into_vec (line 61) | pub fn into_vec(mut self) -> Vec<String> {
    method write_char (line 69) | fn write_char(&mut self, c: char) -> core::fmt::Result {
    method write_str (line 74) | fn write_str(&mut self, s: &str) -> core::fmt::Result {
    method write_line (line 81) | fn write_line(&mut self, _: &fmt::Config) -> fmt::Result {
    method write_trailing_line (line 88) | fn write_trailing_line(&mut self, _: &fmt::Config) -> fmt::Result {

FILE: src/lang/c.rs
  type Tokens (line 13) | pub type Tokens = crate::Tokens<C>;
  type Import (line 54) | pub struct Import {
  type Format (line 65) | pub struct Format {}
  type Config (line 69) | pub struct Config {}
  method imports (line 72) | fn imports(out: &mut Tokens, tokens: &Tokens) {
  function include (line 119) | pub fn include(path: impl Into<ItemStr>, item: impl Into<ItemStr>) -> Im...
  function include_system (line 150) | pub fn include_system<M, N>(path: M, item: N) -> Import

FILE: src/lang/csharp/block_comment.rs
  type BlockComment (line 8) | pub struct BlockComment<T>(pub(super) T);
  function format_into (line 15) | fn format_into(self, tokens: &mut Tokens<Csharp>) {

FILE: src/lang/csharp/comment.rs
  type Comment (line 8) | pub struct Comment<T>(pub(super) T);
  function format_into (line 15) | fn format_into(self, tokens: &mut Tokens<Csharp>) {

FILE: src/lang/csharp/mod.rs
  type Tokens (line 35) | pub type Tokens = crate::Tokens<Csharp>;
  constant SEP (line 114) | const SEP: &str = ".";
  type Format (line 118) | pub struct Format {
  type Config (line 128) | pub struct Config {
    method with_namespace (line 135) | pub fn with_namespace<N>(self, namespace: N) -> Self
  type Import (line 149) | pub struct Import {
    method qualified (line 161) | pub fn qualified(self) -> Self {
  method imports (line 170) | fn imports(
  function import (line 243) | pub fn import<P, N>(namespace: P, name: N) -> Import
  function block_comment (line 278) | pub fn block_comment<T>(comment: T) -> BlockComment<T>
  function comment (line 307) | pub fn comment<T>(comment: T) -> Comment<T>

FILE: src/lang/dart/doc_comment.rs
  type DocComment (line 8) | pub struct DocComment<T>(pub(super) T);
  function format_into (line 15) | fn format_into(self, tokens: &mut Tokens<Dart>) {

FILE: src/lang/dart/mod.rs
  constant SEP (line 44) | const SEP: &str = ".";
  constant DART_CORE (line 46) | const DART_CORE: &str = "dart:core";
  type Tokens (line 49) | pub type Tokens = crate::Tokens<Dart>;
  type Format (line 157) | pub struct Format {}
  type Config (line 161) | pub struct Config {}
  type Import (line 167) | pub struct Import {
    method with_alias (line 178) | pub fn with_alias(self, alias: impl Into<ItemStr>) -> Import {
  method imports (line 188) | fn imports(out: &mut Tokens, input: &Tokens, _: &Config) {
  function import (line 250) | pub fn import<P, N>(path: P, name: N) -> Import
  function doc_comment (line 285) | pub fn doc_comment<T>(comment: T) -> DocComment<T>

FILE: src/lang/go.rs
  constant MODULE_SEP (line 50) | const MODULE_SEP: &str = "/";
  constant SEP (line 51) | const SEP: &str = ".";
  type Tokens (line 54) | pub type Tokens = crate::Tokens<Go>;
  type Import (line 105) | pub struct Import {
  type Format (line 114) | pub struct Format {}
  type Config (line 118) | pub struct Config {
    method with_package (line 124) | pub fn with_package<P: Into<ItemStr>>(self, package: P) -> Self {
  method imports (line 132) | fn imports(out: &mut Tokens, tokens: &Tokens) {
  function import (line 175) | pub fn import<M, N>(module: M, name: N) -> Import

FILE: src/lang/java/block_comment.rs
  type BlockComment (line 8) | pub struct BlockComment<T>(pub(super) T);
  function format_into (line 15) | fn format_into(self, tokens: &mut Tokens<Java>) {

FILE: src/lang/java/mod.rs
  type Tokens (line 30) | pub type Tokens = crate::Tokens<Java>;
  constant JAVA_LANG (line 102) | const JAVA_LANG: &str = "java.lang";
  constant SEP (line 103) | const SEP: &str = ".";
  type Format (line 107) | pub struct Format {
  type Config (line 114) | pub struct Config {
    method with_package (line 149) | pub fn with_package<P>(self, package: P) -> Self
  type Import (line 163) | pub struct Import {
  method imports (line 171) | fn imports(
  function import (line 238) | pub fn import<P, N>(package: P, name: N) -> Import
  function block_comment (line 277) | pub fn block_comment<T>(comment: T) -> BlockComment<T>

FILE: src/lang/js.rs
  type Tokens (line 59) | pub type Tokens = crate::Tokens<JavaScript>;
  type Format (line 184) | pub struct Format {}
  type Config (line 188) | pub struct Config {
    method with_module_path (line 236) | pub fn with_module_path<M>(self, module_path: M) -> Self
  type ImportKind (line 248) | enum ImportKind {
  type Import (line 258) | pub struct Import {
    method with_alias (line 310) | pub fn with_alias<N>(self, alias: N) -> Self
    method into_default (line 342) | pub fn into_default(self) -> Self {
    method into_wildcard (line 371) | pub fn into_wildcard(self) -> Self {
  type Module (line 382) | pub enum Module {
    method from (line 393) | fn from(value: &'a str) -> Self {
    method from (line 399) | fn from(value: String) -> Self {
    method from (line 405) | fn from(value: ItemStr) -> Self {
  method imports (line 412) | fn imports(out: &mut Tokens, tokens: &Tokens, config: &Config) {
  function import (line 549) | pub fn import<M, N>(module: M, name: N) -> Import

FILE: src/lang/kotlin/mod.rs
  type Tokens (line 28) | pub type Tokens = crate::Tokens<Kotlin>;
  type Format (line 127) | pub struct Format {
  type Config (line 135) | pub struct Config {
    method with_package (line 172) | pub fn with_package<P>(self, package: P) -> Self
  type Import (line 186) | pub struct Import {
  method imports (line 195) | fn imports(
  function import (line 262) | pub fn import<P, N>(package: P, name: N) -> Import

FILE: src/lang/mod.rs
  type Lang (line 52) | pub trait Lang: Sized {
    method default_indentation (line 61) | fn default_indentation() -> fmt::Indentation {
    method open_quote (line 66) | fn open_quote(
    method close_quote (line 77) | fn close_quote(
    method string_eval_literal (line 88) | fn string_eval_literal(
    method start_string_eval (line 101) | fn start_string_eval(
    method end_string_eval (line 110) | fn end_string_eval(
    method write_quoted (line 119) | fn write_quoted(out: &mut fmt::Formatter<'_>, input: &str) -> fmt::Res...
    method format_file (line 124) | fn format_file(
    type Config (line 142) | type Config = ();
    type Format (line 143) | type Format = ();
    type Item (line 144) | type Item = ();
  type LangSupportsEval (line 138) | pub trait LangSupportsEval: Lang {}
  function format (line 151) | fn format(&self, _: &mut fmt::Formatter<'_>, _: &L::Config, _: &L::Forma...
  type LangItem (line 160) | pub trait LangItem<L>
    method format (line 165) | fn format(
  function c_family_write_quoted (line 179) | pub fn c_family_write_quoted(out: &mut fmt::Formatter, input: &str) -> f...

FILE: src/lang/nix.rs
  type Tokens (line 14) | pub type Tokens = crate::Tokens<Nix>;
  type Import (line 61) | pub enum Import {
  type ImportArgument (line 74) | pub struct ImportArgument(ItemStr);
  type ImportInherit (line 78) | pub struct ImportInherit {
  type ImportVariable (line 87) | pub struct ImportVariable {
  type ImportWith (line 96) | pub struct ImportWith {
  type Format (line 105) | pub struct Format {}
  type Config (line 109) | pub struct Config {
    method with_scoped (line 115) | pub fn with_scoped(self, scoped: bool) -> Self {
  method arguments (line 121) | fn arguments(out: &mut Tokens, tokens: &Tokens) {
  method withs (line 180) | fn withs(out: &mut Tokens, tokens: &Tokens) {
  method imports (line 201) | fn imports(out: &mut Tokens, tokens: &Tokens) {
  function argument (line 271) | pub fn argument<M>(name: M) -> Import
  function inherit (line 304) | pub fn inherit<M, N>(path: M, name: N) -> Import
  function variable (line 352) | pub fn variable<M, N>(name: M, value: N) -> Import
  function with (line 388) | pub fn with<M, N>(argument: M, name: N) -> Import

FILE: src/lang/python.rs
  type Tokens (line 29) | pub type Tokens = crate::Tokens<Python>;
  type Format (line 89) | pub struct Format {}
  type Config (line 92) | pub struct Config {}
  type TypeModule (line 97) | enum TypeModule {
    method qualified (line 111) | fn qualified(self) -> Self {
    method with_alias (line 121) | fn with_alias<T>(self, alias: T) -> Self
  type Import (line 138) | pub struct Import {
    method with_alias (line 171) | pub fn with_alias<T>(self, alias: T) -> Self
    method qualified (line 202) | pub fn qualified(self) -> Self {
    method with_module_alias (line 232) | pub fn with_module_alias<T>(self, module_alias: T) -> Self
  type ImportModule (line 247) | pub struct ImportModule {
    method with_alias (line 277) | pub fn with_alias<N>(self, new_alias: N) -> Self
  method imports (line 289) | fn imports(out: &mut Tokens, tokens: &Tokens) {
  function import (line 380) | pub fn import<M, N>(module: M, name: N) -> Import
  function import_module (line 418) | pub fn import_module<M>(module: M) -> ImportModule

FILE: src/lang/rust.rs
  constant SEP (line 45) | const SEP: &str = "::";
  type Tokens (line 48) | pub type Tokens = crate::Tokens<Rust>;
  type Format (line 141) | pub struct Format {}
  type Config (line 145) | pub struct Config {
    method with_default_import (line 153) | pub fn with_default_import(self, default_import: ImportMode) -> Self {
  method default (line 159) | fn default() -> Self {
  type ImportMode (line 168) | pub enum ImportMode {
  type Module (line 182) | enum Module {
    method into_module_aliased (line 195) | fn into_module_aliased<A>(self, alias: A) -> Self
    method into_aliased (line 210) | fn into_aliased(self) -> Self {
    method direct (line 223) | fn direct(self) -> Self {
    method qualified (line 236) | fn qualified(self) -> Self {
  type Import (line 251) | pub struct Import {
    method with_alias (line 282) | pub fn with_alias<A: Into<ItemStr>>(self, alias: A) -> Self {
    method with_module_alias (line 315) | pub fn with_module_alias<A: Into<ItemStr>>(self, alias: A) -> Self {
    method qualified (line 350) | pub fn qualified(self) -> Self {
    method direct (line 380) | pub fn direct(self) -> Self {
    method write_direct (line 388) | fn write_direct(&self, out: &mut fmt::Formatter<'_>) -> fmt::Result {
    method write_prefixed (line 397) | fn write_prefixed(&self, out: &mut fmt::Formatter<'_>, module: &ItemSt...
  method imports (line 409) | fn imports(out: &mut Tokens, config: &Config, tokens: &Tokens) {
  function import (line 698) | pub fn import<M, N>(module: M, name: N) -> Import

FILE: src/lang/swift.rs
  type Tokens (line 24) | pub type Tokens = crate::Tokens<Swift>;
  type Format (line 84) | pub struct Format {}
  type Config (line 88) | pub struct Config {}
  type Import (line 94) | pub struct Import {
  type ImportImplementationOnly (line 105) | pub struct ImportImplementationOnly {
  type ImportType (line 116) | enum ImportType {
  method imports (line 127) | fn imports(out: &mut Tokens, tokens: &Tokens) {
  function import (line 180) | pub fn import<M, N>(module: M, name: N) -> Import
  function import_implementation_only (line 210) | pub fn import_implementation_only(

FILE: src/lib.rs
  function static_ (line 1000) | pub const fn static_(string: &'static str) -> Item {
  function literal (line 1005) | pub const fn literal(string: ItemStr) -> Item {
  function indentation (line 1010) | pub const fn indentation(level: i16) -> Item {
  function push (line 1015) | pub const fn push() -> Item {
  function line (line 1020) | pub const fn line() -> Item {
  function space (line 1025) | pub const fn space() -> Item {
  function open_quote (line 1030) | pub const fn open_quote(is_interpolation: bool) -> Item {
  function close_quote (line 1035) | pub const fn close_quote() -> Item {
  function open_eval (line 1040) | pub const fn open_eval() -> Item {
  function close_eval (line 1045) | pub const fn close_eval() -> Item {
  function item (line 1056) | pub fn item<L>(item: L::Item) -> impl FormatInto<L>
  function register (line 1072) | pub fn register<L>(item: L::Item) -> impl FormatInto<L>

FILE: src/tokens/display.rs
  function display (line 57) | pub fn display<T>(inner: T) -> Display<T>
  type Display (line 69) | pub struct Display<T> {
  function format_into (line 79) | fn format_into(self, tokens: &mut Tokens<L>) {

FILE: src/tokens/format_into.rs
  type FormatInto (line 43) | pub trait FormatInto<L>
    method format_into (line 48) | fn format_into(self, tokens: &mut Tokens<L>);
  function format_into (line 71) | fn format_into(self, tokens: &mut Self) {
  function format_into (line 97) | fn format_into(self, tokens: &mut Tokens<L>) {
  function format_into (line 125) | fn format_into(self, tokens: &mut Tokens<L>) {
  function format_into (line 155) | fn format_into(self, tokens: &mut Tokens<L>) {
  function format_into (line 186) | fn format_into(self, tokens: &mut Tokens<L>) {
  function format_into (line 213) | fn format_into(self, tokens: &mut Tokens<L>) {
  function format_into (line 238) | fn format_into(self, tokens: &mut Tokens<L>) {
  method format_into (line 264) | fn format_into(self, tokens: &mut Tokens<L>) {
  function format_into (line 290) | fn format_into(self, tokens: &mut Tokens<L>) {
  function format_into (line 317) | fn format_into(self, tokens: &mut Tokens<L>) {
  function format_into (line 341) | fn format_into(self, tokens: &mut Tokens<L>) {
  function format_into (line 373) | fn format_into(self, tokens: &mut Tokens<L>) {
  function format_into (line 401) | fn format_into(self, tokens: &mut Tokens<L>) {
  function format_into (line 430) | fn format_into(self, tokens: &mut Tokens<L>) {
  function format_into (line 460) | fn format_into(self, tokens: &mut Tokens<L>) {
  function format_into (line 494) | fn format_into(self, tokens: &mut Tokens<L>) {

FILE: src/tokens/from_fn.rs
  function from_fn (line 27) | pub fn from_fn<F, L>(f: F) -> FromFn<F>
  type FromFn (line 39) | pub struct FromFn<F> {
  function format_into (line 49) | fn format_into(self, tokens: &mut Tokens<L>) {

FILE: src/tokens/item.rs
  type Kind (line 9) | pub(crate) enum Kind {
  type Item (line 42) | pub struct Item {
    method new (line 49) | pub(crate) const fn new(kind: Kind) -> Self {
    method static_ (line 67) | pub const fn static_(literal: &'static str) -> Self {
    method push (line 85) | pub const fn push() -> Self {
    method line (line 103) | pub const fn line() -> Self {
    method space (line 121) | pub const fn space() -> Self {
    method indentation (line 127) | pub(crate) const fn indentation(n: i16) -> Self {
    method open_quote (line 152) | pub const fn open_quote(is_interpolated: bool) -> Self {
    method close_quote (line 170) | pub const fn close_quote() -> Self {
    method open_eval (line 176) | pub(crate) const fn open_eval() -> Self {
    method close_eval (line 182) | pub(crate) const fn close_eval() -> Self {
    method literal (line 200) | pub const fn literal(lit: ItemStr) -> Self {
    method lang (line 206) | pub(crate) const fn lang(index: usize) -> Item {
    method fmt (line 213) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method format_into (line 251) | fn format_into(self, tokens: &mut Tokens<L>) {

FILE: src/tokens/item_str.rs
  type ItemStrKind (line 21) | enum ItemStrKind {
  type ItemStr (line 31) | pub struct ItemStr {
    method new (line 38) | const fn new(kind: ItemStrKind) -> Self {
    method static_ (line 52) | pub const fn static_(s: &'static str) -> Self {
    method format_into (line 63) | fn format_into(self, tokens: &mut Tokens<L>) {
    method as_ref (line 80) | fn as_ref(&self) -> &str {
    method from (line 104) | fn from(value: Box<str>) -> Self {
    method from (line 111) | fn from(value: &'a ItemStr) -> Self {
    method from (line 119) | fn from(value: &'a String) -> Self {
    method from (line 127) | fn from(value: String) -> Self {
    method from (line 135) | fn from(value: &'a str) -> Self {
    method from (line 143) | fn from(value: &'b &'a str) -> Self {
    method from (line 151) | fn from(value: Cow<'a, str>) -> Self {
    method from (line 162) | fn from(value: &'b Cow<'a, str>) -> Self {
    method from (line 173) | fn from(value: Rc<String>) -> Self {
    method fmt (line 180) | fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
    method fmt (line 187) | fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
  function format_into (line 73) | fn format_into(self, tokens: &mut Tokens<L>) {
  type Target (line 90) | type Target = str;
  method deref (line 92) | fn deref(&self) -> &str {
  method eq (line 194) | fn eq(&self, other: &Self) -> bool {
  method partial_cmp (line 203) | fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
  method cmp (line 210) | fn cmp(&self, other: &Self) -> core::cmp::Ordering {
  method hash (line 217) | fn hash<H>(&self, state: &mut H)

FILE: src/tokens/quoted.rs
  function quoted (line 54) | pub fn quoted<T>(inner: T) -> QuotedFn<T> {
  type QuotedFn (line 62) | pub struct QuotedFn<T> {
  function format_into (line 72) | fn format_into(self, t: &mut Tokens<L>) {

FILE: src/tokens/register.rs
  function register (line 48) | pub fn register<T, L>(inner: T) -> RegisterFn<T>
  type RegisterFn (line 60) | pub struct RegisterFn<T> {
  function format_into (line 69) | fn format_into(self, t: &mut Tokens<L>) {
  type Register (line 106) | pub trait Register<L>
    method register (line 111) | fn register(self, tokens: &mut Tokens<L>);

FILE: src/tokens/static_literal.rs
  type StaticLiteral (line 8) | pub struct StaticLiteral {
    method format_into (line 17) | fn format_into(self, tokens: &mut crate::Tokens<L>) {
  function static_literal (line 39) | pub fn static_literal(literal: &'static str) -> StaticLiteral {

FILE: src/tokens/tokens.rs
  type Tokens (line 70) | pub struct Tokens<L = ()>
  function new (line 93) | pub fn new() -> Self {
  function with_capacity (line 111) | pub fn with_capacity(cap: usize) -> Self {
  function iter (line 137) | pub fn iter(&self) -> Iter<'_, L::Item> {
  function append (line 166) | pub fn append<T>(&mut self, tokens: T)
  function item (line 174) | pub(crate) fn item(&mut self, item: Item) {
  function extend_by_ref (line 190) | pub(crate) fn extend_by_ref(&mut self, other: &Tokens<L>)
  function extend_by_owned (line 217) | pub(crate) fn extend_by_owned(&mut self, mut other: Tokens<L>) {
  function iter_lang (line 256) | pub fn iter_lang(&self) -> IterLang<'_, L> {
  function register (line 279) | pub fn register<T>(&mut self, tokens: T)
  function is_empty (line 295) | pub fn is_empty(&self) -> bool {
  function space (line 329) | pub fn space(&mut self) {
  function push (line 367) | pub fn push(&mut self) {
  function line (line 419) | pub fn line(&mut self) {
  function indent (line 471) | pub fn indent(&mut self) {
  function unindent (line 521) | pub fn unindent(&mut self) {
  function format (line 574) | pub fn format(
  function literal (line 585) | pub(crate) fn literal(&mut self, lit: impl Into<ItemStr>) {
  function open_quote (line 591) | pub(crate) fn open_quote(&mut self, is_interpolated: bool) {
  function close_quote (line 597) | pub(crate) fn close_quote(&mut self) {
  function lang_item (line 602) | pub(crate) fn lang_item(&mut self, item: L::Item) {
  function lang_item_register (line 608) | pub(crate) fn lang_item_register(&mut self, item: L::Item) {
  function format_file (line 650) | pub fn format_file(&self, out: &mut fmt::Formatter<'_>, config: &L::Conf...
  function indentation (line 657) | fn indentation(&mut self, mut n: i16) {
  method default (line 685) | fn default() -> Self {
  function lang_supports_eval (line 697) | pub fn lang_supports_eval(&self) {}
  function to_file_string (line 732) | pub fn to_file_string(&self) -> fmt::Result<String> {
  function to_string (line 767) | pub fn to_string(&self) -> fmt::Result<String> {
  function to_file_vec (line 834) | pub fn to_file_vec(&self) -> fmt::Result<Vec<String>> {
  function to_vec (line 872) | pub fn to_vec(&self) -> fmt::Result<Vec<String>> {
  function eq (line 889) | fn eq(&self, other: &Tokens<L>) -> bool {
  function eq (line 899) | fn eq(&self, other: &Vec<Item>) -> bool {
  function eq (line 909) | fn eq(&self, other: &Tokens<L>) -> bool {
  function eq (line 919) | fn eq(&self, other: &[Item]) -> bool {
  function eq (line 929) | fn eq(&self, other: &[Item; N]) -> bool {
  function eq (line 939) | fn eq(&self, other: &Tokens<L>) -> bool {
  function partial_cmp (line 957) | fn partial_cmp(&self, other: &Tokens<L>) -> Option<Ordering> {
  method cmp (line 968) | fn cmp(&self, other: &Tokens<L>) -> Ordering {
  type ItemRef (line 976) | pub struct ItemRef<'a, T> {
  function fmt (line 985) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type ItemRefKind (line 991) | enum ItemRefKind<'a, T> {
  function eq (line 998) | fn eq(&self, other: &Item) -> bool {
  function eq (line 1008) | fn eq(&self, other: &&Item) -> bool {
  method eq (line 1018) | fn eq(&self, other: &ItemRef<'_, T>) -> bool {
  function eq (line 1025) | fn eq(&self, other: &ItemRef<'_, T>) -> bool {
  type Iter (line 1033) | pub struct Iter<'a, T> {
  type Item (line 1039) | type Item = ItemRef<'a, T>;
  method next (line 1042) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1055) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Item (line 1064) | type Item = ItemRef<'a, L::Item>;
  type IntoIter (line 1065) | type IntoIter = Iter<'a, L::Item>;
  method into_iter (line 1068) | fn into_iter(self) -> Self::IntoIter {
  function fmt (line 1079) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  method clone (line 1090) | fn clone(&self) -> Self {
  function hash (line 1104) | fn hash<H>(&self, state: &mut H)
  type IterLang (line 1116) | pub struct IterLang<'a, L>
  type Item (line 1127) | type Item = &'a L::Item;
  method next (line 1130) | fn next(&mut self) -> Option<Self::Item> {
  type Import (line 1149) | struct Import(u32);
  function test_walk_custom (line 1166) | fn test_walk_custom() {

FILE: tests/test_indentation_rules.rs
  function test_indentation_rules (line 4) | fn test_indentation_rules() -> genco::fmt::Result {

FILE: tests/test_option.rs
  function test_option (line 4) | fn test_option() -> genco::fmt::Result {

FILE: tests/test_quote.rs
  function test_quote (line 4) | fn test_quote() -> genco::fmt::Result {
  function test_tight_quote (line 50) | fn test_tight_quote() -> genco::fmt::Result {
  function test_escape (line 60) | fn test_escape() -> genco::fmt::Result {
  function test_scope (line 68) | fn test_scope() -> genco::fmt::Result {

FILE: tests/test_quote_in.rs
  function test_quote_in (line 5) | fn test_quote_in() -> genco::fmt::Result {
  function test_quote_into_unit (line 14) | fn test_quote_into_unit() -> genco::fmt::Result {

FILE: tests/test_quote_simple_expression.rs
  function test_quote_simple_expression (line 4) | fn test_quote_simple_expression() -> genco::fmt::Result {

FILE: tests/test_register.rs
  function test_register (line 4) | fn test_register() -> genco::fmt::Result {

FILE: tests/test_string.rs
  function test_quoted (line 4) | fn test_quoted() -> genco::fmt::Result {
  function test_string_in_string_in (line 20) | fn test_string_in_string_in() -> genco::fmt::Result {

FILE: tests/test_token_gen.rs
  function test_token_gen (line 10) | fn test_token_gen() {
  function test_iterator_gen (line 36) | fn test_iterator_gen() {
  function test_tricky_continuation (line 79) | fn test_tricky_continuation() {
  function test_indentation (line 110) | fn test_indentation() {
  function test_repeat (line 156) | fn test_repeat() {
  function test_tight_quote (line 201) | fn test_tight_quote() {
  function test_tight_repitition (line 217) | fn test_tight_repitition() {
  function test_if (line 241) | fn test_if() {
  function test_match (line 272) | fn test_match() {
  function test_let (line 328) | fn test_let() {
  function test_mutable_let (line 380) | fn test_mutable_let() {
  function test_empty_loop_whitespace (line 413) | fn test_empty_loop_whitespace() {
  function test_indentation_empty (line 454) | fn test_indentation_empty() {
  function test_indentation_management (line 499) | fn test_indentation_management() {
  function test_indentation_management2 (line 558) | fn test_indentation_management2() -> fmt::Result {
  function test_lines (line 595) | fn test_lines() -> fmt::Result {