小编Abh*_*k S的帖子

Golang新手在这里.

两者之间是否存在功能差异？

func randomNumberGenerator() <-chan int {

和

func randomNumberGenerator() chan int {

我尝试过使用它们,它们似乎对我很好.

我已经看过Rob Pike(Go创建者之一)在Google IO 2012的Go Concurrency Patterns演讲中使用的前者.我也看到它在Go的官方网站上使用过.为什么可以省略它时添加2个额外字符("< - ")？我已经尝试在网上寻找差异,但找不到它.

Elixir新手在这里.我一直在尝试将KeywordList转换为字符串.我可以这样做

IO.inspect([name: "John Doe"])

但它将字符串打印到控制台.是否有一个只返回字符串的函数？

更新:Elixir并不慢,我的算法是.我的算法甚至不是苹果对比.有关Ruby和Go等效算法,请参阅下面的Roman答案.还要感谢José,我的慢速算法可以通过添加前缀MIX_ENV = prod来显着加快.我已经更新了问题中的统计数据.

原始问题: 我正在研究多种语言的Project Euler问题,只是为了了解语言的效率和速度.在问题#5中,我们被要求找到可被1到20的所有数字整除的最小正数.

我用多种语言实现了该解决方案.以下是统计数据:

1. 去1.4.2:0.58s
2. Ruby 2.2 MRI:6.7s
3. Elixir 1.0.5(我的第一个算法):57s
4. Elixir 1.0.5(我的第一个算法,MIX_ENV = prod前缀):7.4s
5. Elixir 1.0.5(Roman的Go等效算法):0.7s
6. Elixir 1.0.5(Roman的Ruby等效算法):1.8s

为什么Elixir的表现如此之慢？我尝试在所有语言中使用相同的优化.警告:我是FP和Elixir新手.

我有什么办法可以改善Elixir的表现吗？如果您使用任何分析工具来找出更好的解决方案,请将它们包含在响应中吗？

在Go:

func problem005() int {
  i := 20
outer:
  for {
    for j := 20; j > 0; j-- {
      if i%j != 0 {
        i = i + 20
        continue outer
      }
    }
    return i
  }
  panic("Should have found a solution by now")
}

在Ruby中:

def self.problem005
  divisors = (1..20).to_a.reverse

  number = 20 …

程序顺序规则指出"线程中的每个操作都发生在 - 在程序顺序中稍后出现的该线程中的每个操作之前"

1.I读取另一个线程,一个动作是

• 读取和写入变量
• 锁定和解锁显示器
• 开始和加入线程

这是否意味着可以按顺序更改读取和写入,但读取和写入不能使用在第2行或第3行中指定的操作更改顺序？

2."程序顺序"是什么意思？

对示例的解释将非常有用.

其他相关问题

假设我有以下代码:

long tick = System.nanoTime(); //Line1: Note the time
//Block1: some code whose time I wish to measure goes here
long tock = System.nanoTime(); //Line2: Note the time

首先,它是一个单线程应用程序,以保持简单.编译器注意到它需要检查两次时间并且还注意到与周围时间注释行没有依赖关系的代码块,因此它看到了重新组织代码的可能性,这可能导致Block1不被定时调用所包围在实际执行期间(例如,考虑此顺序Line1-> Line2-> Block1).但是,作为程序员,我可以看到Line1,2和Block1之间的依赖关系.Line1应紧接在Block1之前,Block1需要有限的时间才能完成,并且Line2立即成功.

所以我的问题是:我是否正确测量了块？

• 如果是,那么是什么阻止了编译器重新排列顺序.
• 如果不是,(通过Enno的回答后认为是正确的)我该怎么做才能防止它.

PS:我最近在SO中提出的另一个问题偷了这个代码.

有没有办法让Elixir中的列表理解变得懒惰？如果没有,有没有办法把它变成一个Stream？

my_list = for i <- (1..1000000), j <- (1..1000000), do: {i, j}

这段代码通过占用太多内存来破坏我的程序.

我想在my_list上应用过滤器,map和reduce.

我一直在阅读有关Java内存模型的信息，并且我知道编译器可以重新组织语句来优化代码。

假设我有以下代码：

long tick = System.nanoTime();
function_or_block_whose_time_i_intend_to_measure();
long tock = System.nanoTime();

编译器是否会以我想要测量的方式在tick和tock之间不执行的方式重组代码？例如，

long tick = System.nanoTime();
long tock = System.nanoTime();
function_or_block_whose_time_i_intend_to_measure();

如果是这样，保留执行顺序的正确方法是什么？

编辑：示例说明了用nanoTime乱序执行：

public class Foo {
    public static void main(String[] args) {
        while (true) {
            long x = 0;

            long tick = System.nanoTime();
            for (int i = 0; i < 10000; i++) { // This for block takes ~15sec on my machine
                for (int j = 0; j < 600000; j++) {
                    x = x + x * x; …

我在处理 Java 集合和 Guava 时非常广泛地使用泛型。我在使用 API 时非常理解它：

1. PECS规则
2. {co, contra, in}方差
3. 通配符
4. 有界泛型

但是，我发现很难使用泛型来提出 API。Java泛型有设计模式吗？或者任何对 Java 泛型的引用也会有所帮助。我读了：

1. 有效的Java
2. 《Java 泛型和集合》这本书
3. http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html

我只熟悉泛型有用的两种模式：

1. 收容概念：Java集合、GuavaOptional<T>等。
2. 类型参数化： Guava Predicate<T>,Function<T>

我是 Elixir 和函数式编程的新手，有 OO 背景。

我一直试图理解 Elixir 中列表理解中的变量重新分配是如何工作的。我期望函数 test1() 和 test2() 打印 4，但 test2() 不会重新分配变量并打印 1。

defmodule SampleCode do
  def test1 do
    num = 1
    num = num + 1
    num = num + 2
    IO.puts num # Prints 4
  end

  def test2 do
    num = 1
    for i <- (1..2) do
      num = num + i
    end
    IO.puts num # Prints 1
  end
end

1. 为什么这些函数的行为不同？
2. 这是 Elixir 中的变量作用域还是我所缺少的函数式编程的基本原则？

Elixir和OTP新手.尝试使用GenServer的一些hello-world示例.我正在编写测试,每个测试产生一个GenServer进程.它们没有明确终止.测试完成后,该过程是否会死亡？

跟进:如果没有终止,他们会变成"僵尸"进程吗？此外,测试完成后是否有终止它们的模式？

一些Elixir函数有2个变量用于指示错误

1. 返回一个元组,例如File.open返回类似{:ok, io_device}或的东西{:error, posix}

2. 提高例外,例如 File.open!

我的问题是:

1. 有两种方式的意图是什么？
2. 一个优先于另一个(如最佳实践)？

据说函数是 Elixir/Erlang 中的一等公民。函数可以作为消息传递吗？

在探索 Elixir API 时，我遇到了Agent#get_and_update(agent, fun, timeout \\ 5000). 我想获取和更新操作是原子的。我认为这是可能的唯一方法是fun在代理进程而不是与代理交互的客户端进程上运行。

如果fun在客户端进程上运行，则会带来许多有关保证原子性和客户端进程失败的问题。