to extract as a partial?...
162737
def nested
        a.current_page.children.select { |x| nested? x }
         .sort_by { |x| name x }
         .map { |x| link x }
         .join
      end
1258496
def find_partial(*)
      super.tap do |partial|
        raise CellHandling, partial.inspect if CellUtils.cell? partial.inspect
      end
    end
411914
function getPartial(name) {
    if (name in this._partials) {
      return this._partials[name];
    }
    else if (this._parent) {
      return this._parent.getPartial(name);
    }

    throw new Error("Missing partial " + name);
  }
646959
function extract (/* pattern, ...args */) {
    var args = slice.call(arguments, 1);
    var context = this === exports ? null : this;
    var patternFn = getOrCompile(arguments[0]);
    return patternFn.call(context, args, runtime) || null;
  }
604351
function(context, partials, section) {
      var tail = context[context.length - 1];

      if (!isArray(tail)) {
        section(context, partials, this);
        return;
      }

      for (var i = 0; i < tail.length; i++) {
        context.push(tail[i]);
        section(context, partials, this);
        context.pop();
      }
    }
1050680
def _extract_all(node, name, limit_count=None):
    """"""

    seq = []

    for i in range(0, len(node.getElementsByTagName(name))):
        if len(seq) == limit_count:
            break

        seq.append(_extract(node, name, i))

    return seq
491746
def is_partial(self):
        
        self.open()
        part = lvm_vg_is_partial(self.handle)
        self.close()
        return bool(part)
766404
function(func, ctx, partials) {
      var cx = ctx[ctx.length - 1];
      return func.call(cx);
    }
755264
def _my_partial(func, *args, **kwargs):
    
    newobj = partial(func, *args, **kwargs)
    # monkey patch
    newobj.from_string = FloatWithUnit.from_string
    return newobj
17367
def _partial(self):
        """"""
        raw_stdout = self._process.readAllStandardOutput()
        stdout = handle_qbytearray(raw_stdout, self._get_encoding())

        if self._partial_stdout is None:
            self._partial_stdout = stdout
        else:
            self._partial_stdout += stdout

        self.sig_partial.emit(self, stdout, None)
1024093
function invokePartialWrapper(partial, context, options) {
  var env = Handlebars;
  if (options.hash) {
    context = Object.assign({}, context, options.hash);
    if (options.ids) {
      options.ids[0] = true;
    }
  }

  partial = env.VM.resolvePartial.call(env.VM, partial, context, options);
  var result = env.VM.invokePartial.call(env.VM, partial, context, options);

  if (result == null && env.compile) {
    options.partials[options.name] = env.compile(partial, options);
    result = options.partials[options.name](context, options);
  }

  if (result != null) {
    if (options.indent) {
      let lines = result.split('\n');
      for (let i = 0, l = lines.length; i < l; i++) {
        if (!lines[i] && i + 1 === l) {
          break;
        }

        lines[i] = options.indent + lines[i];
      }
      result = lines.join('\n');
    }
    return result;
  }

  throw new Exception('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');
}
112625
private final T extract() {
        T old = buffer[takeIndex];
        buffer[takeIndex] = null;

        if (++takeIndex >= buffer.length)
            takeIndex = 0;

        return old;
    }
771689
def _extract_value(self, value):
        """"""
        return ModelEndpoint._value_map.get(smart_str(value).lower(), value)
712516
function getPartial(attributes) {
        const splitAttr = partition(attributes, (attribute) => attribute.key === 'src');
        const sourcePath = splitAttr[0][0] && splitAttr[0][0].value;
        let file;

        if (sourcePath && fs.existsSync(options.basePath + sourcePath)) {
            file = injectHTML(fs.readFileSync(options.basePath + sourcePath))
        } else if (!sourcePath) {
            gutil.log(`${pluginName}:`, new gutil.PluginError(pluginName, gutil.colors.red(`Some partial does not have 'src' attribute`)).message);
        } else {
            gutil.log(`${pluginName}:`, new gutil.PluginError(pluginName, gutil.colors.red(`File ${options.basePath + sourcePath} does not exist.`)).message);
        }

        return replaceAttributes(file, splitAttr[1]);
    }
65293
function extractParts (str, indexA, indexB) {
	let part = str.substr(indexA, indexB);

	part = part.replace(/</g, '&lt;').replace(/>/g, '&gt;');
	part = part.replace(/\n/g, '<span class="invisible"> \u21A9</span>\n');
	part = part.replace(/\t/g, '<span class="invisible tab">\u2192</span>');
	return part;
}
1159381
def eager_partial_regardless(__fn, *a, **kw):
        
        return (EAGER_PARTIAL_REGARDLESS, (__fn, a, tuple(kw.items())))
1257715
def partial(f, x, i):
    
    result = f(*[AdFloat(x_j, j == i) for j, x_j in enumerate(x)])
    return result.dx