标签: lazy-evaluation

我有一个像这样的Django my_forms.py:

class CarSearchForm(forms.Form):  
    # lots of fields like this
    bodystyle = forms.ChoiceField(choices=bodystyle_choices())  

每种选择都是例如("Saloon","Saloon(15辆汽车)").所以选择是由这个函数计算的.

def bodystyle_choices():  
    return [(bodystyle.bodystyle_name, '%s (%s cars)' %  
          (bodystyle.bodystyle_name, bodystyle.car_set.count()))  
          for bodystyle in Bodystyle.objects.all()]

我的问题是,每次我只导入my_forms.py时,选项函数都会被执行.我认为这是由于Django声明其字段的方式:在类中但不在类方法中.哪个没问题,但我的views.py导入了my_forms.py,因此无论使用哪个视图,都会对每个请求进行选择查找.

我认为也许选择= bodystyle_choices没有括号会起作用,但我得到:

'function' object is not iterable

显然我可以使用缓存并将"import my_forms"放在所需的视图函数中,但这并没有改变主要观点:我的选择需要是懒惰的!

有谁知道一种真正的声明性语言？我正在寻找的行为类似于Excel所做的,我可以在哪里定义变量和公式,并在输入发生变化时更改公式的结果(没有自己再次设置答案)

我正在寻找的行为最好用这个伪代码显示:

X = 10     // define and assign two variables
Y = 20;

Z = X + Y  // declare a formula that uses these two variables

X = 50     // change one of the input variables

?Z         // asking for Z should now give 70 (50 + 20)

我已经尝试过很多语言,比如F#,python,matlab等,但是每次尝试这个都会得到30而不是70.从命令的角度来看,这是正确的,但我正在寻找一个如果你知道我的意思,更多的角色行为.

这只是一个非常简单的计算.当事情变得更加困难时,它应该自动处理诸如递归和memoization之类的东西.

下面的代码显然可以在C#中运行,但它只是为了工作的代码,我正在寻找更多的东西,没有那些"技术噪音"

class BlaBla{
    public int X {get;set;}  // this used to be even worse before 3.0
    public int Y {get;set;}
    public int Z {get{return X + Y;}}
} …

我有很多功能:

String first(){}
String second(){}
...
String default(){}

每个都可以返回一个空值,默认值除外.每个功能可以采用不同的参数.例如,第一个可以不带参数,第二个可以接受一个字符串,第三个可以接受三个参数,等等.我想做的是:

ObjectUtils.firstNonNull(first(), second(), ..., default());

问题在于,由于函数调用,这需要进行急切的评估.我想早点退出,在第二个函数之后说(因为函数调用可能很昂贵,想想API调用等).在其他语言中,您可以执行与此类似的操作:

return first() || second() || ... || default()

在Java中,我知道我可以做类似的事情:

String value;
if (value = first()) == null || (value = second()) == null ...
return value;

由于所有的== null检查,这不是非常易读的IMO.ObjectUtils.firstNonNull()首先创建一个集合,然后迭代,只要该函数被懒惰地评估,这是可以的.

建议？(除了做一堆ifs)

背景:我有一系列连续的,带时间戳的数据.数据序列中有孔,有些大,有些只有一个缺失值.
每当孔只是一个缺失值时,我想使用虚拟值修补孔(较大的孔将被忽略).

我想使用延迟生成修补序列,因此我使用Seq.unfold.

我已经制作了两个版本的方法来修补数据中的漏洞.

第一个消耗带有孔的数据序列并产生修补序列.这就是我想要的,但是当输入序列中的元素数量超过1000时,方法运行得非常慢,并且输入序列包含的元素越多,它就会越来越差.

第二种方法使用带有孔的数据列表并生成修补序列并且运行速度很快.然而,这不是我想要的,因为这会强制整个输入列表在内存中的实例化.

我想使用(sequence - > sequence)方法而不是(list - > sequence)方法,以避免在内存中同时存在整个输入列表.

问题:

1)为什么第一种方法如此缓慢(使用较大的输入列表逐渐变得更糟)(我怀疑它与使用Seq.skip 1重复创建新序列有关,但我不确定)

2)如何使用输入序列而不是输入列表快速修补数据中的空洞？

代码:

open System

// Method 1 (Slow)
let insertDummyValuesWhereASingleValueIsMissing1 (timeBetweenContiguousValues : TimeSpan) (values : seq<(DateTime * float)>) =
    let sizeOfHolesToPatch = timeBetweenContiguousValues.Add timeBetweenContiguousValues // Only insert dummy-values when the gap is twice the normal
    (None, values) |> Seq.unfold (fun (prevValue, restOfValues) ->  
        if restOfValues |> Seq.isEmpty then
            None // Reached the …

我编写了一个小的Haskell程序来打印当前目录中所有文件的MD5校验和(递归搜索).基本上是Haskell版本的md5deep.一切都很好,花花公子,除非当前目录有大量的文件,在这种情况下,我收到如下错误:

<program>: <currentFile>: openBinaryFile: resource exhausted (Too many open files)

似乎Haskell的懒惰导致它不会关闭文件,即使在相应的输出行已经完成之后也是如此.

相关代码如下.感兴趣的功能是getList.

import qualified Data.ByteString.Lazy as BS

main :: IO ()
main = putStr . unlines =<< getList "."

getList :: FilePath -> IO [String]
getList p =
    let getFileLine path = liftM (\c -> (hex $ hash $ BS.unpack c) ++ " " ++ path) (BS.readFile path)
    in mapM getFileLine =<< getRecursiveContents p

hex :: [Word8] -> String
hex = concatMap (\x -> printf "%0.2x" …

我正在学习Haskell Lazy IO.

我正在寻找一种优雅的方式来复制大文件(8Gb),同时将复制进度打印到控制台.

请考虑以下以静默方式复制文件的简单程序.

module Main where

import System
import qualified Data.ByteString.Lazy as B

main = do [from, to] <- getArgs
          body <- B.readFile from
          B.writeFile to body

Imgine有一个你想用于报告的回调函数:

onReadBytes :: Integer -> IO ()
onReadBytes count = putStrLn $ "Bytes read: " ++ (show count)

问题:如何将onReadBytes函数编织到Lazy ByteString中,以便在成功读取时调用它？或者如果这个设计不好,那么Haskell的做法是什么？

注意:回调的频率并不重要,可以每1024字节或每1Mb调用一次 - 不重要

答案:非常感谢camccann的答案.我建议完全阅读.

Bellow是基于camccann代码的代码版本,您可能会发现它很有用.

module Main where

import System
import System.IO
import qualified Data.ByteString.Lazy as B

main = do [from, to] <- getArgs
          withFile from ReadMode $ …

所以,我正在努力自学Scala,而我一直在玩的其中一件事就是Stream上课.我试图使用经典的Haskell版本的Dijkstra解决汉明数字问题的天真翻译:

object LazyHammingBad {
  private def merge(a: Stream[BigInt], b: Stream[BigInt]): Stream[BigInt] =
    (a, b) match {
      case (x #:: xs, y #:: ys) =>
        if (x < y) x #:: merge(xs, b)
        else if (y < x) y #:: merge(a, ys)
        else x #:: merge(xs, ys)
    }

  val numbers: Stream[BigInt] =
    1 #:: merge(numbers map { _ * 2 },
      merge(numbers map { _ * 3 }, numbers map { _ * 5 }))
}

以此为代表解释,导致很快失望: …

我有一个懒惰ByteString的函数,我希望有严格的ByteStrings返回列表(懒惰应该转移到输出的列表类型).

import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as L
csVals :: L.ByteString -> [B.ByteString]

我想因各种原因这样做,有几个lexing函数需要严格的ByteStrings,我可以保证ByteStrings输出中csVal的输出严格s 非常小.

如何在ByteString没有分块的情况下进行"严格化" ？

Update0

我想采取一个懒惰ByteString,并使一个严格ByteString包含其所有数据.

我想知道初始化类成员的python方法是什么,但只有在访问它时才会访问它.我尝试了下面的代码并且它正在运行,但有什么比这简单吗？

class MyClass(object):

    _MY_DATA = None

    @staticmethod
    def _retrieve_my_data():
        my_data = ...  # costly database call
        return my_data

    @classmethod
    def get_my_data(cls):
        if cls._MY_DATA is None:
            cls._MY_DATA = MyClass._retrieve_my_data()
        return cls._MY_DATA

我在ghci中为偶数和奇数定义了两个相互递归的列表,如下所示:

> let evens = 0:map (+1) odds; odds = map (+1) evens

然后我使用了咨询thunk :sp

> :sp evens
evens = _
> :sp odds
odds = _
> take 5 evens
[0,2,4,6,8]
> :sp evens
evens = 0 : 2 : 4 : 6 : 8 : _
:sp odds
odds = _

注意odds虽然evens已经评估了第5个元素,但是如何评估thunk .我可以想到一个直观的解释.odds必须显式调用才能进行评估:

> take 5 odds
[1,3,5,7,9]
>:sp odds
odds = 1 : 3 : 5 : 7 : 9 : …