code: def rust_code(expr, assign_to=None, **settings):
      """Converts an expr to a string of Rust code
  
      Parameters
      ==========
  
      expr : Expr
          A SymPy expression to be converted.
      assign_to : optional
          When given, the argument is used as the name of the variable to which
          the expression is assigned. Can be a string, ``Symbol``,
          ``MatrixSymbol``, or ``Indexed`` type. This is helpful in case of
          line-wrapping, or for expressions that generate multi-line statements.
      precision : integer, optional
          The precision for numbers such as pi [default=15].
      user_functions : dict, optional
          A dictionary where the keys are string representations of either
          ``FunctionClass`` or ``UndefinedFunction`` instances and the values
          are their desired C string representations. Alternatively, the
          dictionary value can be a list of tuples i.e. [(argument_test,
          cfunction_string)].  See below for examples.
      dereference : iterable, optional
          An iterable of symbols that should be dereferenced in the printed code
          expression. These would be values passed by address to the function.
          For example, if ``dereference=[a]``, the resulting code would print
          ``(*a)`` instead of ``a``.
      human : bool, optional
          If True, the result is a single string that may contain some constant
          declarations for the number symbols. If False, the same information is
          returned in a tuple of (symbols_to_declare, not_supported_functions,
          code_text). [default=True].
      contract: bool, optional
          If True, ``Indexed`` instances are assumed to obey tensor contraction
          rules and the corresponding nested loops over indices are generated.
          Setting contract=False will not generate loops, instead the user is
          responsible to provide values for the indices in the code.
          [default=True].
  
      Examples
      ========
  
      >>> from sympy import rust_code, symbols, Rational, sin, ceiling, Abs, Function
      >>> x, tau = symbols("x, tau")
      >>> rust_code((2*tau)**Rational(7, 2))
      '8*1.4142135623731*tau.powf(7_f64/2.0)'
      >>> rust_code(sin(x), assign_to="s")
      's = x.sin();'
  
      Simple custom printing can be defined for certain types by passing a
      dictionary of {"type" : "function"} to the ``user_functions`` kwarg.
      Alternatively, the dictionary value can be a list of tuples i.e.
      [(argument_test, cfunction_string)].
  
      >>> custom_functions = {
      ...   "ceiling": "CEIL",
      ...   "Abs": [(lambda x: not x.is_integer, "fabs", 4),
      ...           (lambda x: x.is_integer, "ABS", 4)],
      ...   "func": "f"
      ... }
      >>> func = Function('func')
      >>> rust_code(func(Abs(x) + ceiling(x)), user_functions=custom_functions)
      '(fabs(x) + x.CEIL()).f()'
  
      ``Piecewise`` expressions are converted into conditionals. If an
      ``assign_to`` variable is provided an if statement is created, otherwise
      the ternary operator is used. Note that if the ``Piecewise`` lacks a
      default term, represented by ``(expr, True)`` then an error will be thrown.
      This is to prevent generating an expression that may not evaluate to
      anything.
  
      >>> from sympy import Piecewise
      >>> expr = Piecewise((x + 1, x > 0), (x, True))
      >>> print(rust_code(expr, tau))
      tau = if (x > 0) {
          x + 1
      } else {
          x
      };
  
      Support for loops is provided through ``Indexed`` types. With
      ``contract=True`` these expressions will be turned into loops, whereas
      ``contract=False`` will just print the assignment expression that should be
      looped over:
  
      >>> from sympy import Eq, IndexedBase, Idx
      >>> len_y = 5
      >>> y = IndexedBase('y', shape=(len_y,))
      >>> t = IndexedBase('t', shape=(len_y,))
      >>> Dy = IndexedBase('Dy', shape=(len_y-1,))
      >>> i = Idx('i', len_y-1)
      >>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i]))
      >>> rust_code(e.rhs, assign_to=e.lhs, contract=False)
      'Dy[i] = (y[i + 1] - y[i])/(t[i + 1] - t[i]);'
  
      Matrices are also supported, but a ``MatrixSymbol`` of the same dimensions
      must be provided to ``assign_to``. Note that any expression that can be
      generated normally can also exist inside a Matrix:
  
      >>> from sympy import Matrix, MatrixSymbol
      >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)])
      >>> A = MatrixSymbol('A', 3, 1)
      >>> print(rust_code(mat, A))
      A = [x.powi(2), if (x > 0) {
          x + 1
      } else {
          x
      }, x.sin()];
      """
  
      return RustCodePrinter(settings).doprint(expr, assign_to)
  
imports: from __future__ import annotations
  from typing import Any
  from sympy.core import S, Rational, Float, Lambda
  from sympy.core.numbers import equal_valued
  from sympy.printing.codeprinter import CodePrinter
label_desc: Use image node_id 1 for calling a global function with example usage: rust_code(expr, assign_to) and returns: RustCodePrinter