标签: lazy-evaluation

通过什么机制这个斐波那契函数被记忆了？

fib = (map fib' [0..] !!)                 
     where fib' 1 = 1                                                        
           fib' 2 = 1                                                        
           fib' n = fib (n-2) + fib (n-1)                    

在相关的说明中,为什么这个版本不是？

fib n = (map fib' [0..] !! n)                                               
     where fib' 1 = 1                                                        
           fib' 2 = 1                                                        
           fib' n = fib (n-2) + fib (n-1)                    

自1.3.0-beta.10版本以来,AngularJS有一个新功能:"懒惰的一次性绑定".

简单的表达式可以作为前缀::,告诉角度在首次评估表达式后停止观看.给出的常见示例如下:

<div>{{::user.name}}</div>

是否有类似以下表达式的语法？

<div ng-if="user.isSomething && user.isSomethingElse"></div>
<div ng-class="{classNameFoo: user.isSomething}"></div>

我在Clojure中尝试了以下内容,期望返回一个非惰性序列的类:

(.getClass (doall (take 3 (repeatedly rand))))

但是,这仍然会回归clojure.lang.LazySeq.我的猜测是doall评估整个序列,但返回原始序列,因为它仍然可用于记忆.

那么从懒惰中创建一个非懒惰序列的惯用手段是什么？

我们都知道(或应该知道)Haskell默认是懒惰的.在必须对其进行评估之前,不评估任何内容.那么什么时候必须评估一下？Haskell必须严格要点.我把这些称为"严格点",虽然这个术语并不像我想象的那么广泛.据我说:

Haskell中的减少(或评估)仅发生在严格点处.

所以,问题是:什么,准确地说,是Haskell的严格点？我的直觉说main,seq/爆炸模式,模式匹配以及IO通过执行的任何动作main都是主要的严格点,但我不知道为什么我知道这一点.

(另外,如果他们不叫"严点",什么是他们叫什么名字？)

我想一个好的答案将包括一些关于WHNF等的讨论.我也想象它可能触及lambda演算.

编辑:关于这个问题的其他想法.

正如我在这个问题上的反思,我认为在严格点的定义中添加一些东西会更清楚.严格点可以具有不同的上下文和不同的深度(或严格性).回到我的定义"Haskell的减少只发生在严格点",让我们在这个定义中添加这个子句:"只有在评估或减少周围环境时才会触发严格点."

所以,让我试着让你开始我想要的那种答案.main是严格的一点.它被特别指定为其上下文的主要严格点:程序.当main评估程序(的上下文)时,激活main的严格点.主要深度是最大的:必须进行全面评估.Main通常由IO动作组成,它们也是严格点,其背景是main.

现在你尝试:seq用这些术语讨论和模式匹配.解释功能应用的细微差别:它是如何严格的？怎么回事？怎么样deepseq？let和case陈述？unsafePerformIO？Debug.Trace？顶级定义？严格的数据类型？邦模式？等等.这些项目中有多少只能用seq或模式匹配来描述？

我一般都听说生产代码应该避免使用Lazy I/O. 我的问题是,为什么？是否可以在懒散的I/O之外使用它？什么使替代品(例如调查员)更好？

我今天在unix中发现了"time"命令,并认为我会用它来检查Haskell中尾递归和正常递归函数之间运行时的差异.

我写了以下函数:

--tail recursive
fac :: (Integral a) => a -> a
fac x = fac' x 1 where
    fac' 1 y = y
    fac' x y = fac' (x-1) (x*y) 

--normal recursive
facSlow :: (Integral a) => a -> a
facSlow 1 = 1
facSlow x = x * facSlow (x-1)

这些都是有效的,记住它们只是用于这个项目,所以我没有费心去检查零或负数.

但是,在为每个编写一个main方法,编译它们,并使用"time"命令运行它们时,两者都具有相似的运行时,正常的递归函数使尾递归函数边缘化.这与我在lisp中关于尾递归优化的内容相反.这是什么原因？

在使用map,flatmap等函数后,使用withFilter而不是过滤器总是更高效吗？

为什么只支持map,flatmap和foreach？(预期的功能如forall/exists)

这是让我感到困惑的一个.我正在尝试实现一个基本的Hibernate DAO结构,但是遇到了问题.

这是基本代码:

int startingCount = sfdao.count();
sfdao.create( sf );
SecurityFiling sf2 = sfdao.read( sf.getId() );
sfdao.delete( sf );
int endingCount = sfdao.count();

assertTrue( startingCount == endingCount );
assertTrue( sf.getId().longValue() == sf2.getId().longValue() );
assertTrue( sf.getSfSubmissionType().equals( sf2.getSfSubmissionType() ) );
assertTrue( sf.getSfTransactionNumber().equals( sf2.getSfTransactionNumber() ) );

它在第三个assertTrue上失败,它试图将sf中的值与sf2中的相应值进行比较.这是例外:

org.hibernate.LazyInitializationException: could not initialize proxy - no Session
    at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:86)
    at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:140)
    at org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer.invoke(JavassistLazyInitializer.java:190)
    at com.freightgate.domain.SecurityFiling_$$_javassist_7.getSfSubmissionType(SecurityFiling_$$_javassist_7.java)
    at com.freightgate.dao.SecurityFilingTest.test(SecurityFilingTest.java:73)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:40)

我正在寻找stackoverflow Non-Trivial Lazy Evaluation,这让我想到了Keegan McAllister的演讲:为什么要学习Haskell.在幻灯片8中,他显示了最小功能,定义为:

minimum = head . sort

并指出其复杂性为O(n).我不明白为什么如果通过替换排序是O(nlog n),复杂性被认为是线性的.帖子中引用的排序不能是线性的,因为它不假设数据的任何内容,因为线性排序方法需要它,例如计数排序.

懒惰的评价在这里发挥着神秘的作用吗？如果是这样,背后的解释是什么？

在我的班级中更改我的getter方法(如版本2)是不好的做法.

版本1:

 public String getMyValue(){
     return this.myValue
 }

版本2:

 public String getMyValue(){

    if(this.myValue == null || this.myValue.isEmpty()){
       this.myValue = "N/A";
    }

    return this.myValue;
 }