Difference between Predicate<T> and Function<T, R> First and foremost a Predicate<T> is strictly a boolean-valued function: _ _ _ _ _ _ _ | | T –> | predicate | –> boolean |_ _ _ _ _ _ _| Whereas this is not necessarily true for a Function<T, R>: _ _ _ _ _ _ … Read more
You would have to do .filter(((Predicate<String>) String::isEmpty).negate()) If you want, you can define static<T> Predicate<T> not(Predicate<T> p) { return t -> !p.test(t); } and then .filter(not(String::isEmpty)) but I would just stick with v -> !v.isEmpty()
.Any(predicate) sounds like what you want; returns bool, returning true as soon as a match is found, else false. There is also: .All(predicate) which behaves in a similar way, returning false as soon as a non-match is found, else true.
You don’t need LinqKit to do this. Just remember to use Expression<Func<MyEntity, bool>> instead of Func<MyEntity, bool> Something like this: public IQueryable<MyEntity> GetAllMatchedEntities(Expression<Func<MyEntity, Boolean>> predicate) { return _Context.MyEntities.Where(predicate); } You have to use Expression because Linq to Entities needs to translate your lambda to SQL. When you use Func your lambda is compiled to IL … Read more
The copy_if algorithm looks something like this(taken from MSVC2010): template<class InIt, class OutIt, class Pr> inline OutIt copy_if(InIt First, InIt Last, OutIt Dest, Pr Pred) { for (; First != _Last; ++First) if (Pred(*_First)) *Dest++ = *First; return (Dest); } And as you can see the copy_if does not do a push_back, it just copy … Read more
The method in Predicate<T> returns boolean. The method in Function<T, Boolean> returns Boolean. They are not the same. Although there is autoboxing, Java methods don’t use wrapper classes when primitives would do. Also, there are differences like Boolean can be null while boolean can’t. It’s even more different in the case of Consumer<T>. The method … Read more
These functions are in the CL package, you will need to (require ‘cl) to use them: (remove-if-not #’evenp ‘(1 2 3 4 5)) This will return a new list with all even numbers from the argument. Also look up delete-if-not, which does the same, but modifies its argument list.
How about: public static Predicate<T> Or<T>(params Predicate<T>[] predicates) { return delegate (T item) { foreach (Predicate<T> predicate in predicates) { if (predicate(item)) { return true; } } return false; }; } And for completeness: public static Predicate<T> And<T>(params Predicate<T>[] predicates) { return delegate (T item) { foreach (Predicate<T> predicate in predicates) { if (!predicate(item)) { … Read more
You can definitely combine predicates in the $filter. For example: /People?$filter=endswith(LastName,’Smith’) and startswith(FirstName,’Mary’) For details around supported operators and such please see this page: http://www.odata.org/documentation/odata-version-2-0/uri-conventions#FilterSystemQueryOption Currently OData doesn’t have a way to express the question “People which have at least one address”. Depending on your data it might be feasible to download all People fulfilling … Read more
A predicate like NSPredicate *predicate = [NSPredicate predicateWithFormat:@”NOT (self IN %@)”, arrayOfExcludedObjects]; where the entity of the fetch request is the entity of objects in the array, should do what you want. This can, of course be combined with other clauses in a single predicate for a fetch request. In general, object comparisons (e.g self … Read more