标签: enumerator

我正在编写与此类似的代码:

public IEnumerable<T> Unfold<T>(this T seed)
{
    while (true)
    {
        yield return [next (T)object in custom sequence];
    }
}

显然,这种方法永远不会回归.(C#编译器默默地允许这个,而R#给我警告"函数永远不会返回".)

一般来说,提供一个返回无限数量项的枚举器,而不提供停止枚举的方法是不好的设计？

这种情况有什么特别的考虑因素吗？纪念品？PERF？其他陷阱？

如果我们总是提供退出条件,哪些是选项？例如:

• 类型为T的对象,表示包含或排他的边界
• a Predicate<T> continue(同样TakeWhile如此)
• 伯爵(同样Take)
• ...

我们应该依赖用户呼叫Take(...)/ TakeWhile(...)之后Unfold(...)吗？(也许是首选方案,因为它利用了现有的Linq知识.)

如果代码将在公共API中发布,无论是按原样(通用)还是作为此模式的特定实现,您会以不同的方式回答这个问题吗？

今天早些时候,我为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_ $ …

关于创建单向,延迟评估,可能无限的迭代器,我遇到了Ruby的问题.基本上,我正在尝试使用Ruby,就像我使用Haskell列表,以及在较小程度上使用Python生成器.

并不是我本身不理解它们; 我只是不知道如何像其他语言一样随意使用它们,而且我也不确定Ruby中的哪些方法会将它们变成背后的数组,将整个序列卸载到内存中是不必要的.

是的,我一直在研究Ruby参考手册.其实半小时,专注.或者显然不是.

例如,如果我要实现卡片组,它在Python中看起来像这样(未经测试):

# Python 3

from itertools import chain, count

face_ranks =
    dict(
        zip(
            ('jack', 'queen', 'king', 'ace'),
            count(11)))

sorted_deck =
    map(
        lambda suit:
            map(
                lambda rank:
                    {
                        'rank' : rank,
                        'suit' : suit
                    },
                chain(
                    range(2, 11),
                    face_ranks.keys())),
        ('clubs', 'diamonds', 'hearts', 'spades'))

那么,我如何在Ruby中完成这项工作,完全避免使用数组呢？请注意,据我所知,上面的代码只使用元组和生成器:在任何时候都不会将整个序列转储到内存中,就像我使用了数组一样.我对上面的代码可能是错的,但是你得到了我想要的东西.

我如何链接迭代器(如Python的chain())？如何生成无限范围的迭代器(如Python的count())？如何在迭代器中添加一个数组(比如将元组传递给Python的链())而不将整个过程转换为数组？

我见过解决方案,但它们涉及阵列或不必要的复杂性,如光纤.

在Python中,我可以像数组一样简单地操作和抛出迭代器.我几乎可以把它们当作Haskell列表来对待,我最熟悉的就是它,而且在编码时我的想法就是这样.我对Ruby数组感到不舒服,这就是为什么我寻求其替代品的帮助.

我已经设法在互联网上获取有关它的信息,但我找不到任何涵盖Ruby中这种数据结构的基本操作？有帮助吗？

我想将枚举器用于Delphi XE2的泛型集合.我想知道,谁拥有函数GetEnumerator返回的TEnumerator(我在文档中没有找到任何明确的答案):

• 我拥有它并需要在使用后释放它吗？
• 或者它归集合所有,我不必关心它的释放？

码:

procedure Test;
var
  myDictionary: TDictionary<String, String>;
  myEnum: TDictionary<String, String>.TPairEnumerator;
begin
  { Create a dictionary }
  myDictionary := TDictionary<String, String>.Create;
  myDictionary.Add('Key1', 'Value 1');
  myDictionary.Add('Key2', 'Value 2');

  { Use an enumerator }
  myEnum := myDictionary.GetEnumerator;
  // ... do something with the Enumerator ...

  { Release objects }
  myEnum.Free; // ** Do I need to free the enumerator? **
  myDictionary.Free;          
end;

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

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

当我尝试在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

当为每个循环设置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.

我正在使用yield return迭代SqlDataReader记录:

IEnumerable<Reading> GetReadings() {
    using (var connection = new SqlConnection(_connectionString))
    {
        using (var command = new SqlCommand(_query, connection))
        {
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    yield return new Reading
                    {
                        End = reader.GetDateTime(0),
                        Value = reader.GetDouble(1)
                    };
                }
            }
            connection.Close();
        }
    }
}

然后我使用这个被接受的答案的改编版本来"拉"许多迭代器:

   var enumerators = data.Select(d => new
   {
       d.Key,
       Enumerator = d.Value.GetEnumerator()
   }).ToList();

   while (true)
   {
       foreach (var item in enumerators)
       {
           if (!item.Enumerator.MoveNext())
           {
               yield …

我想优化以下代码以简洁.

x1.each { |x| 
  x2.each { |y|
    ....
    xN.each { |z|
      yield {}.merge(x).merge(y)...... merge(z)
    }
  }
}

假设x1, x2, ..., xN是Enumerator对象.

1. 以上并不简洁
2. 它适用于x1,x2作为Arrays,但不能作为Enumerators
   • 因为枚举器迭代器应该重置为内部循环

我试过这个但没有成功:

[x1, x2, ..., xN].reduce(:product).map { |x| x.reduce :merge }

有什么建议？

UPDATE

目前解决了:

[x1, x2, ..., xN].map(:to_a).reduce(:product).map { |x| 
  yield x.flatten.reduce(:merge) 
}

我正在寻找一种在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,最后记录它)？

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

提前谢谢,拉卡

在C++中,特别是在C++ 14 n4296中,有两个段落讨论了枚举器的类型,这似乎与我相矛盾.见7.2/5(10.2/5 in n4659):

每个枚举定义一个与所有其他类型不同的类型.每个枚举也有一个基础类型.可以使用enum-base显式指定基础类型.对于作用域枚举类型,如果未明确指定,则基础类型为int.在这两种情况下,基础类型都被认为是固定的.在枚举说明符的右括号之后,每个枚举器都有其枚举类型.如果基础类型是固定的,那么闭括号之前的每个枚举器的类型是基础类型,枚举器定义中的constant-expression应该是基础类型的转换常量表达式[...]

5.1.1/11(8.1.4.2/4 in n4659)写道:

表示枚举(7.2)的嵌套名称说明符,后跟该枚举的枚举数名称,是引用枚举数的qualified-id.结果是枚举器.结果的类型是枚举的类型.结果是一个prvalue.

然后,当我们在关闭声明的括号之前通过嵌套名称说明符引用枚举器时会发生什么？以下面的代码为例:

template < typename T1, typename T2 >
struct fail_if_not_same {
    static_assert(std::is_same<T1, T2>::value, "Fail!");
    static constexpr int value = 0;
};

enum class E : short {
    A,
    B = A + 1,
    C = fail_if_not_same<decltype(B), short>::value,
    D = fail_if_not_same<decltype(E::B), short>::value
};

E::B上面的表达式是什么类型的？这是标准的矛盾吗？gcc和clang都遵循7.2/5.