标签: lazy-evaluation

我正在尝试使用Clojure完成SICP中的一些练习,但是我现在执行Simpson规则的方法出错(例如1-29).这与懒惰/急切的评估有关吗？有想法该怎么解决这个吗？错误和代码如下:

java.lang.ClassCastException:用户$ simpson $ h__1445无法在clojure.lang.Numbers.divide(Numbers.java:139)中强制转换为java.lang.Number

这是代码:

(defn simpson [f a b n]
  (defn h [] (/ (- b a) n))
  (defn simpson-term [k]
    (defn y [] (f (+ a (* k h))))
    (cond 
      (= k 0) y
      (= k n) y
      (even? k) (* 2 y)
      :else (* 4 y)))
  (* (/ h 3)
     (sum simpson-term 0 inc n)))

我有5000个矢量,保存在5000个文件中.我需要找到他们的总和.DF2类型只是Vector DoubleNum 的同义词,并且是Num的一个实例.所以我读取并解析所有要列出的文件[IO DF2]并将其折叠:

getFinal :: IO DF2
getFinal = foldl1' (liftA2 (+)) $ map getDF2 [1..(sdNumber runParameters)]
    where getDF2 i = fmap parseDF2 $ readFile ("DF2/DF2_" ++ show i)

但是我收到一个错误:

DF2: DF2/DF2_1022: openFile: resource exhausted (Too many open files)

谷歌透露这个问题很常见:

• Haskell懒惰的I/O和关闭文件
• 处理(也)许多XML文件(使用TagSoup)

但是,我没有得到懒惰IO的问题.如果它是懒惰的,那为什么它在需要之前打开文件？我不明白如何使Duncan Coutts 的优雅解决方案适应我的情况.

模型:

class Author{
   String name
   static hasMany = [books: Book]    
}

class Book{
  String name
  Author author

  static belongsTo = Author
}

然后我有一个控制器

class MyController{
  def authors{
     def authors = Author.getAll()
     render authors as JSON
  }

问题是,即使Author-Books关联是懒惰的,也会执行N + 1个查询以急切地获取每个作者的书籍.它发生了什么以及如何禁用它

我一直听说C#使用懒惰评估.因此,对于某些代码,if (true || DoExpensiveOperation()将返回true而不执行DoExpensiveOperation().

在面试测试中,我看到了以下问题,

static bool WriteIfTrue(bool argument)
{
    if (argument)
    {
        Console.WriteLine("argument is true!");
    }

    return argument;
}

static void Main()
{
    // 1              0                       0                 1
    WriteIfTrue((WriteIfTrue(false) & WriteIfTrue(true)) || WriteIfTrue(true));

    // 1               1                     0                      1
    WriteIfTrue((WriteIfTrue(true) || WriteIfTrue(false)) & WriteIfTrue(true));

    //  0                 0                  0                    0
    WriteIfTrue((WriteIfTrue(false) & WriteIfTrue(true)) & WriteIfTrue(false));

    // 1                1                      0                   1
    WriteIfTrue((WriteIfTrue(true) || WriteIfTrue(false)) & WriteIfTrue(true));
}

打印多少次"论证是真的!" 到屏幕？

我会说7是正确的答案.现在,如果我坚持使用编译器并运行它,它会打印出来的10次数!懒惰的评价哪里出错了？

如果我对一个类型只有一个构造函数的表达式进行模式匹配,那还是会强制运行时将表达式计算为WHNF吗？

我做了一个似乎表明它没有评估的实验:

Prelude> data Test = Test Int Int
Prelude> let errorpr () = error "Fail"
Prelude> let makeTest f = let (x,y) = f () in Test x y
Prelude> let x = makeTest errorpr
Prelude> let Test z1 z2 = x
Prelude> :sprint z1
z1 = _
Prelude> :sprint z2
z2 = _
Prelude> :sprint x
x = _

我本来希望得到一个错误或:sprint x得到

x = Test _ _

但事实并非如此.

显然我不明白"让"是如何运作的.请参阅以下答案

问题的标题说明了一切.在C#表达式中a ?? b,b始终是求值,还是仅在a求值时null？

我对此感到好奇,因为在评估右侧表达可能有副作用或评估可能计算成本高昂的情况下,这可能很重要.

要更改信号的采样率,需要进行上采样,滤波,然后进行下采样.天真地这样做意味着在输入信号中插入零,与滤波器的脉冲响应相关,然后丢弃除n卷积的每个样本之外的所有样本.

天真方法的问题在于存在许多无用的计算.当与滤波器卷积时,大多数滤波器抽头乘以零,并且计算将在下采样阶段丢弃的样本的值是无用的.这就是为什么有效的合理重采样使用多相滤波器组,其中仅执行所需的计算.

我想知道是否可以使用延迟计算来避免无用的乘法,同时还避免明确地构造多相滤波器组.我理想的解决方案是类似于天真的方法(上采样,然后相关,然后下采样),但做了与显式多相滤波器方法相同的计算.

下采样很容易,因为不需要计算不需要的值.但我无法弄清楚如何避免相关部分中的乘数为零.我提出的最好的方法是使用Maybe类型和上传样本与Nothings(而不是零):

upsample n xs = upsample2' n xs 0
    where upsample' _ [] _ = []
          upsample' _ (x:_) 0 = Just x : upsample' n xs n
          upsample' n xs counter = Nothing : upsample' n xs (counter - 1)

correlate xs ys = sum $ catMaybes $ zipWith (fmap . (*)) xs ys

firFilter taps signal = map (correlate taps) (tails signal)

downsample _ [] = []
downsample n (x:xs) = x : …

我有以下数据可以发货或不发货:

data LaserCollisionResult = NoCollision | LaserToLaserCollision Ship | LaserToShipCollision Ship deriving (Eq, Show)

然后,稍后,我试图检查LaserCollisionResult是否为LaserToLaserCollision类型,但是我收到错误.我的[lambda]功能是这样的:

laserPaths' = map (\(p,r) -> if r == LaserToLaserCollision then doSomethingWith p else p) $ zip laserPaths laserCollisionResults

我得到的错误是:

Couldn't match type 'LaserCollisionResult' with 'Ship -> LaserCollisionResult'
Expected type: [Ship -> LaserCollisionResult]
Actual type: [LaserCollisionResult]
In the second argument of 'zip', namely laserCollisionResults.

如何检查laserCollisionResults中的LaserCollisionResult是否属于LaserToLaserCollision类型？

我想从流中收集前n个元素,而不是遍历整个事物.是否有标准方法可以做到这一点？翼

MyList.stream()
  .filter(x -> predicate(x))
  .findFirstN(100)

会从流中返回最多100个元素的集合吗？我的另一种方法是评估整个流,然后从结果中进行采样,但这并没有利用流固有的惰性评估.

这里有全新的Haskell程序员.刚刚完成"了解你一个Haskell"......我对一个有多大特定属性的集合感兴趣.我有一些小参数值的代码,但我想知道如何处理更大的结构.我知道Haskell可以做"无限的数据结构",但我只是没有看到如何从我所在的位置到达那里并且了解一个Haskell/Google并没有让我了解这一点.

这里的工作代码为我eSet定的"小"的论点r和t

import Control.Monad
import System.Environment
import System.Exit

myPred :: [Int] -> Bool
myPred a = myPred' [] a
    where
        myPred' [] []         = False
        myPred' [] [0]        = True
        myPred' _  []         = True
        myPred' acc (0:aTail) = myPred' acc aTail
        myPred' acc (a:aTail)
             | a `elem` acc   = False
             | otherwise      = myPred' (a:acc) aTail

superSet :: Int -> Int -> [[Int]]
superSet r t = replicateM r [0..t]

eSet :: Int -> …