Module rust

Expand description

Rust code syntax is available through this module.

Rust syntax elements.

Note that no checking exists to make sure the elements are used correctly, i.e. the correct combination of structs. Instead, the library user is expected to have basic knowledge of how Rust syntax is composed, and to combine the structs in this module likewise.

Example:


async fn write_function<O>(output: &mut O) -> Result<(), O::Error> where O: Output {
  // For more advanced usage, you can replace Str("") by other Writable implementations
  let function_def = FunctionDef {
    mods: SingularSeq(ModPub),
    name: Str("my_func"),
    args: CombinedSeq(
     SingularSeq(FunctionParam(Str("var1"), Str("Type"))),
     SingularSeq(FunctionParam(Str("var2"), Parameterized::new(Str("Option"), SingularSeq(Str("bool")))))
    ),
    return_type: Parameterized::new(Str("Box"), SingularSeq(Str("str"))),
    where_conds: NoOpSeq,
    body: FunctionBodyImplement(Str("todo!()"))
  };
  function_def.write_to(output).await
  // Will render as:
  /*
  pub fn my_func(var1: Type, var2: Option<bool>) -> Box<str> {
    todo!()
  }
   */
}

Structs§

AllowLints: The attribute content for allow(...). The tuple value must be a sequence.
AnonTuple: An anonymous tuple type. This struct’s tuple value must be a sequence.
ArrayFromElements: An array literal with predefined elements written out. Renders as [E1, E2, E3, ...] where EX is in the element sequence.
AssignStmt: An assignation. This statement includes the semicolon and a new line.
AssociatedItem: An item attached to an associated container, via “::”. The output will look like Cont::Item.
AssociatedTypeDef: Declares an associated type, rendering as type VarName = Value;. Adds new lines before and after.
AssociatedTypeEquals: Renders as Type=Value. Intended to be used as a type argument, to specify associated types.
AttributesAccept: A sequence acceptor that writes attributes. Every attribute will be surrounded with “#[]”
BoundedTypeVar: A type variable with a sequence of bounds. Will render as TypeVar: B1 + B2 + ...
Cfg: A cfg attribute. Renders as cfg(Cond).
CfgAttr: An attribute enabled conditionally, i.e. #[cfg_attr(Cond, Attr)]
Closure: Writes a closure. Adds new lines inside the brackets, wrapping the inner expression.
DeclareField: Declares a single field within a struct. Renders as Name: Value.
DynOf: Adds a “dyn “ before a type expression.
EnumDef: Defines an enum.
ExternBlock: Declaration of an extern block, i.e. for FFI. In Rust 2024 and later, the unsafe keyword must be added for extern blocks. Thus, this struct requires that the context satisfies [ContextProvides] for Edition.
FunctionBodyDeclare: Declares a function body. This is equivalent to just a semicolon.
FunctionBodyImplement: Implements a function body. Places the contents inside brackets
FunctionCall: Performs a call to a function inside code.
FunctionDef: A function declaration
FunctionParam: Renders an individual function parameter, Name: Type
FunctionPtr: A function pointer. Can be used for fn, Fn, FnMut, and FnOnce.
ImplOf: Adds an “impl “ before a type expression
LetStmt: A let statement. This statement includes the semicolon and a new line.
Lifetime: A standalone lifetime, intended to be used as a type argument or variable
LifetimedRefOf: Adds a reference with a lifetime before a type expression, i.e. &'<lifetime> <type>
Link: The link attribute.
ModBlock: Declaration of a module block. Renders as mod Mod {Body}.
ModPub: The public modifier
ModUnsafeExtern: The extern modifier, with the ABI selected as the tuple value.
MustUse: The must_use attribute
NamedTuple: A named tuple type.
NoMangle: The no mangle attribute.
OkResultOf: Wraps an expression in Ok(EXPR).
Parameterized: A type argument-parameterized expression. Used in relation to parameterized names and their arguments. Examples: function_name<args>, TypeName<'lifetime, args>, MyType<Assoc=Value>.
QuestionMarkAfter: A question mark following another expression.
RefOf: Adds a “&” before a type expression
StructCall: The construction or deconstruction of a struct.
StructDef: The declaration of a struct.
StructFields: Named struct fields. This will place every field on a new line with a comma afterward. It is recommended that the sequence should pass DeclareField.
TraitDef: The declaration of a trait
TraitImpl: The implementation declaration for a trait, applying to a certain receiver.
Turbofish: Provides access to the “turbofish” syntax, i.e. Name::<Args>. The first tuple value must be writable, and the second must be a sequence.
TypeAsTrait: Uses the as expression to perform a qualified trait cast (ready for a method call). I.e., this will render as <Type as Trait>.
UnsafeBlock: Places the expression inside an unsafe block. Adds new lines inside the brackets, wrapping the inner expression.
UseType: Imports a single type so that it can be used later. Renders as use Type;. Adds a new line after the semicolon.
WithAttributes: Adds attributes to ANY item.

Enums§

Deprecated: The deprecated attribute. The three variants of this enum correspond to the deprecated attribute’s multiple ways of being specified. See: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-deprecated-attribute
Edition: All possible Rust editions. This is the only type in this module meant to be used as context, and not as a writable itself.
FunctionPtrKind: The kind of function type
StructKind: Completes the struct definition as either a named tuple or a struct with named fields.
Target: A cfg condition for targeting an OS, OS family, or architecture. For example:

Traits§

CanHaveAttributes: A writable that can have attributes attached to it

Type Aliases§

UnitType: The unit type, i.e. ()

Module rust

Module rust Copy item path

Structs§

Enums§

Traits§

Type Aliases§

Module rust