小编Dan*_*ons的帖子

我有两个功能相同的查询.其中一个表现很好,另一个表现很差.我没有看到性能差异出现在哪里.

查询#1:

SELECT id 
FROM subsource_position
WHERE
  id NOT IN (SELECT position_id FROM subsource)

这回来了以下计划:

                                  QUERY PLAN                                   
-------------------------------------------------------------------------------
 Seq Scan on subsource_position  (cost=0.00..362486535.10 rows=128524 width=4)
   Filter: (NOT (SubPlan 1))
   SubPlan 1
     ->  Materialize  (cost=0.00..2566.50 rows=101500 width=4)
           ->  Seq Scan on subsource  (cost=0.00..1662.00 rows=101500 width=4)

查询#2:

SELECT id FROM subsource_position
EXCEPT
SELECT position_id FROM subsource;

计划:

                                           QUERY PLAN                                            
-------------------------------------------------------------------------------------------------
 SetOp Except  (cost=24760.35..25668.66 rows=95997 width=4)
   ->  Sort  (cost=24760.35..25214.50 rows=181663 width=4)
         Sort Key: "*SELECT* 1".id
         ->  Append  (cost=0.00..6406.26 rows=181663 width=4)
               ->  Subquery Scan …

我试图了解如何在Haskell中使用iteratee库.到目前为止,我所看到的所有文章似乎都专注于建立一个如何构建迭代的直觉,这是有帮助的,但现在我想要下来并实际使用它们,我觉得有点海上.查看iteratees的源代码对我来说价值有限.

假设我有这个函数修剪一行的尾随空格:

import Data.ByteString.Char8

rstrip :: ByteString -> ByteString
rstrip = fst . spanEnd isSpace

我想做的是:将它变成一个iteratee,读取一个文件并将其写在其他地方,并从每一行中删除尾随空格.我将如何使用iteratees进行结构化？我看到有一个enumLinesBS在Data.Iteratee.Char功能,我可以下探到这一点,但我不知道我是否应该使用mapChunks或convStream或如何重新包装上面的功能于iteratee.

我正在解析一个由一系列行组成的相当简单的文件格式,每行都有一些空格分隔的字段,如下所示:

l 0x9823 1
s 0x1111 3
l 0x1111 12
?

我正在使用SWI-Prolog.这是我到目前为止的DCG:

:- consult(library(pure_input)).

load_trace(Filename, Traces) :-
    phrase_from_file(trace_file_phrase(Traces), Filename).

trace_file_phrase([]) --> [].
trace_file_phrase([T|Ts]) --> trace_phrase(T), trace_file_phrase(Ts).

trace_phrase(access(Type, Address, SinceLast)) -->
    access_type(Type), space,
    address(Address),  space,
    nat(SinceLast),    newline.

access_type(load)  --> "l".
access_type(store) --> "s".

address(Number) --> "0x", hexnum(Number).

hexdigit(N)  --> digit(N).
hexdigit(10) --> "a". hexdigit(11) --> "b". hexdigit(12) --> "c".
hexdigit(13) --> "d". hexdigit(14) --> "e". hexdigit(15) --> "f".
hexnum(N) --> hexdigit(D), hexnum(D, N).
hexnum(N, N) --> [].
hexnum(A, N) --> hexdigit(D), …

我正在帮助一个朋友学习Haskell,他最近创建了这样的代码,它在运行时进行类型检查并生成一个CPU刻录循环.我完全被这个困惑了.

import Control.Monad
import Control.Applicative

main = forever putStrLn "Hello, infinity"

这不应该键入检查,但确实如此.正确的版本显然是:

main = forever $ putStrLn "Hello, infinity"

令我感到奇怪和惊讶的是,无论是否导入Control.Applicative,您都会获得不同的结果.没有导入它,它不会键入检查:

Prelude Control.Monad> forever putStrLn "Hello, infinity"

<interactive>:1:1:
    No instance for (Monad ((->) String))
      arising from a use of `forever'
    Possible fix: add an instance declaration for (Monad ((->) String))
    In the expression: forever putStrLn "Hello, infinity"
    In an equation for `it': it = forever putStrLn "Hello, infinity"

我没有((->) String在Control.Applicative的源代码中看到Monad实例,所以我猜测由于使用了Control.Category或Control.Arrow而发生了一些奇怪的事情,但我不知道.所以我想我有两个问题:

1. 什么是导入Control.Applicative让这发生？
2. 当它进入无限循环时会发生什么？在这种情况下,Haskell实际上试图执行什么？

谢谢,

Jan Burse的回答显示了Prolog中元解释器的最简单实现之一:

solve(true) :- !.
solve((A,B)) :- !, solve(A), solve(B).
solve(H) :- clause(H,B), solve(B).

我想扩展这个解释器,以便它可以调用builtins.香草人无法处理诸如此类的电话solve(member(X, [1,2,3,4])).这可能是使用ISO谓词吗？如果没有,是否可以使用SWI-Prolog谓词？

我有一个大型的非Java EE,基于JSF的Web应用程序项目.我们的系统是分层的(在源代码意义上):有一个数据模型包,在此基础上是DAO包.我们在DAO包中专门使用Hibernate的XML配置映射.我们真的不想用注释来混淆数据模型,但是并没有专门与Hibernate结合(除了映射非常复杂).

我强烈考虑转向Java EE并将DAO对象构建为EJB.但是由于我们不愿意放弃Hibernate的XML,这引出了几个问题:

• 是否有可能在没有JPA注释的情况下将Hibernate与JPA一起使用？
• 如果没有,我的EJB是否有可能在Hibernate上以事务方式运行？我认为这称为JTA支持,但不确定.我喜欢"免费"获取交易的想法; 现在我们有一个自定义编码的阶段监听器,我想删除哪个处理Hibernate事务.
• 有没有办法从Hibernate的XML映射配置迁移到某种JPA XML映射？我没有看到这样做的方法,但显然减少我们与Hibernate的耦合会更好.

谢谢!

我正试图实现Fisher-Yates对某些数据的改组.该算法易于实现一维数组.但是,我需要能够在二维矩阵中混洗数据.

我认为可以很好地推广到更高维数组的方法是将我任意尺寸的矩阵转换为索引的一维数组,对其进行混洗,然后通过将该索引数组的每个索引处的元素与元素交换来重新组织矩阵在索引数组元素的索引处.换句话说,采用2x2矩阵,例如:

1  2
3  4

我会把它转换成这个"数组":

[(0, (0,0)),  (1, (0,1)),  (2, ((1,0)),  (3, (1,1))]

然后,我会按照正常情况进行争夺,比方说,

[(0, (1,0)),  (1, (0,1)),  (2, ((1,1)),  (3, (0,0))]

重组后,原始矩阵将变为:

2  3
4  1

我的基本方法是我想要一个类似于以下类型的类:

class Shufflable a where
  indices    :: a -> Array Int b
  reorganize :: a -> Array Int b -> a

然后我将有一个函数来执行看起来像这样的shuffle:

fisherYates :: (RandomGen g) => g -> Array Int b -> (Array Int b, g)

我认为(减去RandomGen管道)我应该可以改变这样一个可洗牌的东西:

shuffle :: (Shufflable a, RandomGen g) => a -> g -> (a, g) …

以拉丁文大学导论为例,考虑以下句子:

the sailor gives the girl money

我们可以使用DCG在Prolog中处理这个问题,这个规则非常优雅:

sentence(s(NP, VP)) --> noun_phrase(NP), verb_phrase(VP).
noun_phrase(Noun) --> det, noun(Noun).
noun_phrase(Noun) --> noun(Noun).
verb_phrase(vp(Verb, DO, IO)) --> verb(Verb), noun_phrase(IO), noun_phrase(DO).

det --> [the].
noun(X) --> [X], { member(X, [sailor, girl, money]) }.
verb(gives) --> [gives].

我们看到这有效:

?- phrase(sentence(S), [the,sailor,gives,the,girl,money]).
S = s(sailor, vp(gives, money, girl)) ;

在我看来,DCG真的是为处理字序语言而优化的.我完全失去了如何处理这个拉丁语的句子:

 nauta dat pecuniam puellae

这意味着同样的事情(水手给女孩钱),但是单词顺序是完全免费的:所有这些排列也意味着完全相同的事情:

nauta dat puellae pecuniam
nauta puellae pecuniam dat
puellae pecuniam dat nauta
puellae pecuniam nauta dat
dat pecuniam nauta …

在工作的同时,我做了很多修改.每当代码形式合理时,我都愿意提交.但并非所有这些提交都很有趣.所以我将这些提交提交到本地磁盘或私有服务器.它看起来像这样:

• 我Foo早上拿了包,所以它的版本是FamousSmalltalkGuy.14.
• 我在当地早上(15),午餐(16)和晚上(17)承诺.现在Foo在本地打包是最多的DanielLyons.17.
• 看起来像Famous Smalltalk Guy将15版本推向了Smalltalkhub.
• 我合并FamousSmalltalkGuy.15了我的图像,生成DanielLyons.18.

现在我想推进DanielLyons.18Smalltalkhub.什么是正确的做法？

1. 复制版本(单击Monticello UI中的"复制"按钮).

   这感觉错了,因为届时将有来自不连续FamousSmalltalkGuy.15和DanielLyons.18.

2. 在Smalltalkhub存储库中提交新版本,手动DanielLyons.15在框中书写.

   这感觉不对,因为它似乎混淆了我的本地形象.毕竟,它DanielLyons.15之前已经看过了,这不是它.

我确信这里有正确的事情,但我不知道它是什么.如果有人能够对正确的蒙蒂塞洛工作流程进行同步协作开发,我将非常感激.谢谢!

在我看来,应该能够在字节列表上使用DCG处理二进制数据.但是,为了使其一般工作,必须使用按位操作,这意味着is/2涉及,这意味着实例化顺序是一个问题,这可能使用DCG来解析和生成混淆.这里的想法是序列化/反序列化二进制数据,但我认为这个例子很简单,足以说明问题.

让我用一些代码来说明.假设我有一个二进制协议.我想从一个字节读取两个4位整数.我天真的自我试试这个:

two_four_bit_ints(High, Low) -->
  [B],
  {
    High is B >> 4,
    Low  is B /\ 0xF
  }.

这似乎适用于解析:

?- phrase(two_four_bit_ints(H,L), [255]).
H = L, L = 15.

?- phrase(two_four_bit_ints(H,L), [0]).
H = L, L = 0.

?- phrase(two_four_bit_ints(H,L), [15]).
H = 0,
L = 15.

?- phrase(two_four_bit_ints(H,L), [240]).
H = 15,
L = 0.

但这不会产生:

?- phrase(two_four_bit_ints(15,15), [X]).
ERROR: is/2: Arguments are not sufficiently instantiated

?- phrase(two_four_bit_ints(15,15), X).
ERROR: is/2: Arguments are not sufficiently instantiated …