标签: any

我想编写一个Prolog程序来查找两个列表的相等性,其中元素的顺序
无关紧要.所以我写了以下内容:

del(_, [], []) .
del(X, [X|T], T).  
del(X, [H|T], [H|T1]) :-
   X \= H,
   del(X, T, T1).

member(X, [X|_]).  
member(X, [_|T]) :- 
   member(X, T).

equal([], []).  
equal([X], [X]).  
equal([H1|T], L2) :-
   member(H1, L2),
   del(H1, L2, L3),
   equal(T, L3).  

但是当我提供输入时equal([1,2,3],X).,它并没有显示所有可能的值X.相反,程序挂在中间.可能是什么原因？

我想为我的项目创建一个这样的方法:

func print(obj: AnyObject) {
    if let rect = obj as? CGRect {
        println(NSStringFromCGRect(rect))
    }
    else if let size = obj as? CGSize {
        println(NSStringFromCGSize(size))
    }

    //...
}

但我不能因为CGRect和CGSize是structS和不符合AnyObject protocol.那么,关于如何做到这一点的任何想法？

使用kotlin和retrofit2时遇到问题，kotlin的通用参数被转换为通配符（？），但在Java中却没有。

现在，我需要Map<String, Object>在Java中使用一个参数（键是String类型，值不固定），将其转换为kotlin代码是Map<String, Any>。

但是改造对它们的处理方式有所不同。

Map<String, Object>在Java中被编译成[java.util.Map<java.lang.String, java.lang.Object>]，并且可以正常工作。

Map<String, Any>在kotlin中将其编译为[java.util.Map<java.lang.String, ?>]，则retrofit2 抛出parameterError（参数类型不得包含类型变量或通配符）。

1？改装相关代码

public ServiceMethod build() {
    ……
    for (int p = 0; p < parameterCount; p++) {
        Type parameterType = parameterTypes[p];
        if (Utils.hasUnresolvableType(parameterType)) {
            throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s", parameterType);
        }
        ……
    }
    ……
}

Utils.hasUnresolvableType（parameterType）方法的引用如下

final class Utils {
    ……
    static boolean hasUnresolvableType(Type type) {
        ……
        if (type instanceof WildcardType) …

Python 中的逻辑运算符是惰性的。具有以下定义：

def func(s):
    print(s)
    return True

呼叫or接线员

>>> func('s') or func('t')
's'

只计算第一个函数调用，因为or识别表达式计算为 True，而不管第二个函数调用的返回值。and行为类似。

但是，当以下列方式使用any()（类比：）时all()：

>>> any([func('s'), func('t')])
's'
't'

所有函数调用都会被评估，因为在any开始迭代其项目的布尔值之前，首先构造内部列表。当我们省略列表构造而只写时，也会发生同样的情况

>>> func('s') or func('t')
's'

这样，我们失去的力量any是短路，它只要迭代的第一个元素是truish打破该装置。如果函数调用代价高昂，那么预先评估所有函数是一个很大的损失，并且浪费了any. 从某种意义上说，人们可以将其称为 Python 陷阱，因为对于尝试利用 的此功能的用户来说可能出乎意料any，并且any通常被认为只是链接一系列or语句的另一种语法方式。但any只是短路，而不是懒惰，这就是这里的区别。

any正在接受一个 iterable。因此，应该有一种创建迭代器的方法，该迭代器不会预先评估其元素，而是将未评估的元素传递给any并让它们any仅在内部评估，以实现完全懒惰的评估。

所以，问题是：我们如何使用any真正的惰性函数评估？这意味着：我们如何制作一个any可以消费的函数调用迭代器，而无需预先评估所有函数调用？

我在 TypeScript 上遇到了一个奇怪的问题。我最近了解了void ...operator，因为我需要应用它所以eslint不会报告no-floating-promises。然而，这个特定的代码片段以某种方式导致了我无法在 TypeScript Playground 上重现的问题：

class A {

  async a() {}

  async onTickAsync(repeat: boolean) {
    try {
      await this.a();
    } catch(e) {
      console.error(e);
    } finally {
      if (repeat) {
        window.setTimeout(() => void this.onTickAsync(true), 200);
      }
    }
  }

}

VS Code 会报这个错误：

TS7011：缺少返回类型注释的函数表达式隐式具有“any”返回类型。

但是，该问题在TS Playground上无法重现。VS Code 和 Playground 都使用 TypeScript 4.5.4。这是我的tsconfig.json：

class A {

  async a() {}

  async onTickAsync(repeat: boolean) {
    try {
      await this.a();
    } catch(e) { …

我尝试在 Go 中使用泛型，但我不太明白何时使用anyorcomparable作为类型参数。有人可以帮助理解这些吗？

我正在为C中的列表实现简单的库,我在编写find函数时遇到了问题.

我希望我的函数接受任何类型的参数来查找,和: find(my_list, 3)和find(my_list, my_int_var_to_find). 我已经掌握了列表元素类型的信息.

现在我已经找到了几种解决这个问题的方法:

• 带有不同类型后缀的不同功能:int findi(void* list, int i),int findd(void* list, double d)- 但我不喜欢这种方法,对我来说似乎是冗余,而且API令人困惑.

• 使用联盟:

  typedef union {
     int i;
     double d;
     char c;
     ...
  } any_type;
  

  Run Code Online (Sandbox Code Playgroud)

  但是这样我强迫用户既知道了any_typeunion,又在调用之前创建它find.我想避免这种情况.

• 使用可变函数:int find(void* list, ...).我喜欢这种方法.但是,我担心没有对参数数量的限制.用户可以自由写,int x = find(list, 1, 2.0, 'c')虽然我不知道它应该是什么意思.

我也看到了这个问题的答案:C:为一个函数参数发送不同的结构,但它无关紧要,因为我想接受非指针参数.

处理此功能的正确方法是什么？

例如,Exception.allCatch定义为

def allCatch[T]: Catch[T] 

为什么不呢

val allCatch: Catch[Nothing]

什么时候Catch它的论证是协变的？

或者,为什么PartialFunction对象定义

def empty[A, B]: PartialFunction[A, B] 

而不仅仅是

val empty: PartialFunction[Any,Nothing]

？

更新:到目前为止似乎答案错过了重点.因此,请在答案中包含一个真正针对问题的具体示例.例如:显示一段可以使用def empty[A, B]: PartialFunction[A, B]但不起作用(或不太方便)的代码val empty: PartialFunction[Any,Nothing].

我有一个DataFrame,我想检查一列的任何值(v)是否满足x<=v<=y.

equal = any(df['columnX'] == value) # No problems here
in_between = any(x <= df['columnX'] <= y) # ValueError :/

我得到的错误是ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all(). 但我any()已经在使用了!

那么这里的问题是什么？为什么它适用==但不适用x<=v<=y？

我想探索如何使用std::any而不是 void * 或此类构造进行消息传递。所以我创建了一个示例代码来测试这个 - 见下文。

std::any 的使用看起来不错，但我想切换类型以检查 std::any 是哪种类型。这可能是不可能的，而且我知道我可以使用 if/elseif... 块来代替，但是如果我可以创建一个 switch 语句，以便我在具有 10-20 种不同类型的实际代码中使用它，那就太好了它会更具可读性。

#include <string>  
#include <iostream>  
#include <sstream>  
#include <any>  
#include <typeindex>  

struct ints { int a{1}; int b{2}; };
struct strings { std::string a{"string1"}; std::string b{"string2"}; };

void send_msg(std::any item)
{
    switch (item.type().hash_code())       // <------- HERE
    {
        case typeid(ints).hash_code():     // <------- HERE
            std::cout << "ints" << std::endl;
            break;
        case typeid(strings).hash_code():
            std::cout << "strings" << std::endl;
            break;
        default:
            std::cout << "unknown type\n";
    }
} …