Return the predicate matching the tuple

 @return [Function]

 @api private
13277
def predicate
      header.reduce(Function::Proposition::Tautology.instance) do |predicate, attribute|
        predicate.and(attribute.eq(attribute.call(self)))
      end
    end
783155
function predicate (fn, string) {
  var idx = -1
  var end = string.length
  var out = []
  var buf = ''

  while (++idx < end) {
    if (fn(string[idx], idx) === true) {
      if (buf) out.push(buf)
      buf = ''
    } else {
      buf += string[idx]
    }
  }

  if (buf) out.push(buf)
  return out
}
668802
def any(self, func):
        
        return any([func(k, v) for k, v in self.items()])
551455
function or(f, g) {
  if(!(isPredOrFunc(f) && isPredOrFunc(g))) {
    throw new TypeError(
      'or: Preds or predicate functions required for first two arguments'
    )
  }

  return x =>
    !!(predOrFunc(f, x) || predOrFunc(g, x))
}
995869
def matches(self, event):
        '''
        
        '''
        ret = []
        self._matches(event, set(), ret)
        return tuple(r[0] for r in ret)
1048311
public final <U2> Tuple3<T1, U2, T3> map2(Function<? super T2, ? extends U2> function) {
        return Tuple.tuple(v1, function.apply(v2), v3);
    }
363921
function _parse_predicate_key(Type, opts, key) {
	opts = opts || {};

	debug.assert(key).is('string');

	if(key[0] !== '$') {
		var datakey = get_predicate_datakey(Type);
		//return new Predicate( "json_extract_path("+datakey+", '"+JSON.stringify([key])+"'::json->>0)::text", [], {'datakey': datakey, 'key': key});
		return new Predicate( parse_keyref_json(datakey, key), [], {'datakey': datakey, 'key': key});
	}

	var _key = key.substr(1);

	if( (opts.epoch === true) && ( (key === '$created') || (key === '$modified') ) ) {
		//return new Predicate("to_json(extract(epoch from "+_key+")*1000)", [], {'key':_key});
		return new Predicate("extract(epoch from "+_key+")*1000", [], {'key':_key});
	}

	if(key === '$documents') {
		var traits = (opts && opts.traits) || {};
		var documents = (traits && traits.documents) || [];
		debug.assert(documents).is('array');
		return new Predicate("get_documents(row_to_json("+(Type.meta.table)+".*), $::json)", [
			JSON.stringify(parse_predicate_document_relations(Type, documents, traits))
		], {'key':_key});
	}

	return new Predicate(_key, [], {'key':_key});
}
333310
function createPredicateFn(expression, comparator, matchAgainstAnyProp) {
  var predicateFn;

  if (comparator === true) {
    comparator = equals;
  } else if (!isFunction(comparator)) {
    comparator = function(actual, expected) {
      if (isObject(actual) || isObject(expected)) {
        // Prevent an object to be considered equal to a string like `'[object'`
        return false;
      }

      actual = lowercase('' + actual);
      expected = lowercase('' + expected);
      return actual.indexOf(expected) !== -1;
    };
  }

  predicateFn = function(item) {
    return deepCompare(item, expression, comparator, matchAgainstAnyProp);
  };

  return predicateFn;
}
128302
def predicates(G: Graph, n: Node) -> Set[TriplePredicate]:
    
    return predicatesOut(G, n) | predicatesIn(G, n)
254061
function parseArgumentList() {
                    var token, expr, args = [];

                    while (true) {
                        expr = parseExpression();
                        if (typeof expr === 'undefined') {
                            break;
                        }
                        args.push(expr);
                        token = lexer.peek();
                        if (!matchOp(token, ',')) {
                            break;
                        }
                        lexer.next();
                    }

                    return args;
                }
823754
function (obj, f) {
      var r = {};
      each(obj, function (x, i) {
        var tuple = f(x, i, obj);
        r[tuple.k] = tuple.v;
      });
      return r;
    }
35665
def kids(tup_tree):
    
    k = tup_tree[2]
    if k is None:
        return []
    # pylint: disable=unidiomatic-typecheck
    return [x for x in k if type(x) == tuple]
1053564
public static Predicate<Tuple2<Context<?>, Boolean>> onlyMismatches() {
        return new Predicate<Tuple2<Context<?>, Boolean>>() {
            public boolean apply(Tuple2<Context<?>, Boolean> tuple) {
                return !tuple.b;
            }
        };
    }
1215154
def find(template)
      bin_for_find(template).find do |tuple|
        tuple.alive? && template.match(tuple)
      end
    end
189704
def any(self, predicate):
        
        if predicate is None:
            raise NullArgumentError(
                u"predicate lambda expression is necessary")
        return self.where(predicate).count() > 0
1181527
function getCleanTrigramTuplesAsDictionary(tuples) {
  var index = tuples.length
  var dictionary = {}
  var tuple

  while (index--) {
    tuple = tuples[index]
    dictionary[tuple[0]] = tuple[1]
  }

  return dictionary
}
378152
def get_tuple(nuplet, index, default=None):
    
    if nuplet is None:
        return default
    try:
        return nuplet[index]
    except IndexError:
        return default