code: def transparent_lift_with_state(
      init_fn: Callable[..., tuple[hk.Params, hk.State]],
      *,
      allow_reuse: bool = False,
  ) -> tuple[
      Callable[..., tuple[hk.Params, hk.State]], LiftWithStateUpdater
  ]:
      r"""Registers params and state in an outer transform without adding scope.
  
      Functionally this is equivalent to :func:`lift_with_state`\ but without
      automatically adding an additional variable scoping.
  
      See :func:`lift_with_state`\ for more context on when to use
      ``lift_with_state``.
  
      Args:
        init_fn: The ``init`` function from an :class:`TransformedWithState`\.
        allow_reuse: Allows lifted parameters and state to be reused from the outer
          :func:`transform_with_state`\ . This can be desirable when e.g. within
          control flow (e.g. ``hk.scan``).
  
      Returns:
        A callable that during ``init`` injects parameter values into the outer
        context and during ``apply`` reuses parameters from the outer context. In
        both cases returns parameter values to be used with an ``apply`` function.
        The ``init`` function additionally returns an object used to update the
        outer context with new state after ``apply`` is called.
  
      See also:
        - :func:`lift`: Register params with an outer transform.
        - :func:`lift_with_state`: Register params and state with an outer
          transform.
        - :func:`transparent_lift`: Register params with an outer transform
          without a namespace.
      """
  
      base.assert_context("lift_with_state")
      params_and_state_fn = _to_callable(
          LiftingModule(
              init_fn, transparent=True, allow_reuse=allow_reuse
          )
      )
      name = base.current_name() if base.current_module() else None
      updater = LiftWithStateUpdater(name)
      return params_and_state_fn, updater
  
imports: from collections.abc import Mapping, MutableMapping
  import functools
  from typing import Any, Callable, Optional, TypeVar
  from haiku._src import base
  from haiku._src import data_structures
  from haiku._src import module
  from haiku._src import transform
  from haiku._src.typing import LiftingModuleType
label_desc: Use image node_id 9 for calling a global function with example usage: transparent_lift_with_state(init_fn) and returns: params_and_state_fn,  updater