标签: lazy-evaluation

我正在使用消息传递工具包(它恰好是Spread,但我不知道细节很重要).从此工具包接收消息需要一些样板:

1. 创建与守护程序的连接.
2. 加入一个小组.
3. 接收一条或多条消息.
4. 离开小组.
5. 断开与守护程序的连接.

根据我在别处看过的一些习惯用法,我能够使用Spread的Java API和Clojure的互操作形式来编写一些工作函数:

(defn connect-to-daemon
  "Open a connection"
  [daemon-spec]
  (let [connection (SpreadConnection.)
        {:keys [host port user]} daemon-spec]
    (doto connection
      (.connect (InetAddress/getByName host) port user false false))))

(defn join-group
  "Join a group on a connection"
  [cxn group-name]
  (doto (SpreadGroup.)
    (.join cxn group-name)))

(defn with-daemon*
  "Execute a function with a connection to the specified daemon"
  [daemon-spec func]
  (let [daemon (merge *spread-daemon* daemon-spec)
        cxn (connect-to-daemon daemon-spec)]
    (try
     (binding [*spread-daemon* (assoc daemon :connection cxn)]
       (func)) …

在2.7我可以做到以下几点:

val lazyM: Map[_, _] = map.projection.mapElements(v => expCalc(v)) //MAP VIEW

我在2.8中找不到这样做的方法,实际上最终得到了一张地图:

val m: Map[_, _] = map.view.map(kv => kv._1 -> expCalc(kv._2)).toMap //STRICT

这似乎是功能的重大损失,因此我认为它隐藏在某个地方的集合库中.有人有主意吗？

编辑 - 愚蠢地我认为mapValues与旧的mapElements完全相同

我想要一个像foo.method1.method2.method3那样向后运行函数的类,我希望函数运行method3 method2然后运行method1.但现在它已经进入了1 2 3.我认为这被称为懒惰评估,但我不确定.

我对Ruby几乎一无所知所以请原谅这个问题,如果它很简单,我已经知道了.

我正在按照B. Ford的硕士论文在OCaml中实现一个packrat解析器. 我的解析器应该接收一个表示语言语法的数据结构,并解析给定的符号序列.

我被记忆部分困住了.原始论文使用Haskell的惰性评估来实现线性时间复杂度.我想在OCaml中这样做(通过懒惰进行记忆),但不知道该怎么做.

那么,如何通过OCaml中的延迟评估来记忆函数？

编辑:我知道懒惰的评估是什么以及如何在OCaml中利用它.问题是如何使用它来记忆功能.

编辑:我写的代表语法的数据结构是:

type ('a, 'b, 'c) expr =
| Empty of 'c
| Term of 'a * ('a -> 'c)
| NTerm of 'b
| Juxta of ('a, 'b, 'c) expr * ('a, 'b, 'c) expr * ('c -> 'c -> 'c)
| Alter of ('a, 'b, 'c) expr * ('a, 'b, 'c) expr
| Pred of ('a, 'b, 'c) expr * 'c
| NPred of ('a, 'b, 'c) expr …

我是Haskell的新手,我正在为我的Programming Languages课写一篇论文.我想用一些示例代码演示Haskell的懒惰,但我不确定我所看到的是否实际上是懒惰.

doubleMe xs = [x*2 | x <- xs]

在ghci:

let xs = [1..10]
import Debug.Trace
trace (show lst) doubleMe (trace (show lst) doubleMe (trace (show lst) doubleMe(lst)))

输出:

[1,2,3,4,5,6,7,8,9,10]
[1,2,3,4,5,6,7,8,9,10]
[1,2,3,4,5,6,7,8,9,10]
[8,16,24,32,40,48,56,64,72,80]

感谢您的时间和帮助!

我在Haskell中编写了一个简单(且非严重)的素数生成器,它具有相互递归的定义,用于生成素数和确定数字的素数:

primes :: (Integral a) => [a]
primes = 2 : filter isPrime [3, 5..]

isPrime :: (Integral a) => a -> Bool
isPrime m = all (indiv m) (takeWhile (<= (intSqrt m)) primes)

intSqrt :: (Integral a) => a -> a
intSqrt 1 = 1
intSqrt n = div (m + (div (n - 1) m)) 2
  where m = intSqrt (n - 1)

indiv :: (Integral a) => a -> a -> Bool
indiv m n = rem …

我试图围绕着如何获得无限列表来解决这个问题...这是我的路障:

您有一个类型列表A,并A实现Ord类型类.您可以像这样描述一系列有序元素(例如,intergers):

[1..6]

这相当于......

Cons 1 (Cons 2 (Cons 3 (Cons 4 (Cons 5 (Cons 6 (Empty))))))

haskell如何知道如何构建无限列表？haskell能够创建支持的任何数据类型的无限列表Ord吗？

我想知道是否可以执行以下操作：

var obj = {
   counter: (function(){
                if(!this.val){ this.val = 0; }
                this.val += 1;
                return this.val;
            })();
};

console.log(obj.counter); //should output 1
console.log(obj.counter); //should output 2
console.log(obj.counter); //should output 3
...

有没有办法从这样的对象中获取字段，以便每次访问该函数时都会重新评估一个函数？

假设我有一个清单

xs = [0,1,2,3]
[some_function(current, next) for current, next in zip(xs, xs[1:])]

我想迭代这个列表的对(当前,下一个).澄清zip创建列表[(0,1),(1,2),(2,3)]

问题是,如果xs是生成器而不是列表来实现这一点,我需要从中创建一个列表,这肯定不是最佳解决方案.

我看到了Haskell这个片段在此答案由自豪haskeller上元PPCG:

x=2:x

我想,"等等,我可以在Scala那样做!" 所以我尝试过:

lazy val x: List[Int] = 2 :: x

它编译了,我的控制台打印好了x: List[Int] = <lazy>.但是这些行中的每一行都会导致StackOverflowException:

x take 1
x.head
x(1)
x

基于最后一个,它看起来像任何尝试使用x打击堆栈尝试计算x(或者尝试在控制台中打印它时发生堆栈溢出).在这个例子中,Scala的懒惰与Haskell的懒惰有什么不同？这是Scala的功能lazy val还是List只需要完整的尾部？