The first argument is assumed to be the ``key`` for routing.
426378
def _route(self, attr, args, kwargs, **fkwargs):
        

        key = get_key(args, kwargs)

        found = self._hash.get_node(key)

        if not found and len(self._down_connections) > 0:
            raise self.HostListExhausted()

        return [i for i, h in self.cluster.hosts.iteritems()
                if h.identifier == found]
1202383
function(router, pathname, handler, msg_, preMsg, msg2) {

const msg = (msg2 && ` ${msg2}`) || (msg_ && `@${msg_}`) || '';

if (msg) {
  console.log(`${pad(preMsg, 35)} ${lpad(pathname,55)} ${msg}`);
}

  router.addRoute(pathname, function(req, res, params) {

    if (getDumpReqVerbosity() > 0) {
      dumpReq(req, res, `--------vvvvv\n${msg2} handling`, {skipBody:true, verbosity:getDumpReqVerbosity(), postMsg: '------^^^^^'});
    }

    return handler.apply(this, arguments);
  });
}
858623
def router(name, args, kwargs, options, task=None, **kw):
    '''
    
    '''
    # Fetch task by name if necessary
    task = task or celery.tasks.get(name)
    if not task:
        return
    # Single route param override everything
    if task.route:
        queue = task.route.split('.', 1)[0]
        return {'queue': queue, 'routing_key': task.route}
    # queue parameter, routing_key computed if not present
    if task.default_queue:
        key = task.default_routing_key
        key = key or '{0.default_queue}.{0.name}'.format(task)
        return {'queue': task.default_queue, 'routing_key': key}
    # only routing_key, queue should not be returned to fallback on default
    elif task.default_routing_key:
        return {'routing_key': task.default_routing_key}
817036
def first_key(lines):  # type: (List[str]) -> str
    
    for line in lines:
        if line.startswith('#'):
            continue
        if any(line.startswith(quote) for quote in QUOTES):
            return line[1:]
        return line
    else:
        return ''
925338
function assertKeys (routes) {
  Object.keys(routes).forEach(function (route) {
    assert.ok(meths.indexOf(route) !== -1, route + ' is an invalid method')
  })
}
1147653
def first(opts={})
      sq = Tripod::SparqlQuery.new(self.as_query(opts))
      first_sparql = sq.as_first_query_str
      self.resource_class._resources_from_sparql(first_sparql).first
    end
1029014
def first(dmap_data, *path):
    """"""
    if not (path and isinstance(dmap_data, list)):
        return dmap_data

    for key in dmap_data:
        if path[0] in key:
            return first(key[path[0]], *path[1:])

    return None
679351
def pass_key(f):
    
    @func(nargs=1, nouts=1)
    def wrapper(k, v):
        return (k, f(v))
    return wrapper
710542
Rule Key() {
		return FirstOf(
			SequenceS(KeyDef(),
					OptionalS(SequenceS(
							OptionalS(suppr(WSPS())),
							Clef()
					)),
					OptionalS(Parameters())
			),
			Clef(),
			String("HP"),
			String("Hp")
		).label(Key);
	}
99206
function Entry(key, val, index) {
    this.key = key;
    this.val = val;
    this.index = index;
  }
137765
def push(self, proxy, key, attribute, relation_operation):
        
        node = TraversalPathNode(proxy, key, attribute, relation_operation)
        self.nodes.append(node)
        self.__keys.add(key)
403781
function provide(nucleus, key, provider) {
		provider(preventMultiCall(function (result) {
			set(nucleus, key, result);
		}));
	}
408483
def _key(self):
        
        return (self.start_key, self.start_inclusive, self.end_key, self.end_inclusive)
707844
public static <K, V> V first( NavigableMap<K, V> map ) {
        return map.firstEntry().getValue();
    }
1235680
def prepare_key(action, options = {})
      (
        options[:key] ||
        self.activity_key ||
        ((self.class.name.underscore.gsub('/', '_') + "." + action.to_s) if action)
      ).try(:to_s)
    end
1307258
def key_for_primary
        @_key_for_primary ||= if options[:as]
          options[:as]
        else
          controller_name = controller.controller_name
          (resource.respond_to?(:each) ? controller_name : controller_name.singularize).intern
        end
      end
731948
function adaptForRouter(val, key) {
  key = key.split(/\s+/);
  if (typeof val === 'string' || typeof val === 'function' || Array.isArray(val)) {
    val = {
      path: key[0],
      method: key[1],
      controller: val
    };
  } else if (typeof val === 'object') {
    if (!val.path) {
      val.path = key[0];
    }
    if (!val.method) {
      val.method = key[1];
    }
  } else {
    throw new Error(`Problem with route "${key}"`);
  }
  return val;
}