RustQ.Rust (rustq v0.6.0)

Copy Markdown View Source

Elixir-friendly builders for Rust fragments.

Use this module when generating Rust declarations from data. Builders return small structs or fragments that RustQ can validate and splice into templates.

alias RustQ.Rust

Rust.struct(:User,
  vis: :pub,
  derive: [:Clone, :Debug],
  fields: [Rust.field(:id, :i64, vis: :pub)]
)

Prefer real Rust templates for larger bodies and use these builders for the repetitive edges: fields, function signatures, attributes, type aliases, and simple declarations.

Summary

Types

rust_type()

Functions

arg(function, arg)
arg(function, name, type, opts \\ [])
args(function, args)
arm(code)
arm(pattern, body)
assign(target, expr)
ast_item(ast)
ast_items(asts)
attr(item, attr)
block(lines)
body(function, body)
call_expr(receiver, method, args \\ [])
call_stmt(receiver, method, args \\ [])
cast(value, type)
const(name, type, value, opts \\ [])
derive(item, values)
enum(name, opts \\ [])
expr(code)
field(name, type)
field(name, type, opts)
field(item, name, type, opts)
fields(item, fields)
fn(clauses)

Alias for fn_/2, callable as RustQ.Rust.fn(...).

fn_(name, opts \\ [])
if_(condition, then_lines, opts \\ [])
if_let(pattern, expr, then_lines, opts \\ [])
impl(target, opts \\ [])
impl_item(code)
item(code)
item(impl, item)
items(impl, items)
let_(pattern, expr)
let_mut(pattern, expr)
literal(value)
match_(expr, arms)
mod(name, opts \\ [])
none()
param(name, type)
path(parts)
prelude(atom)
pub(item)
question(value)
raw(code)
ref(value, opts \\ [])
ref_expr(value, opts \\ [])
return_if(condition, value \\ "Ok(())")
returns(function, type)
some(value)
static_slice(value)
stmt(code)
struct(name, opts \\ [])
to_fragment(block)
trait(impl, trait)
tuple(values)
type(value)
type(name, opts)
type_alias(name, type, opts \\ [])
use(path, opts \\ [])
use_many(paths, opts \\ [])
variant(item, variant)
variants(item, variants)
vis(item, visibility)

Types

rust_type()

@type rust_type() :: atom() | String.t() | tuple() | [atom() | String.t()] | struct()

Functions

arg(function, arg)

@spec arg(RustQ.Rust.Function.t(), term()) :: RustQ.Rust.Function.t()
@spec arg(atom() | String.t(), rust_type()) :: RustQ.Rust.Fragment.t()

arg(function, name, type, opts \\ [])

@spec arg(RustQ.Rust.Function.t(), atom() | String.t(), rust_type(), keyword()) ::
  RustQ.Rust.Function.t()

args(function, args)

@spec args(RustQ.Rust.Function.t(), [term()]) :: RustQ.Rust.Function.t()

arm(code)

@spec arm(iodata()) :: RustQ.Rust.Fragment.t()

arm(pattern, body)

@spec arm(iodata(), iodata()) :: RustQ.Rust.Fragment.t()

assign(target, expr)

@spec assign(iodata(), iodata()) :: RustQ.Rust.Fragment.t()

ast_item(ast)

@spec ast_item(term()) :: RustQ.Rust.Fragment.t()

ast_items(asts)

@spec ast_items([term()]) :: [RustQ.Rust.Fragment.t()]

attr(item, attr)

@spec attr(term(), term()) :: term()

block(lines)

@spec block([term()]) :: term()

body(function, body)

@spec body(RustQ.Rust.Function.t(), iodata()) :: RustQ.Rust.Function.t()

call_expr(receiver, method, args \\ [])

@spec call_expr(iodata(), atom() | String.t(), [iodata()]) :: RustQ.Rust.Fragment.t()

call_stmt(receiver, method, args \\ [])

@spec call_stmt(iodata(), atom() | String.t(), [iodata()]) :: RustQ.Rust.Fragment.t()

cast(value, type)

@spec cast(iodata(), iodata()) :: RustQ.Rust.Fragment.t()

const(name, type, value, opts \\ [])

@spec const(atom() | String.t(), rust_type(), term(), keyword()) ::
  RustQ.Rust.Const.t()

derive(item, values)

@spec derive(
  RustQ.Rust.Struct.t() | RustQ.Rust.EnumDecl.t(),
  atom() | String.t() | [atom() | String.t()]
) :: RustQ.Rust.Struct.t() | RustQ.Rust.EnumDecl.t()

enum(name, opts \\ [])

@spec enum(
  atom() | String.t(),
  keyword()
) :: RustQ.Rust.EnumDecl.t()

expr(code)

@spec expr(iodata()) :: RustQ.Rust.Fragment.t()

field(name, type)

@spec field(atom() | String.t(), rust_type()) :: RustQ.Rust.Field.t()

field(name, type, opts)

@spec field(atom() | String.t(), rust_type(), keyword()) :: RustQ.Rust.Field.t()

field(item, name, type, opts)

@spec field(RustQ.Rust.Struct.t(), atom() | String.t(), rust_type(), keyword()) ::
  RustQ.Rust.Struct.t()

fields(item, fields)

@spec fields(RustQ.Rust.Struct.t(), [term()]) :: RustQ.Rust.Struct.t()

fn(clauses)

Alias for fn_/2, callable as RustQ.Rust.fn(...).

fn_(name, opts \\ [])

@spec fn_(
  atom() | String.t(),
  keyword()
) :: RustQ.Rust.Function.t()

if_(condition, then_lines, opts \\ [])

@spec if_(iodata(), [term()], keyword()) :: RustQ.Rust.Fragment.t()

if_let(pattern, expr, then_lines, opts \\ [])

@spec if_let(iodata(), iodata(), [term()], keyword()) :: RustQ.Rust.Fragment.t()

impl(target, opts \\ [])

@spec impl(
  rust_type(),
  keyword()
) :: RustQ.Rust.Impl.t()

impl_item(code)

@spec impl_item(iodata()) :: RustQ.Rust.Fragment.t()

item(code)

@spec item(iodata()) :: RustQ.Rust.Fragment.t()

item(impl, item)

@spec item(RustQ.Rust.Impl.t() | RustQ.Rust.ModDecl.t(), term()) ::
  RustQ.Rust.Impl.t() | RustQ.Rust.ModDecl.t()

items(impl, items)

@spec items(RustQ.Rust.Impl.t() | RustQ.Rust.ModDecl.t(), [term()]) ::
  RustQ.Rust.Impl.t() | RustQ.Rust.ModDecl.t()

let_(pattern, expr)

@spec let_(iodata(), iodata()) :: RustQ.Rust.Fragment.t()

let_mut(pattern, expr)

@spec let_mut(iodata(), iodata()) :: RustQ.Rust.Fragment.t()

literal(value)

@spec literal(term()) :: String.t()

match_(expr, arms)

@spec match_(iodata(), [{iodata(), [term()]}]) :: RustQ.Rust.Fragment.t()

mod(name, opts \\ [])

@spec mod(
  atom() | String.t(),
  keyword()
) :: RustQ.Rust.ModDecl.t()

none()

@spec none() :: RustQ.Rust.Fragment.t()

param(name, type)

@spec param(atom() | String.t(), rust_type()) :: RustQ.Rust.Fragment.t()

path(parts)

@spec path(term()) :: String.t()

prelude(atom)

@spec prelude(atom()) :: [RustQ.Rust.Use.t()]

pub(item)

@spec pub(term()) :: term()

question(value)

@spec question(iodata()) :: RustQ.Rust.Fragment.t()

raw(code)

@spec raw(iodata()) :: RustQ.Rust.Fragment.t()

ref(value, opts \\ [])

@spec ref(
  rust_type(),
  keyword()
) :: String.t()

ref_expr(value, opts \\ [])

@spec ref_expr(
  iodata(),
  keyword()
) :: RustQ.Rust.Fragment.t()

return_if(condition, value \\ "Ok(())")

@spec return_if(iodata(), iodata()) :: RustQ.Rust.Fragment.t()

returns(function, type)

@spec returns(RustQ.Rust.Function.t(), rust_type()) :: RustQ.Rust.Function.t()

some(value)

@spec some(iodata()) :: RustQ.Rust.Fragment.t()

static_slice(value)

@spec static_slice(rust_type()) :: String.t()

stmt(code)

@spec stmt(iodata()) :: RustQ.Rust.Fragment.t()

struct(name, opts \\ [])

@spec struct(
  atom() | String.t(),
  keyword()
) :: RustQ.Rust.Struct.t()

to_fragment(block)

@spec to_fragment(term()) :: String.t()

trait(impl, trait)

@spec trait(RustQ.Rust.Impl.t(), rust_type()) :: RustQ.Rust.Impl.t()

tuple(values)

@spec tuple([iodata()]) :: RustQ.Rust.Fragment.t()

type(value)

@spec type(rust_type()) :: String.t()

type(name, opts)

@spec type(atom() | String.t(), keyword() | [rust_type()]) :: String.t()

type_alias(name, type, opts \\ [])

@spec type_alias(atom() | String.t(), rust_type(), keyword()) ::
  RustQ.Rust.TypeAlias.t()

use(path, opts \\ [])

@spec use(
  term(),
  keyword()
) :: RustQ.Rust.Use.t()

use_many(paths, opts \\ [])

@spec use_many(
  [term()],
  keyword()
) :: [RustQ.Rust.Use.t()]

variant(item, variant)

@spec variant(RustQ.Rust.EnumDecl.t(), term()) :: RustQ.Rust.EnumDecl.t()

variants(item, variants)

@spec variants(RustQ.Rust.EnumDecl.t(), [term()]) :: RustQ.Rust.EnumDecl.t()

vis(item, visibility)

@spec vis(term(), atom() | String.t() | nil) :: term()