标签: lazy-evaluation

如何使用该代码获得斐波纳契数列的总和:

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

编辑:取5个fibs给出[0,1,1,2,3]的列表,所以第5个元素的值是3,要提取它我们必须输入:'last(take(5 fibs))'我们得到等等

如果我们使用解释器来寻找第5个元素我们得到[0,1,2,3]的列表,最后一个元素与第5个元素的值相同,如何获得该列表的LAST元素？我可以'使用它' last,你有什么想法,可以吗？

我复制了(http://www.haskell.org/haskellwiki/Euler_problems/11_to_20#Problem_11)上给出的Euler.11解决方案,但它失败并出现索引错误:" (Array.!):undefined array element ".当然首先我想要一个更好的错误消息(!),甚至可能给出失败的索引,但是我没有尝试调试它.

数据输入正确,打印数据显示正确的边界和数据.

所以我在结果表达式和理解体中添加了一些跟踪消息.我从最终表达式中获得了大量的跟踪结果,但是没有来自主体计算的结果.为什么？

prods :: Array (Int, Int) Int -> [Int]
-- trace ("xs: " ++ show xs) (product xs)
prods a = [trace ("xs: " ++ show xs) (product xs) | i <- range $ bounds a,
                        s <- senses,
                        let trace1 = check "i: " i,
                        let is = take 4 $ iterate s i,
                        let trace2 = check "is: " is,
                        all (inArray a) is,
                        let xs = map (a!) is] …

我面临以下问题:

从初始集[1,2,3,4]计算所有可能的子集,即[[1],[2],[3],[4],[1,2],[1,3],[1,4],[2,3],[2,4],[3,4],[1,2,3],[1,2,4],[1,3,4],[2,3,4],[1,2,3,4]]

我编写了以下Haskell程序generate.hs,这是正确的.

generateSets :: Eq a => [a] -> [[a]] -> [[a]] -> [[a]]
generateSets []  _  _  = []
generateSets src [] _  = let isets = growthup [] src in generateSets src iset iset
generateSets src sets rsets = if null sets' then rsets else generateSets src sets' (rsets++sets')
  where sets' = concatMap (flip growthup src) sets

growthup :: (Eq a) => [a] -> [a] -> [[a]]
growthup ps ss = map …

在C/C++中,我们使用指针和类似的东西在解析大量字符时节省内存.Haskell会使用同样的东西吗？我已经看到一些解析器实现接受/返回Haskell中的"要解析的剩余字符" - 编译器是否负责传递大量内存？提前致谢!

最近,我遇到了一段这样的代码(不是真正的代码,而是一个基于它的简短示例):

#include <stdio.h>

int main()
{
  int n;

  printf ("n? ");  
  scanf ("%d", &n);

  n%2 && printf ("N is odd\n");  /* <-- this is it */

  return 0;
}

如果有人没有得到它,这段代码相当于:

int main()
{
  int n;

  printf ("n? ");  
  scanf ("%d", &n);

  if (n%2) 
    printf ("N is odd\n");

  return 0;
}

对于x86-64位,使用GCC 4.4.5-8编译的此代码的反汇编为此部分提供了n评估并printf()有条件地调用的部分:

        andl    $1, %eax
        testb   %al, %al
        je      .L3
        movl    $.LC2, %eax
        movq    %rax, %rdi
        movl    $0, %eax
        call    printf
        testl   %eax, %eax
.L3:
        movl …

据我所知,在scala中,def用于使表达式被懒惰地评估.

例如:

var num=123;
def  i=10000+num;
print(i); 
//result 1: ouput 10123

num=456
print(i) 
//result 2: output 10456

var num=789
print(i)
//result 3: output 10456

我的问题是,之后var num=789为什么def i=10000+num没有被评估为10789.

我想在重新声明变量num后var num=789,scala重新创建符号表中具有相同符号num的其他项.

我对吗？为什么rsult 3输出10456而不是10789.

谢谢.

我必须将以下lambda表达式减少为WHNF,但我不太清楚如何做到这一点:

(?x y. x 3) (+ 4) (+ 6 7)

那么,我该怎么做？呼叫减少名称？

这个表达式(其他例子)(?z x. (?x. x) z) x在WHNF中了吗？

我试图理解为什么第一个main在无效时终止c,而第二个终止.从描述来看,这 main只是一个未经评估的thunk,executing它只是构建数据结构.我试图在这里应用相同的原理,看看为什么第一个主要没有终止.如果有人可以帮助我理解这一部分,或者给我指点理解这将是伟大的.除此之外,为什么GHCI无法将其识别为TCO？不符合定义吗？

main = loop                                                                     
  where                                                                         
   loop =  do                                                                   
     c <- getChar                                                               
     case valid c of                                                            
       Nothing -> return ()                                                     
       Just b  -> print b                                                       
     print c                                                                    
     loop                                                                       

> main :: IO ()
> main = loop
>   where
>   loop =  do
>     c <- getChar
>     case validate c of
>       Nothing -> return ()
>       Just b  -> do
>         print b
>         loop

谢谢.

我正在做一些Java 8流的"代数",也就是说,我正在尝试编写一个简单的操作Op,它将两个流作为输入并产生另一个流.

所以我有这个简单的代码,其目的是在一系列数字中打印secund最高值:

import java.util.Arrays;
import java.util.stream.IntStream;

public class SecundHighestValue {

    public static void main(String[] args) {

        //setting the input parameters
        int [] numbers = {1, 2, 3, 4, 3, 4, 2, 1};

        IntStream S1 = Arrays.stream(numbers);
        IntStream S2 = Arrays.stream(new int[] {Arrays.stream(numbers).max().getAsInt()} );

        // setting the operation
        IntStream S3 = S1.filter(x-> x != S2.toArray()[0]); // doesn't work

        /*** does work  ***
        int  maxNumber = S2.toArray()[0];
        IntStream S3 = S1.filter(x-> x != maxNumber);
        */

        // accessing the operation's result stream …

是否something <- stuff总是在Haskell中评估类似的语句,即使something在其余代码中没有调用它？(被something <- stuff称为"行动"？ - 我不知道技术措辞).

如果这是真的,我还有另外一个问题.

我有一些代码从这样开始:

computeContour3d voxel voxmax level = do
    voxelmax <- somefunction voxel
    let max' = fromMaybe voxelmax voxmax

也就是说,如果参数voxmax不是Nothing,则voxelmax没有必要,因为max' = fromJust voxmax在这种情况下.因此,如果我的第一个问题的回答是"是",我怎么能避免评估voxelmax何时没有必要？