标签: lazy-evaluation

public class myClass
{
   public myClass(String InstanceName)
   {
      Name = InstanceName;
   }
   public String Name { get; set; }
}

// Now using myClass lazily I have:

Lazy<myClass> myLazy;
Console.WriteLine(myLazy.Value.Name);

我的问题是当我们使用惰性实例时如何传递InstanceName给myClass构造函数？

浏览Hackage时,大多数monad都有Lazy和Strict版本.有什么区别？你能用一些常见的monad(State,Reader,Writer)的例子来突出它吗？

在编程的运动,它首先要求编程的阶乘函数,然后计算的总和:1! + 2! + 3! +... n!在O(n)乘法(所以我们不能直接使用阶乘).我不是在寻找这个特定(微不足道)问题的解决方案,我正在尝试探索Haskell的能力,这个问题是我想要玩的玩具.

我认为Python的生成器可以很好地解决这个问题.例如 :

from itertools import islice
def ifact():
    i , f = 1, 1
    yield 1
    while True:
        f *= i
        i += 1
        yield f

def sum_fact(n):
    return sum(islice(ifact(),5))

然后我试图弄清楚Haskell中是否有类似于这个生成器的行为,我认为懒惰会让所有员工都没有任何额外的概念.

例如,我们可以用我的Python ifact替换

fact = scan1 (*) [1..]

然后用以下方法解决练习:

sum n = foldl1 (+) (take n fact)

我想知道这个解决方案是否真的与Python关于时间复杂性和内存使用的"等效".我会说Haskell的解决方案永远不会存储所有列表事实,因为它们的元素只使用一次.

我是对还是完全错了？

编辑:我应该更准确地检查:

Prelude> foldl1 (+) (take 4 fact)
33
Prelude> :sprint fact
fact = 1 : 2 : 6 : 24 …

我需要类似于String.format(...)方法的东西,但是有懒惰的评估.

这个lazyFormat方法应该返回一些对象,其toString()方法将评估格式模式.

我怀疑有人已经这样做了.这可以在任何图书馆中找到吗？

我想替换它(logger是log4j实例):

if(logger.isDebugEnabled() ) {
   logger.debug(String.format("some texts %s with patterns %s", object1, object2));
}

有了这个:

logger.debug(lazyFormat("some texts %s with patterns %s", object1, object2));

只有在启用调试日志记录时,我才需要lazyFormat来格式化字符串.

在以下代码中:

ismaxl :: (Ord a) => [a] -> a -> Bool
ismaxl l x = x == maxel
           where maxel = maximum l

main = do
  let mylist = [1, 2, 3, 5]
  let ismax = ismaxl mylist
  --Is each call O(1)?  Does each call remember maxel?
  let c1 = ismax 1
  let c2 = ismax 2
  let c3 = ismax 3
  let c5 = ismax 5
  putStrLn (show [c1, c2, c3, c5])

部分函数是否为max,计算maxel？特别是,有人可以指出关于Haskell中部分函数的复杂性的规则吗？在上面的例子中,编译器必须只调用一次最大值吗？换句话说,部分函数是否保留了内部where子句的先前调用的引用？

我有一些CPU限制的代码不能令人满意,我正在寻找可能的错误,我的理由是复杂性.

这只是"我想知道......"问题中的一个.

Scala具有不可变数据结构和(可选)惰性值等.

Scala程序与完全纯粹(在函数编程意义上)和完全懒惰(或Ingo指出,它是否足够非严格)的程序有多接近？哪些价值观不可避免地变得多变,什么评价不可避免地贪婪？

我一直在研究在Perl 6中构造惰性列表的各种方法,我想收集描述Fibonacci序列的所有简洁方法.

我将从马萨克的期刊中的三个开始:

my @fibs := (0, 1, -> $a, $b { $a + $b } ... *);

my @fibs := (0, 1, { $^a + $^b } ... *);  

my @fibs := (0, 1, *+* ... *);

我认为这样的东西也会起作用,但我认为我的语法有误:

my @fibs := (0, 1, (@fibs Z+ @fibs[1..*]));

有什么东西急切(切片？)并导致Rakudo进入无限循环.它是Haskell定义的翻译:

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

更新:

看起来像zipWith示例的问题是@fibs[1..*]切片.if tail定义为sub tail (@x) {my $i = 1; {@x[$i++]}...*}然后它正常工作.我很想知道为什么切片对任何熟悉Rakudo内部的人来说都不是懒惰的.

另一个不错的是:

my …

如何在Haskell中的以下示例中对函数求值进行推理:

let f x = ...
    x = ...
in map (g (f x)) xs

在GHC,有时(f x)是对各元素只计算一次,有时一次xs,这取决于究竟f和g是.当f x计算成本昂贵时,这可能很重要.它刚刚绊倒了我正在帮助的Haskell初学者,我不知道该告诉他什么,除了它取决于编译器.还有更好的故事吗？

更新

在以下示例(f x)中将评估4次:

let f x = trace "!" $ zip x x
    x = "abc"
in map (\i -> lookup i (f x)) "abcd" 

我读了这个关于重命名对象的基本问题和@Shane对它的回答,指着我懒惰的评价.现在我想知道是否assign也懒得评价.就像这里一样:

assign("someNewName",someOldObject)
rm(someOldObject)

为什么我想知道这样做的原因是以下用例:假设我有10K + R对象各自有两个属性叫originalName和additionalName.现在我想编写一个函数,可以有效地让用户从一个名称切换到另一个名称,而不会丢失这两个属性.粗略喜欢这个......

编辑:基于@Hadley的输入我改变了我的代码.

switchObjectName <- function(x) {
  n1 <- attributes(x)$originalName
  n2 <- attributes(x)$additionalName
  objName <- deparse(substitute(x))
  if(objName == n1) {
    delayedAssign(n2,x,assign.env=.GlobalEnv)
  } else {
    delayedAssign(n1,x,assign.env=.GlobalEnv)
  }
  rm(list=c(objName),envir=.GlobalEnv)    
}

这种方法效果很好,但是我说这rm句话是正确的.rm(objName,envir=.GlobalEnv)虽然objName肯定是一个字符因为它是结果,但我试过但是无法使它工作deparse(substitute(x).

我现在已经多次出现这个错误了,我使用了不同的解决方法,但我真的很好奇它为什么会发生.基本情况如下:

class SomeClass {
  var coreDataStuff = CoreDataStuff!
  lazy var somethingElse = SomethingElse(coreDataStuff: coreDataStuff)
}

所以我理解我不能在类完全初始化之前使用self,但是在这种情况下我使用self属性coreDataStuff初始化一个懒惰的var,直到我的实例准备好才会发生.

任何人都可以解释我为什么会收到 Instance member can not be used on type错误？