class_docstr: This implements a *very* limited decompiler. It only handles cases of
  lambda x: fn(a, b, x, ...)
  where a,b, etc are variables captured from the surrounding scope, and there
  may be some occurrences of x.
  No additional statements or expressions are permitted
code: def visit_FunctionDef(self, node):
      from sys import version_info as python_version
  
      if self.state != self.FUNCTION:
          raise NotImplementedError("Unexpected function")
  
      self.visit(node.args)
  
      self.state = self.INNER_CALL
      if type(node.body) is list:
          next_node = node.body[0]
          # there is this annoying condition in which if there is a doc string,
          # it actually shows up in the ast as a Expr.str
          # so we need to catch that and skip it
          try:
              # Docstrings are constants in Python 3.8 and strings in all other
              # supported Python versions.
              if (
                  python_version.major == 3
                  and python_version.minor >= 8
              ):
                  if (
                      type(next_node) is ast.Expr
                      and type(next_node.value) is ast.Constant
                  ):
                      # this is *probably* a doc string!
                      next_node = node.body[1]
              elif (
                  type(next_node) is ast.Expr
                  and type(next_node.value) is ast.Str
              ):
                  # this is *probably* a doc string!
                  next_node = node.body[1]
          except:
              # just in case the above fails for various reasons like say...
              # there is *only* a doc string. We still fail with the
              # appropriate error
              pass
      else:
          next_node = node.body
  
      if type(next_node) is ast.Call:
          self.visit(next_node)
      elif (
          type(next_node) is ast.Return
          and type(next_node.value) is ast.Call
      ):
          self.visit(next_node.value)
      else:
          raise NotImplementedError(
              "Function must comprise of just a function call "
          )
  
imports: from __future__ import print_function
  from __future__ import division
  from __future__ import absolute_import
  import sys
  import ast
  import inspect
  from ..None import meta
label_desc: Use image node_id 12 for calling the lambda_closure_visitor obj's underlying member method code with example usage: obj.visit_FunctionDef(node) without return types