标签: lazy-evaluation

背景

这个问题源于一个挑战布伦特Yorgey提出在OPLSS:写一个函数f :: (Int -> Int) -> Bool区分f undefined的f (\x -> undefined).我们所有的答案要么被使用,seq要么类似于令人厌恶的爆炸模式seq.例如:

f :: (Int -> Int) -> Bool
f g = g `seq` True

*Main> f undefined
*** Exception: Prelude.undefined
*Main> f (\x -> undefined)
True

该GHC评上seq说,

e1 `seq` e2 

过去常见的

case e1 of { _ -> e2 }

所以我尝试了手工制作.它不起作用:

f' g = case g of { _ -> True }

*Main> f' undefined
True
*Main> …

如何在Haskell中实现素数列表,以便可以懒惰地检索它们？

我是Haskell的新手,想了解懒惰评估功能的实际用途.

我有条件声明:

if($boolean && expensiveOperation()){ ...}

PHP是否具有惰性布尔评估,即它是否会检查$boolean以及是否为假而不执行昂贵的操作？如果是这样,我应该把我的变量放在什么顺序？

在Haskell中,经常提到与懒惰评估相关的术语脊柱严格性.虽然我对这意味着有一个模糊的理解,但对于以下方面有一个更具体的解释会更好:

• 什么是脊柱的数据结构
• 什么是脊柱严格呢？
• 将spine严格数据结构与惰性数据结构进行比较有什么好处？

是否存在与延迟加载相反的常用术语/ catch-phrase？

是否可以在Prolog中使用惰性列表？类似于以下内容:

ones([1 | Y]) :- ones(Y).

虽然这显然不起作用.

一个小麻烦dict.setdefault是它总是评估它的第二个参数(当然,当给出时),即使第一个参数已经是字典中的一个键.

例如:

import random
def noisy_default():
    ret = random.randint(0, 10000000)
    print 'noisy_default: returning %d' % ret
    return ret

d = dict()
print d.setdefault(1, noisy_default())
print d.setdefault(1, noisy_default())

这产生如下的ouptut:

noisy_default: returning 4063267
4063267
noisy_default: returning 628989
4063267

当最后一行确认时,第二次执行noisy_default是不必要的,因为此时密钥1已经存在于d(带有值4063267)中.

是否有可能实现一个子类,dict其setdefault方法懒惰地计算其第二个参数？

编辑:

以下是受BrenBarn评论和Pavel Anossov的回答启发的实现.在此期间,我继续实施了懒惰版本的get,因为基本的想法基本相同.

class LazyDict(dict):
    def get(self, key, thunk=None):
        return (self[key] if key in self else
                thunk() if callable(thunk) else
                thunk)


    def setdefault(self, key, thunk=None):
        return (self[key] if …

这一定非常简单.但无论如何我会问它,因为我认为其他人也会挣扎.为什么以下简单的LINQ查询不会始终使用新的变量值而不是始终使用第一个？

static void Main(string[] args)
{
    Console.WriteLine("Enter something:");
    string input = Console.ReadLine();       // for example ABC123
    var digits = input.Where(Char.IsDigit);  // 123
    while (digits.Any())
    {
        Console.WriteLine("Enter a string which doesn't contain digits");
        input = Console.ReadLine();         // for example ABC
    }
    Console.WriteLine("Bye");
    Console.ReadLine();
}

在注释的示例中,它将进入循环,因为输入ABC123包含数字.但它永远不会离开它,即使你输入类似ABC,因为digits仍然是123.

那么为什么LINQ查询不会评估新input值但始终是第一个？

我知道我可以通过这个附加线修复它:

while (digits.Any())
{
    Console.WriteLine("Enter a string which doesn't contain digits");
    input = Console.ReadLine();          
    digits = input.Where(Char.IsDigit);  // now it works as expected
}

或 …

我想实现一个无限的列表:

abstract class MyList[+T]
case object MyNil extends MyList[Nothing]
case class MyNode[T](h:T,t: => MyList[T]) extends MyList[T]

//error: `val' parameters may not be call-by-name

问题是call-by-name不允许的.

我听说这是因为val或者var不允许使用构造函数参数call-by-name.例如:

class A(val x: =>Int) 
//error: `val' parameters may not be call-by-name

但矛盾的是,正常的构造函数的参数仍然是val,尽管private.例如:

class A(x: =>Int) 
// pass

所以问题是:

• 问题真的是关于val还是var？
  • 如果说.由于按名称调用的要点是推迟计算,为什么不能call-by-name或val计算(或初始化)被推迟？
• 如何绕过cass类来实现无限列表？

我想请你向我提供一些文章(也许是书籍),你可能已经发现这些文章非常有说服力地批评了OOP方法.

我在WWW上读过一些关于这个主题的内容,但我并没有真正找到一个"明确的消极因素".

我对OOP的个人态度并不多,但我真的希望为任何讨论和抽象思维提供建设性,严谨的基础.

您也可以发布一些原创研究,但请非常有建设性(根据我的个人要求).