标签: lazy-evaluation

这里有什么不对,懒惰评价呢？

teste.hs

module Main where  

import Control.Parallel(par,pseq)  
import Text.Printf  
import Control.Exception  
import System.CPUTime  
import Data.List  
import IO  
import Data.Char  
import Control.DeepSeq  

--Calcula o tempo entre o inicio e o fim de rodagem do programa  
time :: IO t -> IO t  
time a = do  
    start <- getCPUTime  
    v <- a
    end   <- getCPUTime  
    let diff = (fromIntegral (end - start)) / (10^12)  
    printf "Computation time: %0.3f sec\n" (diff :: Double)  
    return v  

learquivo :: FilePath -> IO ([[Int]])  
learquivo …

我只是将我的一些代码更新到2.9.0,而且我遇到了一个问题.我有一个特性,我称之为"NonStrictIterable"(基本上,一切都应该尽可能地懒惰 - NonStrictIterable之外的代码本身不应该运行,直到某人实际要求一个元素).

但是在2.9.0中,我似乎无法覆盖flatMap.这是一个减少版本,显示错误:

import scala.collection.generic.CanBuildFrom

trait NonStrictIterable[A] extends Iterable[A] { self =>
  def iterator: Iterator[A]

  override def flatMap[B, That](f: A => TraversableOnce[B])(implicit bf: CanBuildFrom[Iterable[A], B, That]): That = {
    new NonStrictIterable[B] {
      def iterator = self.iterator flatMap { a: A => f(a).toIterable.iterator }
    }.asInstanceOf[That]
  }
}

这曾经在2.9.0之前工作,但现在我得到"方法flatMap覆盖任何东西".查看Iterable.flatMap的方法签名,我看到TraversableOnce类型签名已更改为enTraversableOnce.做出相应的改变

import scala.collection.GenTraversableOnce
import scala.collection.generic.CanBuildFrom

trait NonStrictIterable[A] extends Iterable[A] { self =>
  def iterator: Iterator[A]

  override def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Iterable[A], B, That]): That = { …

我正在读取数据库中的数据并将其放入DataRow.

我想测试一个可空布尔字段是否是Null或True.

如何在VB.NET中执行以下操作而不抛出Or操作符不能DBNull作为其操作数之一的异常？我可以强制执行懒惰的OR评估,这样只是评估IsNull并且不再继续吗？

If row.IsNull("MyNullableBooleanField") Or row("MyNullableBooleanField")

通过示例,有人可以证明懒惰评估与反应式编程有何不同.或者,它们非常相似吗？

鉴于c = 3;两种方法似乎都涉及b = c + 2;至少在内部实现,无论代码如何int b() {return c + 2;}.在这两种情况下,不知道b在需要其值之前是什么,然后进行计算.

描述这种方法的名称是什么？

因此,反应式编程使用或模拟惰性评估？懒惰评估的语言是以被动方式编程的？

考虑一下(Python 3.3):

a=enumerate([2,3,5])
print(list(a))
print(list(a))

你真的希望两个打印电话打印不同的东西吗？我也不.

如果用set/ tuple或替换列表,也会发生同样的事情dict.如果你enumerate用map或替换对象也会发生这种情况filter,但奇怪的是,如果你用它替换它range.

也许这是一个功能.但这是非常令人惊讶的,没有记录(至少我没有找到任何关于它的东西),而且不一致(范围的工作原理不同).你怎么看？

我做下一个作业=)我的任务是创建无限列表与斐波纳契数[0,1,1,2,3,5,8 ..]我可以使用Prelude中的任何函数.

我的尝试:

fibs2 :: [Integer]
fibs2 = reverse $ foldr f [1,0] [0..]
  where 
        f _ (x:y:xs) = (x+y):x:y:xs

此函数仅适用于有限列表,如[0..100],它给出了无限列表:

*** Exception: stack overflow

我做错了什么？如何制作"懒惰"功能？

更新 我的第二次尝试:

fibs4 = 0:[ b | (a, b) <- scanl (\(x,y) _ -> (y,x + y)) (0,1) [0..] ]

它运作正常.:)这是正常的还是奇怪的？

我有一个django模型，需要参考自定义用户模型进行一些处理。

在类加载时，我无法使用此模型的类，因为类的加载顺序是未知的。

因此，我需要在运行时添加一些类属性，此刻，我需要将它们添加到中__init__或__new__类似的地方：

def __new__(cls, *args, **kwargs):
    # hack to avoid INSTALLED_APPS initialization conflicts.
    # get_user_model() can't be called from this module at class loading time,
    # so some class attributes must be added later.
    # Metaclasses could me more appropiate but I don't want to override
    # dango's metaclasses.
    if not hasattr(cls, '_reverse_field_name_to_user'):
        cls._find_reverse_field_name_to_user()
    return Group.__new__(cls, *args, **kwargs)

它可以工作，但是看起来很可怕，所以我考虑过@lazyclassproperty对这些属性使用类似的东西。

我已经发现了几个@classproperty和@lazyproperty装修而不是一个两个，我不知道如何写一个自己。

问题：如何编码这样的装饰器？或建议另一种更清洁的方法替代我目前的愚蠢实施。

我编写了以下函数来判断数字是否为素数.

isPrime :: Int -> Bool
isPrime n = and (map (\x -> (n `mod` x > 0))[2..(intSquareRoot n)])

intSquareRoot :: Int -> Int
intSquareRoot n = intSq n
  where
    intSq x
      | x*x > n = intSq (x - 1)
      | otherwise = x

我刚刚开始使用Haskell,所以这段代码可能对任何受过使用训练的人都是可怕的.但是,我很好奇这段代码是否使用了Haskell的懒惰评估.这部分

(map (\x -> (n `mod` x > 0))[2..(intSquareRoot n)])

将创建一个布尔列表,如果只有其中一个是假的(所以如果一个介于2和n的sqrt之间的数字除以n)那么使用'和'函数整个事件是假的.但我认为将首先创建整个列表,然后使用'和'函数.这是真的？如果是这样,我怎样才能通过使用延迟求值来加快速度,以便函数停止并在找到n的第一个除数后返回false.在此先感谢您的帮助!

假设我们有一个字符串,1abcd1efg1hjk1lmn1并希望在1-s 之间找到东西.我们做的是

re.findall('1.*?1','1abcd1efg1hjk1lmn1')

得到两个结果

['1abcd1', '1hjk1']

好吧,我明白了.但如果我们这样做

re.findall('1.*?1hj','1abcd1efg1hjk1lmn1')

为什么它在1s而不是一个之间抓两个间隔？为什么我们得到['1abcd1efg1hj']而不是['1efg1hj']？这不是懒惰应该做的吗？

这是我的代码:

import Data.Function.Memoize
import Debug.Trace

foo :: Int -> Int -> Int
foo a = memoFix fooMemo where 
    fooMemo f x = a + (trace (show x) cont) where
        cont = if x == 0 then 0 else x + f (x - 1)

main = do
    print $ foo 0 5
    print $ foo 0 5
    print $ foo 0 5

我希望它打印:

3
2
1
0
6
6
6

但是,它打印出来:

3
2
1
0
6
3
2
1
0 …