小编vas*_*ily的帖子

我有很多类来自供应商,他们喜欢在属性访问上随机抛出RuntimeExceptions.

public Object getSomeProperty() {
    if (!someObscureStateCheck()) {
        throw new IllegalStateExcepion();
    }
    return calculateTheValueOfProperty(someRandomState);
}

我无法更改类,无法添加注释,为每个类定义mixins是不现实的,因为堆栈的这一部分经常变化.

如果杰克逊的getter抛出异常,我如何让杰克逊忽略一个属性？

我们希望从少数可用的AWS区域提供大量视频文件.目标受众来自全球多个地点.连接速度无法保证.因此绝对需要CDN(最好是CloudFront).

视频需要受到保护,因此只有在用户通过身份验证并有权查看这些视频后才能播放.显然,谁可以看到什么和什么时候是应用程序的一部分的逻辑.从原点流式传输视频会慢得令人无法接受.使视频公开且可缓存也不是一种选择.

人们如何解决这类问题？

我使用 ANTLR4 将一种语言翻译成另一种语言。例如，当我读取数字文字时，我可以返回Integeror Double。

@Override
public Integer visitIntegerValue(Parser.IntegerValueContext ctx) {
    return Integer.valueOf(ctx.getText());
}

@Override
public Double visitDoubleValue(Parser.DoubleValueContext ctx) {
    return Double.valueOf(ctx.getText());
}

最终，如果您进一步扩展此方法并引入其他构造（例如字符串和条件），则对于访问者来说唯一合理的类型是class Visitor extends BaseVisitor<Object>，但它会导致代码大量添加instanceof. 例如

@Override
public CollectionQuery visitCondition(Parser.ConditionContext ctx) {
    Property property = (Property) visit(ctx.property());
    String operator = (String) visit(ctx.operator());
    Object value = visit(ctx.amount());
    Object condition;
    if (value instanceof String && operator.equals("$regex")) {
        condition = Pattern.compile((String) value, Pattern.CASE_INSENSITIVE);
    }
    ...
}

虽然我不介意这种“动态性”，但我想知道这是否是一种可维护的继续方式，或者是否应该使用其他技术，例如创建目标语言结构的适当层次结构。

我有一个具有多种口味的应用程序。资产是特定于风格的，我正在寻找一种方法来过滤掉不适用于当前风格的资产。目前的结构看起来像

assets
  flavour1
    image.jpg
  flavour2
    image.jpg

换句话说，如何确保在编译时flavour1资产文件夹被截断为

assets
  flavour1
    image.jpg

我将我的解决方案与haskell.org http://www.haskell.org/haskellwiki/Euler_problems/31_to_40上发布的解决方案进行了比较, 并且不知道该怎么想.我写的是非惯用的,平均的haskell开发人员会立即将我的代码弹射到月球上吗？

main =
  print $ length $ split 200

split n = split' [200, 100, 50, 20, 10, 5, 2, 1] n
  where split' (1:[]) n = [take n $ repeat 1]
        split' (c:cs) n
          | n > c     = map (c:) (split' (c:cs) (n - c)) ++ split' cs n
          | n == c    = [[c]] ++ split' cs n
          | otherwise = split' cs n

来自"企业"的发展我有点直接和愚蠢的解决方案,但另一方面也许每个人都可以阅读单线,我只需要拿起我的游戏？你会建议压缩代码作为练习,还是仅仅针对黑客？

我正在尝试让ElasticSearch在Elastic Beanstalk环境中运行.使用Docker镜像,在负载平衡环境中运行一个实例非常简单.但是,当我尝试向群集添加更多实例时,它们无法发现彼此,并且每个新实例都成为new_master.

我Dockerfile看起来像以下

FROM dockerfile/java:oracle-java8
RUN ... # Downloading and installing ElasticSearch
RUN /elasticsearch/bin/plugin install elasticsearch/elasticsearch-cloud-aws/2.5.0
VOLUME ["/data"]
ADD config/elasticsearch.yml /elasticsearch/config/elasticsearch.yml
WORKDIR /data
CMD ["/elasticsearch/bin/elasticsearch"]

EXPOSE 9200

配置config/elasticsearch.yml如下所示:

cluster:
  name: elastic-env-dev
cloud:
  aws:
    region: ap-southeast-2
discovery:
  type: ec2
  ec2:
    tag:
      Name: elastic-env-dev
    ping_timeout: 120s

EB环境的名称是elastic-env-dev.

本页上的练习09 http://www.ic.unicamp.br/~meidanis/courses/mc336/2009s2/prolog/problemas/要求创建一个谓词,将重复的元素打包到子列表中.

一个直截了当的解决方案很简单

pack([], []).
pack([H|T], [I|U]) :-
    split(H, T, I, P),
    pack(P, U).

split split(Head, Tail, HeadGroup, Rest)的定义为

split(A, [], [A], []).
split(A, [B|T], [A], [B|T]) :- A \= B.
split(A, [A|T], [A|U], B) :- split(A, T, U, B).

工作正常,几乎与上述网页上提供的示例解决方案一致.

这个解决方案失败的地方是查询pack(X, [[a], [b, b]])..2个解集之间的对应关系是双射(对于每个A在pack(A, B)有一个且只有一个B),所以必须有一个更好的解决方案.

解决它的一种方法是改变评估的顺序,帮助prolog根据参数的类型选择非无限分支,如下所示

pack([], []).
pack(A, B) :-
  ( var(A) ->
    A = [H|T],
    B = [I|U],
    pack(P, U),
    split(H, T, I, P)
  ; A = …

我试图将 的值绑定query到视图中的搜索框SwiftUI。

class DataSet: ObservedObject {

... 

@Published var query: String = ""

init() {
    let sub = AnySubscriber<String, Never>(
        receiveSubscription: nil,
        receiveValue: { query in
            print(query)
            return .unlimited
        })
    self.$query.subscribe(sub)
}

...
}

当用户更改 的值时，query我想过滤我的ObservedObject. 然而，我在文档中找不到如何订阅query属性更改的任何地方。

这可能是一个函数的最简单的实现,它返回Prolog中列表的长度

count([], 0).
count([_|B], T) :- count(B, U), T is U + 1.

关于Prolog的一件事我仍然无法理解,那就是使用变量作为参数的灵活性.

所以例如我可以跑步count([a, b, c], 3).和得到true.我也可以跑步count([a, b], X).并得到答案X = 2..奇怪(至少对我而言)是我还可以运行count(X, 3).并获得至少一个结果,这看起来像X = [_G4337877, _G4337880, _G4337883] ;解释器消失在无限循环之前.我甚至可以运行一些真正"灵活"的东西,count(X, A).并且得到X = [], A = 0 ; X = [_G4369400], A = 1.,这显然是不完整的,但不知何故真的很好.

因此,我的多方面问题.我可以以某种方式向Prolog解释在执行时不要超越第一个结果count(X, 3).吗？我可以以某种方式让Prolog为其生成任意数量的解决方案count(X, A).吗？我可以产生什么样的解决方案？这个特定的谓词是什么阻止我为所有可能的查询生成所有解决方案？

试图从http://www.ic.unicamp.br/~meidanis/courses/mc336/2009s2/prolog/problemas/解决练习 07

我从一个看起来像下面的迭代开始

my_flatten1([], []).
my_flatten1([[A|T]|U], [A|V]) :-
   append(T, U1, V),
   my_flatten1(U, U1).
my_flatten1([A|T], [A|U]) :-
   not(is_list(A)),
   my_flatten1(T, U).

is_flat(A) :-
   my_flatten1(A, A).

它似乎适用于以下一组查询

my_flatten1([a, [b, [c, d], e]], X).
my_flatten1(X, [a, b, c]).
my_flatten1(X, [a|T]).
my_flatten1(X, [a, b, A]).
my_flatten1([a, X], M).
my_flatten1([a|X], M).

is_flat([a|X]).
is_flat([a,[c]|X]).
is_flat([F,[c]|X]).

my_flatten1(A, B).
my_flatten1([A], B).
my_flatten1([[A]], B).
my_flatten1([[a|A]], B).
my_flatten1([a|A], B).
my_flatten1([X|B], [1,2,3,4]).
my_flatten1([[a,c|D]|X], [a|B]).

但是我没有成功地my_flatten基于my_flatten1. 总会有一些查询失败或以无限循环结束，或者只产生一个最明显的结果。

编辑以澄清我所追求的内容，例如我可以my_flatten1使用变量作为第一个参数调用以分配括号：

?- my_flatten1(X, [a, b]).
X = [[a], …