标签: lazy-evaluation

我对发电机的概念仍然有点朦胧.我想创建一个生成器函数,它接收两个数字数组并在相应的索引处添加值.我有一些有用的东西,我只是不确定我是否正确地使用惰性评估(即正确使用生成器).有人能告诉我这是否确实是使用发生器的正确方法,或者如果我做错了就纠正我？

def add(a1,a2):
    i = 0
    while i < len(a1):
        yield a1[i]+a2[i]
        i += 1

我正在使用类似的东西来定义SQL插入命令:

sql := 'insert into table(a, b, c) values (' + formatfunction(a) + ', ' + 
                                               formatfunction(b) + ', ' +
                                               formatfunction(c) + ');';

在赋值之后,变量sql以不同的顺序包含a,b,c的格式化值,结果如下所示:

insert into (a, b, c) values ??('value in c', 'value in a', 'value in b');

可能是编译器优化的一些问题？

抱歉可怜的示例代码,完整的可执行代码如下:

procedure Execute(var v : String);
  function ExtractValue(var Content: String; Separator: Char = '|'): String;
  var
    vpHead,
    vpTail,
    vpContent: PChar;
    vsValor: String;
  begin
    vpContent := PChar(Content);
    Result := '';
    if (vpContent = nil) or
       (vpContent^=#0) then
      Exit;
    vpTail := …

试图在SO上的这个问题之后合并F#中的两个LazyLists .最初为匹配两个列表而写.修改后得到这个:

let rec printLazyList (l1:LazyList<int>) (l2:LazyList<int>) =
    match (l1, l2) with
        | t, s when t |> LazyList.isEmpty && s |> LazyList.isEmpty -> printfn "";
        | t , LazyList.Cons(h2,t2) when t |> LazyList.isEmpty -> printf "%d " h2 
                                                                 let a = LazyList.empty 
                                                                 printLazyList a t2
        | LazyList.Cons(h1,t1), s when s |> LazyList.isEmpty -> printf "%d " h1 
                                                                let b = LazyList.empty 
                                                                printLazyList t1 b
        | LazyList.Cons(h1,t1), LazyList.Cons(h2,t2) -> if h1 = h2 then 
                                                            printf "%d " h1 …

我已经比较了懒惰堆栈和非惰性堆栈实现:http://en.wikibooks.org/wiki/F_Sharp_Programming/Advanced_Data_Structures#Lazy_Data_Structures

在本文中它说,append函数对于惰性函数是O(1)而对于非惰性函数是O(n).但是在程序下面运行表明,懒惰堆栈的速度是非懒惰堆栈的两倍.可能是什么原因造成的？

type lazyStack<'a> = 
    | Node of // return an integer exit code
              Lazy<'a * 'a lazyStack>
    | EmptyStack

module LazyStack = 
    let (|Consx|Nil|) = 
        function 
        | Node(item) -> 
            let hd, tl = item.Force()
            Consx(hd, tl)
        | EmptyStack -> 
            Nil

    let hd = 
        function 
        | Consx(hd, tl) -> hd
        | Nil -> failwith "empty"

    let tl = 
        function 
        | Consx(hd, tl) -> tl
        | Nil -> failwith "empty"

    let cons (hd, tl) = Node(lazy (hd, tl)) …

我想有一个懒惰生成的随机数列表,我设法做到但是unsafeInterleaveIO:

rs :: Random a => (a,a) -> IO [a]
rs b = do
  r <- randomRIO b
  ns <- unsafeInterleaveIO $ rs b
  return (r:ns)

有没有安全的方法来实现这种价值观？

是否有任何编程语言实现逻辑运算的参数交换(例如AND,OR)以便更快地进行评估？

示例(我认为这种方法可以用像Haskell这样的惰性评估语言实现)

1. 让我们说我们已经定义了两个谓词A和B.
2. 在程序执行期间,B评估为"True"并且A未评估
3. 在后来的执行中我们有条件 IF A OR B
4. 交换"OR"的参数,条件变为 IF B OR A
5. 在不进行评估的情况下将条件评估为"真" A

我有这个功能：

generatePrimes :: Integral a => a -> [a]
generatePrimes n = [i | i <- [2..], isPrime i]

我正在尝试获得前n 个素数。我知道我可以main通过使用take函数来调用函数（并获取列表的前n 个元素），但是我希望能够在函数达到n 个素数时停止（在函数内部），这样当它被称为main：

generatePrimes 8

它将显示一个只有前 8 个素数的列表。

Haskell noob在这里:我仍然试图理解语言的机制,所以如果我的问题很简单,请原谅我并指出一些我可以学习的链接(我在stackoverflow上搜索了类似主题的一段时间) ,但我仍然无法得到这个).

我出来了这个功能:

chunks :: Int -> [a] -> [[a]]
chunks n xs
    | length xs <= n = [xs]
    | otherwise = let (ch, rest) = splitAt n xs in ch:chunks n rest

以便

ghci> chunks 4 "abracadabra"
["abra","cada","bra"]
ghci> 
ghci> chunks 3 [1..6]
[[1,2,3],[4,5,6]]

我对此感到非常满意,然后我认为"有懒惰的评价!我甚至可以在无限序列中使用它!".所以我试过了take 4 $ chunks 3 [1..].我希望懒惰的haskell魔法会产生[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]],相反,似乎这次懒惰无法帮助我:它无法达到计算的结束(它是否一路走到最后[1..]？)

我认为问题出在"长度xs"部分:ghci似乎也陷入了一个简单的问题length [1..].所以我问:长度实际上是在迭代整个列表以给出响应吗？如果是这样,我想每次我尝试使用懒惰评估实现一些正常工作时,应该避免长度,所以有一些替代方案吗？(例如,如何改进我的示例以使用无限列表？)

我有以下代码用于在python 3.5中延迟计算值。我也尝试过用@cached_property 装饰器获得相同的结果，因此为了简单起见，我将使用它。

class Foo:    
    @property
    def expensive_object(self):
        if not hasattr(self, "_expensive_object"):            
            print("Lengthy initialization routine")
            self._expensive_object = 2
        return self._expensive_object           

问题在于，即使我最终没有在内部使用它，当我将其作为函数的参数传递给它时，它也会被评估，如以下示例所示：

def bar(some_parameter, another_parameter):
    if some_parameter != 10:
        print(some_parameter)
    else:
        print(another_parameter)

从下面的输出中，我们看到它只是通过传递而得到评估的，但是由于代码没有尝试使用它，因此它不是严格必需的。

In [23]: foo1 = Foo()
    ...: bar(3, foo1.expensive_object)
         Lengthy initialization routine
         3

In [24]: bar(3, foo1.expensive_object)
         3

在某些情况下，我的脚本可以运行而无需评估，但由于这种情况，最终还是要这样做。排除参数也是不实际的。我还在__init__组合成员对象中使用它。

如果可能的话，我想使该属性更加懒惰，因为它仅在实际读取时才进行评估。

由于缺乏更好的词汇,我选择了这个头衔.

我想要的是能够做这样的事情:

>>> from random import randint
>>> fruits = [
...     "Orange",
...     "Banana",
...     f"{randint(2,5)} Cherries",
... ]

>>> fruits[2]
'3 Cherries'

>>> fruits[2]
'5 Cherries'

>>> fruits[2]
'2 Cherries'

但相反,字符串中的文字表达式在创建列表时会被评估一次,并在每次访问时得到相同的结果.

我想知道除了编写一些复杂的边缘案例处理之外是否还有一种更容易/更聪明的方法来解决这个问题(毕竟我们是程序员;谁不喜欢编写漂亮的代码并且优雅和喜欢？).我说的是边缘案例处理,因为我的49个字符串中只有6个需要这种"特殊"行为.

到目前为止我所尝试的是从randint调用中创建一个lambda函数,但这并没有帮助; 同样的结果.也许这是懒惰评估的一个案例,但我需要一些指导如何(或是否？)将它与列表一起使用.