class_docstr: Defers the construction of another module until the first call.
  
  Deferred can be used to declare modules that depend on computed properties of
  other modules before those modules are defined. This allows users to separate
  the declaration and use of modules. For example at the start of your program
  you can declare two modules which are coupled:
  
  >>> encoder = hk.Linear(64)
  >>> decoder = hk.Deferred(lambda: hk.Linear(encoder.input_size))
  
  Later you can use these naturally (note: that using `decoder` first would
  cause an error since `encoder.input_size` is only defined after `encoder` has
  been called):
  
  >>> x = jnp.ones([8, 32])
  >>> y = encoder(x)
  >>> z = decoder(y)  # Constructs the Linear encoder by calling the lambda.
  
  The result will satisfy the following conditions:
  
  >>> assert x.shape == z.shape
  >>> assert y.shape == (8, 64)
  >>> assert decoder.input_size == encoder.output_size
  >>> assert decoder.output_size == encoder.input_size
code: def __call__(self, *args, **kwargs):
      # pytype: disable=not-callable
      # pylint: disable=not-callable
      return self.target(*args, **kwargs)
  
file_path: dm-haiku/haiku/_src/deferred.py
imports: from collections.abc import Sequence
  from typing import Callable, Generic, TypeVar
  from haiku._src import base
  from haiku._src import module
label_desc: Use image node_id 3 for calling the Deferred obj's underlying member method code with example usage: obj.__call__() and returns: self