今天早些时候,我为iteratees编写了一个小型测试应用程序,该应用程序组成了一个iteratee,用于使用iteratee编写进度来实际复制数据.我结束了这样的价值观:

-- NOTE: this snippet is with iteratees-0.8.5.0
-- side effect: display progress on stdout
displayProgress :: Iteratee ByteString IO ()

-- side effect: copy the bytestrings of Iteratee to Handle
fileSink :: Handle -> Iteratee ByteString IO ()

writeAndDisplayProgress :: Handle -> Iteratee ByteString IO ()
writeAndDisplayProgress handle = sequence_ [fileSink handle, displayProgress]

在查看枚举器库时,我没有看到类似的sequence_或enumWith.我想要做的就是编写两个迭代,以便它们作为一个整体.我可以放弃结果(()无论如何)或保留它,我不在乎.来自Control.Arrow的(&&&)是我想要的,仅适用于迭代而不是箭头.

我试过这两个选项:

-- NOTE: this snippet is with enumerator-0.4.10
run_ $ enumFile source $$ sequence_ [iterHandle handle, displayProgress]
run_ $ …

我有一棵树,我正试图穿越.当我遍历它时,我会保留一堆枚举器,其中每个枚举器用于枚举树的子节点.

我希望能够复制这个枚举器堆栈并将其交给另一个对象,这样它就可以从堆栈状态指示的位置开始遍历树.

当我尝试在Enumerator上调用#dup时,出现错误.是否可以复制枚举器？如果没有,我怎么能完成同样的事情？(我已经将一堆整数视为指数,但我担心效率.

这里有一些代码来展示我所看到的......

第一个枚举器启动后,您无法复制它.那是我的情况.

a = [1,2,3].each
 => #<Enumerator: [1, 2, 3]:each> 
a.next
 => 1 
b = a.dup
TypeError: can't copy execution context
    from (irb):3:in `initialize_copy'
    from (irb):3:in `initialize_dup'
    from (irb):3:in `dup'
    from (irb):3

I am trying to implement a take_until method for Ruby 2's Enumerator::Lazy class. It should work similar to take_while but instead stop iteration when the yielded block returns true. The result should include the item where the yielded block matches.

My question is how do I signal that the end of the iteration is reached? When using regular Enumerators you can raise the StopIteration error in an each method to signal the end of the iterator. But that doesn't seem …

当为每个循环设置a以从"objProduct"对象变量读取产品时,我在"枚举器模式"窗格中有三个选项,如快照所示:

我知道"第一张表中的行"是当前案例的正确选项.但是,我很好奇第二和第三个选项会在哪些场景中使用？

似乎"ADO对象源变量"将包含多个表,如果应用了第2个/第3个.那令人困惑......不应该将一个变量视为一个表,因此只需要第一个选项吗？

PS我做过研究,只有MSDN如下所示,但是当它们被应用以及用于何种目的时,并不十分清楚.

**Rows in all tables (ADO.NET dataset only)**
Select to enumerate rows in all tables. This option is available only if the objects to enumerate are all members of the same ADO.NET dataset.
**All tables (ADO.NET dataset only)**
Select to enumerate tables only.

我正在寻找一种在Play框架中打印响应体的方法,我有这样的代码:

object AccessLoggingAction extends ActionBuilder[Request] {
  def invokeBlock[A](request: Request[A], block: (Request[A]) => Future[Result]) = {
    Logger.info(s"""Request:
      id=${request.id} 
      method=${request.method} 
      uri=${request.uri} 
      remote-address=${request.remoteAddress} 
      body=${request.body}
    """)
    val ret = block(request)
    /*
    ret.map {result =>
      Logger.info(s"""Response:
      id=${request.id} 
      body=${result.body}
      """)
    }
    */ //TODO: find out how to print result.body (be careful not to consume the enumerator)
    ret
  }
}

目前,已注释掉的代码无法正常工作,我的意思是,它会打印出来:

Response:
id=1
body=play.api.libs.iteratee.Enumerator$$anon$18@39e6c1a2

所以,我需要找到一种从Enumerator [Array [Byte]]中获取String的方法.我试着通过阅读这篇文章来了解Enumerator的概念:http://mandubian.com/2012/08/27/understanding-play2-iteratees-for-normal-humans/

所以...,如果我理解正确的话:

1. 我不应该在将它转换为String的过程中干掉枚举器.否则,客户端将不会收到任何信息.

2. 让我们假设我弄清楚如何实现T /过滤器机制.但那么......它不会打败Play框架作为非阻塞流式传输框架的目的(因为我会在内存中构建完整的字节数组,然后在其上调用toString,最后记录它)？

那么,记录响应的正确方法是什么？

提前谢谢,拉卡

有人可以给我关于如何创建GetEnumerator()的递归版本的建议吗？众所周知的河内塔问题可以作为一个与我遇到的实际问题相当的例子.显示高度为n的磁盘堆栈的所有移动的简单算法是:

void MoveTower0 (int n, Needle start, Needle finish, Needle temp)
{
  if (n > 0)
  {
    MoveTower0 (n - 1, start, temp, finish);
    Console.WriteLine ("Moving disk from {0} to {1}", start, finish);
    MoveTower0 (n - 1, temp, finish, start);
  }
}

我真正想要做的是建立一个实现IEnumerable的HanoiTowerMoves类,这使我可以按如下方式迭代所有移动:

foreach (Move m in HanoiTowerMoves) Console.WriteLine (m);

迈向GetEnumerator()实现的第一步似乎摆脱了MoveTower参数.这可以通过使用堆栈轻松完成.我还介绍了一个Move类,它将参数组合成一个变量.

class Move
{
  public int N { private set; get; }
  public Needle Start { private set; get; }
  public Needle Finish { private set; get; } …

我正在尝试使用scalaz iteratee包来处理恒定空间中的大型zip文件.我需要对zip文件中的每个文件执行一个长时间运行的进程.这些过程可以(并且应该)并行运行.

我创建了一个EnumeratorT将每个膨胀ZipEntry成一个File对象.签名如下:

def enumZipFile(f:File):EnumeratorT[IoExceptionOr[IO[File]], IO]

我想附加一个IterateeT将在每个文件上执行长时间运行的进程.我基本上最终得到了类似的东西:

type IOE[A] = IoExceptionOr[A]

def action(f:File):IO[List[Promise[IOE[File]]]] = (
  consume[Promise[IOE[File]], IO, List] %=
  map[IOE[File], Promise[IOE[File]], IO](longRunningProcess) %=
  map[IOE[IO[File]], IOE[File], IO](_.unsafePerformIO) &=
  enumZipFile(f)
).run

def longRunningProcess:(iof:IOE[File]):Promise[IOE[File]] =
  Promise { Thread.sleep(5000); iof }

当我尝试运行它时:

action(new File("/really/big/file.zip")).unsafePerformIO.sequence.get

我收到一条java.lang.OutOfMemoryError: Java heap space消息.这对我来说很有意义,因为它试图在所有这些IO和Promise对象的内存中建立一个庞大的列表.

几个问题:

• 有没有人对如何避免这个有任何想法？感觉我正在接近这个问题,因为我真的只关心longRunningProcess它的副作用.
• 这种Enumerator方法是错误的方法吗？

我几乎没有想法,所以任何事情都会有所帮助.

谢谢!

更新#1

这是堆栈跟踪:

[error] java.lang.OutOfMemoryError: Java heap space
[error]         at scalaz.Free.flatMap(Free.scala:46)
[error]         at scalaz.effect.IO$$anonfun$flatMap$1.apply(IO.scala:62) …

我一直在调试这个生产错误,我迫切需要帮助,这对我来说也很有意思.

我简化了代码逻辑并为调试添加了一些打印输出:

int[] a = { 2,2,2 };
var b = a.Where(x => x==2);

for(int i = 0; i < 3; i++)
{
    var c = b.Where(x => x==i);

    Console.WriteLine("iter {0} before - B Count: {1}, C Count: {2}", i, b.Count(), c.Count());

    if (c.Count() != b.Count())
        b = b.Except(c);

    Console.WriteLine("iter {0} after - B Count: {1}, C Count: {2}", i, b.Count(), c.Count());
}

Console.WriteLine("After Loop: B Count: {0}", b.Count());

有趣的是(奇怪),输出是:

iter 0 before - B Count: 3, C Count: 0 …

红宝石

Ruby有each_cons可以像这样使用

class Pair
    def initialize(left, right)
        @left = left
        @right = right
    end
end
votes = ["a", "b", "c", "d"]
pairs = votes.each_cons(2).map { |vote| Pair.new(*vote) }
p pairs
# [#<Pair @left="a", @right="b">, #<Pair @left="b", @right="c">, #<Pair @left="c", @right="d">]

迅速

swift中的代码相同,但没有each_cons函数

struct Pair {
    let left: String
    let right: String
}
let votes = ["a", "b", "c", "d"]
var pairs = [Pair]()
for i in 1..<votes.count {
    let left = votes[i-1]
    let right = votes[i] …

这是根据埃里克·利珀特（Eric Lippert）对这个问题的回答得出的一个附带问题。

我想知道为什么C＃语言在以下特定情况下无法检测到正确的接口成员。我不是在寻求反馈意见，以这种方式设计课程是否被视为最佳实践。

class Turtle { }
class Giraffe { }

class Ark : IEnumerable<Turtle>, IEnumerable<Giraffe>
{
    public IEnumerator<Turtle> GetEnumerator()
    {
        yield break;
    }

    // explicit interface member 'IEnumerable.GetEnumerator'
    IEnumerator IEnumerable.GetEnumerator()
    {
        yield break;
    }

    // explicit interface member 'IEnumerable<Giraffe>.GetEnumerator'
    IEnumerator<Giraffe> IEnumerable<Giraffe>.GetEnumerator()
    {
        yield break;
    }
}

在上面的代码中，Ark有3个冲突的实现GetEnumerator()。解决此冲突的方法是将IEnumerator<Turtle>的实现视为默认值，并且要求对两者进行特定的强制转换。

检索枚举数的工作原理很简单：

var ark = new Ark();

var e1 = ((IEnumerable<Turtle>)ark).GetEnumerator();  // turtle
var e2 = ((IEnumerable<Giraffe>)ark).GetEnumerator(); // giraffe
var e3 = ((IEnumerable)ark).GetEnumerator(); …