标签: predicate

我正在阅读"7周内七种语言"的内容,我对Prolog的一些问题感到困惑,因为我不理解'不'的回应.

该friends.pl文件如下所示:

likes(wallace, cheese).
likes(grommit, cheese).
likes(wendolene, sheep).

friend(X, Y) :- \+(X = Y), likes(X, Z), likes(Y, Z).

我可以对它做一些简单的查询,例如:

| ?- ['friends'].
compiling /home/marc/btlang-code/code/prolog/friends.pl for byte code...
/home/marc/btlang-code/code/prolog/friends.pl compiled, 12 lines read - 994 bytes written, 8 ms

yes
| ?- friend(wallace,grommit).

yes
| ?- friend(wallace,wendolene).

no

这一切都符合预期.现在,我想在查询中引入一个变量.我的意图是Prolog会给我一份华莱士所有朋友的名单.我期待X = grommit,但我得到no:

| ?- trace.
The debugger will first creep -- showing everything (trace)

yes
{trace}
| ?- friend(wallace,X).
      1    1  Call: friend(wallace,_16) ?
      2    2 …

我有一个功能:

private IEnumerable<Promotion> MatchesKeyword(IEnumerable<Promotion> list, String keyword)
{
   ...snip...
}

现在执行LINQ查询:

private IEnumerable<Promotion> MatchesKeyword(IEnumerable<Promotion> list, String keyword)
{
   return list.Where(item => item.Name.ContainsText(keyword)
      || item.Description.ContainsText(keyword)
      ...snip...
   );
}

这段代码运行得很好.

但我需要将其转换为使用PredicateBuilder:

private IEnumerable<Promotion> MatchesKeyword(IEnumerable<Promotion> list, String keyword)
{
   var predicate = PredicateBuilder.False<Promotion>();     

   predicate = predicate.Or(item => item.Name.ContainsText(keyword)
         || item.Description.ContainsText(keyword)
         ...snip...
   );

   return list.Where(predicate);
}

奇怪的是,这不会编译.失败的路线是:

return list.Where(predicate);

您可以选择错误:

• 实例参数:无法从'System.Collections.Generic.IEnumerable'转换为'System.Linq.IQueryable'
• 'System.Collections.Generic.IEnumerable'不包含'Where'的定义和最佳扩展方法重载'System.Linq.Enumerable.Where(System.Collections.Generic.IEnumerable,System.Func)'有一些无效的参数
• 参数2:无法从'System.Linq.Expressions.Expression>'转换为'System.Func'

有什么问题？IEnumerable进去,IEnumerable出来.

我会说实话,我读了这个页面PredicateBuilder,我不明白其中任何一个.

一个淡淡的,为什么我需要改变PredicateBuilder …

我正在重构一些代码,发现有两个地方可以使用相同的代码编写,除了一组的比较器less<double>在一个地方而greater<double>在另一个地方.就像是:

double MyClass::Function1(double val)
{
    std::set<double, less<double> > s;
    // Do something with s
}

double MyClass::Function2(double val)
{
    std::set<double, greater<double> > s;
    // Do the same thing with s as in Function1
}

所以我想到了:

double MyClass::GeneralFunction(double val, bool condition)
{  
    if(condition)  
    {  
        // Select greater as comparator  
    }  
    else
    {  
        // Select less as comparator  
    }  

    set<double, comparator> s;  
    // common code
}

我通过使用我的自定义比较器函数使它工作,如下所示:

bool my_greater(double lhs, double rhs)
{
    return lhs > rhs;
} …

"普通"函数通常仅在给定类型的对象域上定义,但某些函数(如Scheme类型谓词list?或procedure?)是为任何类型的参数定义的,甚至可以应用于它们自身.因此,例如(list? procedure?)评估#f和(procedure? procedure?)评估#t.我试图找出如何编写这种完全定义的函数,但未能找到讨论这个的源.

例如,假设我们使用以下构造函数和选择器实现了计算机程序的结构和解释的练习2.4中描述的对数据类型:

    (define (cons x y)
      (lambda (m) (m x y)))

    (define (car z)
      (z (lambda (p q) p)))

    (define (cdr z)
      (z (lambda (p q) q)))

那么我如何定义一个谓词pair?,该谓词返回#t任何使用构造的东西cons,以及#f任何不构造的东西？更一般地,怎么都类型谓词喜欢list?和procedure?实施？

当用户更改页面的哈希值时,我使用window.onhashchange函数执行代码:

window.onhashchange = function() { /* do something */ };

在某些函数中,我还通过JavaScript设置哈希:

window.location.hash = "#abc";

我想通过JavaScript设置哈希时阻止onhashchange事件触发.

到目前为止我尝试了什么:

var currently_setting_hash = false;

window.onhashchange = function() {
  if (currently_setting_hash)
    return;
 //...
}

currently_setting_hash = true;
window.location.hash = "#abc";
currently_setting_hash = false;

这不起作用,因为事件被延迟触发,因此代码将首先设置哈希值,然后将"currently_setting_hash"设置为false,然后执行onhashchange事件.

有什么想法可以实现吗？或者有没有办法检测哈希是由用户还是通过JavaScript设置的？

我正在改变我的一些旧代码以利用Java 8的功能方面.特别是,我正在使用Guava谓词java.util.function.Predicate.其中一个谓词是检查a是否Stream是同质的,即由所有相同的元素组成.

在我的旧代码中(使用Guava Predicate),我有这个:

static <T> Predicate<Iterable<T>> isHomogeneous() {
    return new Predicate<Iterable<T>>() {
        public boolean apply(Iterable<T> iterable) {
            return Sets.newHashSet(iterable).size() == 1;
        }
    };
}

这是新版本,使用java.util.function.Predicate:

public static Predicate<Stream<?>> isHomogeneous =
    stream -> stream.collect(Collectors.toSet()).size() == 1;

IDE(IntellijIDEA v.12)没有显示任何红色波浪线表示错误,但是当我尝试编译时,我得到了这个:

java: no suitable method found for
collect(java.util.stream.Collector<java.lang.Object,capture#1 of ?,java.util.Set<java.lang.Object>>)
  method java.util.stream.Stream.<R>collect(java.util.function.Supplier<R>,java.util.function.BiConsumer<R,? super capture#2 of ?>,java.util.function.BiConsumer<R,R>) is not applicable
    (cannot infer type-variable(s) R
      (actual and formal argument lists differ in length))
  method java.util.stream.Stream.<R,A>collect(java.util.stream.Collector<? super capture#2 of …

我正在使用Java 8 Lambdas,并且在简单的用例方面取得了成功.我来自Java和C#.NET的混合背景,因此我熟悉代码中的lambda.

在我当前的用例中,我试图从一个名为values的Collection中返回一个List.我这样做成功了

values.stream().map(x -> x).collect(Collectors.toList());

相对简单明了.我想做同样的事情,但只从Collection中添加项目,其中项目上的布尔标志设置为true.我认为那会像这样工作

values.stream().map(x -> { if(x.isActive())return ((Model)x);}).collect(Collectors.toList())

但是编译器一直在显示这个错误:Type mismatch: cannot convert from List<Object> to List<Model>我相信编译器应该足够智能,以便从map函数中知道输出类型,并且确实在我原来的简化示例中.这就是为什么我认为这不是最好的方法.

对于.NET堆栈中的任何人来说,C#/ LINQ中的等价物都是

values.Where(x => x.isActive()).ToList();

我知道有很多其他很好的方法可以在没有lambdas的情况下做到这一点,但我想知道如何使用Java Lambdas在Java中实现这一点？

我试图以嵌套的方式将我的数据存储在镶木地板中,并使用地图类型列将复杂对象存储为值.

如果有人可以让我知道过滤器下推是否适用于地图类型的列.例如下面是我的SQL查询 -

`select measureMap['CR01'].tenorMap['1M'] from RiskFactor where businessDate='2016-03-14' and bookId='FI-UK'`

measureMap是一个映射,其键为String,值为自定义数据类型,包含2个属性 - String和另一个String,Double对映射.

我想知道下推是否可以在地图上工作,即如果map有10个键值对,Spark会将整个地图的数据带入memort并创建对象模型,否则它将根据I/O读取的键过滤掉数据水平.

另外我想知道是否有任何方法可以在where子句中指定键,类似于 - 其中measureMap.key ='CR01'？

这是我的代码.

import java.util.stream.Stream;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.function.Predicate;

public class StreamMethod{
    public static void main(String... args){
        List<Integer> data = new ArrayList<Integer>(Arrays.asList(1,2,3,4,5,6,7,8));

        allMatch(data, x -> x < 10);
    }

    public static <T> void allMatch(List<?> list, Predicate<? super T> predicate){
        boolean allSatisfy = list.stream().allMatch(predicate);
        System.out.println(allSatisfy);
    }
}

我收到了错误incompatible types: Predicate<CAP#1> cannot be converted to Predicate<? super CAP#2>.你能帮我解决一下吗？为什么会显示此错误？

然后我也将上面的传递参数更改为

Predicate<Integer> pred= x -> x < 10;
allMatch(data, pred);

但仍面临错误.

我是Java 8的新手,我正试图解决为什么最后一次测试是错误的.

@Test
public void predicateTest() {
    Predicate<Boolean> test1 = p -> 1 == 1;
    Predicate<Boolean> test2 = p -> p == (1==1);

    System.out.println("test1 - true: "+test1.test(true));
    System.out.println("test1 - false: "+test1.test(false));
    System.out.println("test2 - true: "+test2.test(true));
    System.out.println("test2 - false: "+test2.test(false));
}

输出:

test1 - true:true

test1 - false:true

test2 - true:true

test2 - false:false