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 = snt.Linear(64)
      >>> decoder = snt.Deferred(lambda: snt.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 = tf.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
docstr: Returns the target module.
  
  If the constructor has not already run this will trigger construction.
  Subsequent calls to `target` will return the same instance.
  
  Returns:
    A `Module` instance as created by `self.constructor()` .
code: def target(self):
      """Returns the target module.
  
      If the constructor has not already run this will trigger construction.
      Subsequent calls to `target` will return the same instance.
  
      Returns:
        A `Module` instance as created by `self.constructor()` .
      """
      if self._target is None:
          self._target = self._constructor()
          self._constructor = None
      return self._target
  
file_path: sonnet/sonnet/src/deferred.py
imports: from sonnet.src import base
label_desc: Use image node_id 2 for calling the Deferred obj's underlying member method code with example usage: obj.target() and returns: self