标签: predicate

因此,假设我在流上使用了一些随机过滤器,最直接的方法是直接输入谓词:

x.stream().filter(e -> e % 2 == 0)

我也可以简单地做一个参考并提前定义谓词:

Predicate<Integer> isEven = e -> e % 2 == 0;
...
x.stream().filter(isEven)

但我也可以使用一个函数:

private static boolean isEven(Integer integer) {
    return integer % 2 == 0;
}
...
x.stream().filter(MyClass::isEven)

据我所知,谓词当然更有限,而功能可能有副作用等.但由于像Venkat Subramaniam这样的人使用后者的解决方案,我真的很想知道:这里的主要区别是什么？

我想使用std::find函数和谓词(不确定我是否使用正确的单词).这是代码

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class foo {
public:
  typedef pair< int, vector<int> > way;
  typedef pair< int, int > index;
  typedef pair< index, vector<way> > entry;
  vector< entry > table;

  void bar() 
  {
     vector<int> v1;
     v1.push_back(1);
     v1.push_back(2);

     way w = make_pair( 1, v1 );
     vector<way> v2;
     v2.push_back(w);

     index id = make_pair( 10, 20 );
     entry en = make_pair( id, v2 );
     table.push_back( en );
  }
  void insert()
  {
     index new_id = make_pair( …

我有一个需要以特定方式订购的清单.我现在解决了这个问题:

var files = GetFiles()
  .OrderByDescending(x => x.Filename.StartsWith("ProjectDescription_"))
  .ThenByDescending(x => x.Filename.StartsWith("Budget_"))
  .ThenByDescending(x => x.Filename.StartsWith("CV_"))
  .ToArray();

这些文件将合并为一个PDF文件,这里的重点是某些文件应该在开头,而其余文件应该在最后.

我想知道是否有更好的方式来编写这种"模式",因为它感觉相当糟糕,如果有更多的情况会变得更加黯然失色.

我想避免的事情,但不确定如何:多次通过列表,StartsWith每个文件的调用次数超过必要,代码多于必要的等等.

基本上我认为我想要一种OrderByPredicates聪明地满足这些标准的东西,其API的使用方式如下:

var predicates = new Func<boolean, File>[] {
  x => x.Filename == "First"
  x => x.Filename.StartsWith("Foo_"),
  x => x.Filename.StartsWith("Bar_"),
};

var files = GetFiles()
  .OrderByPredicates(predicates)
  .ThenBy(x => x.Filename);

是否有任何理由/参数不实现基于谓词/约束限制其成员的Java集合？

鉴于经常需要这样的功能,我期待它已经在apache-commons或Guava等集合框架上实现.但是,虽然apache确实拥有它,但是Guava 弃用了它的版本,并建议不要使用类似的方法.

该Collection接口契约规定的集合可以,只要它是正确记录放在其元素的所有限制,所以我无法理解为什么有人看守的集合将被劝阻.还有什么其他选择可以确保Integer集合永远不会包含负值而不隐藏整个集合？

您可以将函数指针,函数对象(或boost lambda)传递给std :: sort,以定义要排序的容器元素的严格弱排序.

但是,有时候(足够我已经多次击中这个),你希望能够链接"原始"比较.

如果您正在排序表示联系人数据的对象集合,那么这将是一个简单的例子.有时你会想要排序

last name, first name, area code

first name, last name

age, first name, area code

现在,您当然可以为每个案例编写一个额外的函数对象,但这违反了DRY原则 - 特别是如果每​​个比较都不那么简单.

好像你应该能够写的比较功能的层次 - 水平低的人做单,原始,比较(例如,名字<名字),然后更高层次的人打电话相继较低级别的人(可能与链接&&使用短路评估)来生成复合函数.

这种方法的问题在于std :: sort采用二元谓词 - 谓词只能返回一个bool.因此,如果您正在编写它们,则无法判断"假"是表示相等还是大于.你可以让你的下级谓词返回一个int,具有三种状态 - 但你必须包裹在那些更高级别的谓词,他们可以用的std ::对自己的排序在使用之前.

总之,这些并非不可克服的问题.它似乎比它应该更难 - 并且肯定会邀请一个帮助库实现.

因此,有没有人知道任何预先存在的库(特别是如果它是std或boost库)可以帮助到这里 - 对此事有任何其他想法？

[更新]

正如一些评论中提到的那样 - 我已经开始编写自己的类实现来管理它.它相当小,并且可能在一般情况下存在一些问题.但在此基础上,对于任何有兴趣的人,课程在这里:

http://pastebin.com/f52a85e4f

一些辅助函数(以避免需要指定模板args)在这里:

http://pastebin.com/fa03d66e

我在scala中有以下问题.我必须找到al list中的第一个元素,它满足OR中的两个条件的谓词函数.问题是我想获得元素,但也知道满足了两个条件中的哪一个.这是一个简单的例子:

val l1 = List("A", "B", "AA", "BB")
val l2 = List("AA", "BB", "A", "B")

def c1(s: String) = s.startsWith("B")
def c2(s: String) = s.length == 2

println(l1.find(s => c1(s) || c2(s)))
println(l2.find(s => c1(s) || c2(s)))

结果是:

Some(B)
Some(AA)

对于l1的情况,我希望有一些返回值(例如一个String),表示满足c1(对于l2情况,为c2).一个可能的解决方案可能是在测试之前定义一个var并将其设置在c1和c2函数中,但我想找到一个更"功能样式"的解决方案,也许会返回一个像元组的东西:(元素找到,条件满足).

在此先感谢您的帮助

说,我有元素向量和掩码数组,我想从矢量中提取具有真实对应掩码值的元素来分离向量.有没有办法std::copy_if用于此目的？问题是,我只有谓词中的元素值,而不是它的迭代器,所以我不知道实际索引来解决掩码数组.

我可以直接操作这样的地址:

vector<bool> mask;
vector<int> a, b;
copy_if(a.begin(), a.end(), b.begin(), [&] (int x) -> bool { 
  size_t index = &x - &a[0]; // Ugly...
  return mask[index];
});

但是,我发现这是一个丑陋的解决方案.有更好的想法吗？

更新:另一种可能的解决方案是在掩码上使用外部迭代器:

vector<bool> mask;
vector<int> a, b;
auto pMask = mask.begin();
copy_if(a.begin(), a.end(), b.begin(), [&] (int x) { 
  return *pMask++;
});

但是,此解决方案需要外部命名空间中的附加变量,这仍然是不可取的.

我有一个核心数据库,我正在尝试使用块谓词创建一个获取请求,但是我得到一个未知谓词错误:

注意: employeeToHouse是我在子类化NSManagedObject时为我创建的House类型的属性

NSFetchRequest *request = [NSFetchRequest fetchRequestWithEntityName:@"Place"];
request.predicate       = [NSPredicate predicateWithBlock:^BOOL(id evaluatedObject, NSDictionary *bindings) {
    Place *sortPlace            = (Place *)evaluatedObject;
    CLLocation *placeLocation   = [[CLLocation alloc] initWithLatitude:sortPlace.latitude.doubleValue 
                                                             longitude:sortPlace.longitude.doubleValue];
    CLLocationDistance distance = [placeLocation distanceFromLocation:self.userLocation];
    sortPlace.distanceToUser    = [NSNumber numberWithDouble:distance];
    if(distance<3000)
    {
        return YES;
    }
    return NO;
}];
request.sortDescriptors = [NSArray arrayWithObject:[NSSortDescriptor sortDescriptorWithKey:@ "distanceToUser" 
                                                                                 ascending:YES 
                                                                                  selector:@selector(localizedCaseInsensitiveCompare:)]];

[self.loadingView removeSpinner];
[self setupFetchedResultsControllerWithFetchRequest:request];

然后我得到这个错误:

NSInvalidArgumentException',原因:'谓词的未知谓词类型:BLOCKPREDICATE(0x70ad750)'

难道我做错了什么？

我正在使用PredicateBuilder在我的操作中创建搜索/过滤器部分.这里是:

    [HttpPost]
    public ActionResult Test(int? cty, string inumber, int? page)
    {

        var lstValues =
            db.TableName.Include(x => x.Table1)
                .Include(x => x.Table2)
                .Include(x => x.Table3)
                .ToList();

        var predicate = PredicateBuilder.True<TableName>();

        if (!string.IsNullOrWhiteSpace(inumber))
        {
            predicate = predicate.And(x => x.Inumber == inumber);
        }

        if (!string.IsNullOrWhiteSpace(cty.ToString()))
        {
            predicate = predicate.And(x => x.CtyID == cty);
        }

        if (predicate.Parameters.Count > 0)
        {
            lstValues = db.TableName.AsExpandable().Where(predicate).ToList();
            Session["Paging"] = lstValues;
            ViewBag.Paging = lstValues.ToPagedList(page ?? 1, 2);
            return View(lstValues.ToPagedList(page ?? 1, 2));
        }
        else
        {
            return View(lstValues.ToPagedList(page ?? 1, 2)); …

我的目标是在 TypeScript 中编写满足以下条件的谓词函数（例如）isNull：isUndefined

1. 可以独立使用：array.filter(isNull)
2. 可以逻辑组合：array.filter(and(not(isNull), not(isUndefined)))
3. 使用类型保护，因此 TypeScript 知道 的返回类型array.filter(isNull)将是null[]
4. 组合谓词可以提取到新的谓词函数中，而不会破坏类型推断：const isNotNull = not(isNull)

前两个条件很容易满足：

type Predicate = (i: any) => boolean;

const and = (p1: Predicate, p2: Predicate) =>
    (i: any) => p1(i) && p2(i);

const or = (p1: Predicate, p2: Predicate) =>
    (i: any) => p1(i) || p2(i);

const not = (p: Predicate) =>
    (i: any) => !p(i);

const isNull = (i: any) =>
    i === null;

const isUndefined …