在Haskell中生成无限序列
在Haskell中生成无限序列可以通过使用replicate函数实现。replicate函数可以将一个数据类型重复n次，并返回一个包含重复数据的列表。例如，我们可以使用以下代码生成一个包含10个0的无限序列：
mySeq = replicate 10 0我们也可以使用iterate函数来生成无限序列。iterate函数将一个函数应用于一个初始值，并返回一个包含该值应用结果的列表。例如，我们可以使用以下代码生成一个包含10个1的无限序列：
mySeq = iterate (1+) 0此外，我们还可以使用forever函数来生成一个无限序列。forever函数将一个函数应用于一个初始值，并返回一个无限序列的生成器。例如，我们可以使用以下代码生成一个包含10个1的无限序列：
mySeq = forever (1+)这些是使用Haskell生成无限序列的一些方法。
相关·内容
我见过许多Haskell程序，当用户输入5时，它将返回Fibonacci序列的前5个元素，然而，我需要它只输出小于或等于5的Fibonacci序列的值。 例如: Fib 15需要输出1 1 2 3 5 8 13 Fib 7需要输出1 1 2 3 5 这就是我正在尝试修改的，输出到给定值，而不是给定的索引： -- individual fib numbers
fib :: Int -> Int
fib 0 = 1
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
-- example run fib
浏览 12提问于2021-08-03得票数 1
回答已采纳
2回答
当我在迭代器中迭代时，我想跟踪索引。在Haskell中，我可以使用无限个整数列表[1..]来压缩迭代器。但是，我不知道Python中有这样的功能。构建如下所示迭代器的最简单方法是什么？
for (case,i) in zip(data, magic_infinite_list):
print('Case #{}: {}'.format(i,case))
(我知道我可以做一个变量i并手动增加它，这不是重点--我想知道是否可以用迭代器做到这一点)
浏览 2提问于2017-03-30得票数 3
回答已采纳
8回答
我使用Haskell已经有很长一段时间了，我已经阅读了现实世界haskell的大部分内容，并向您学习了Haskell。我想知道的是，使用惰性计算的语言是否有意义，特别是具有无限列表的“优势”，是否有无限列表使任务变得非常容易，或者甚至是只有使用无限列表才能完成的任务？
浏览 3提问于2010-12-20得票数 4
回答已采纳
在一个模拟问题中，我需要生成数千个独立的代理对象。为此，我需要向每个代理传递一个不同的随机数生成器。在Haskell怎么做？在像C这样的语言中，我可以在需要的时候生成一个随机数，但在Haskell中，我只需要在IO monad中才能生成随机数。代理在完全纯计算中的行为。
我现在是这样做的：
import System.Random
main = do
gen1 <- newStdGen
let rands1 = randoms gen :: [Int]
gen2 <- newStdGen
let rands2 = randoms gen :: [Int]
浏览 1提问于2016-10-18得票数 4
回答已采纳
3回答
无限长列阵
、、
我在Haskell中注意到一件事，它非常容易地有效地处理无限长数组。
所以作为一个快速程序员，，我很好奇我们如何才能用来实现这个目标。
例如：
var infiniteArray = [1,2,3,.............]
浏览 7提问于2016-12-29得票数 7
回答已采纳
3回答
非平凡的延迟评估
、、
我现在正在消化好的演示文稿，为什么要学习Haskell？作者声明: McAllister；在那里他用的是片段
minimum = head . sort
作为哈斯克尔懒惰评估的一个例子，它指出minimum在Haskell中具有时间复杂度O(n)。然而，我认为这个例子在性质上是学术性的。因此，我想要一个更实际的例子，在这个例子中，大多数中间计算都被丢弃了，这并不是微不足道的。
浏览 0提问于2011-10-23得票数 33
回答已采纳
3回答
用F#中的守卫在Haskell中实现类似的列表理解功能的方法是什么
例如：
factors :: Int -> [Int]
factors = [x | x <-[1 .. n], n 'mod' x == 0]
factors 15
[1,3,5,15]
和
posInt :: Int -> [Int]
posInt = [n | n > 0]
posInt 5
[5]
posInt 0
[]
浏览 2提问于2009-12-18得票数 3
回答已采纳
6回答
一些语言(Haskell、Clojure、Scheme等)有懒惰的评估。惰性计算的“卖点”之一是无限的数据结构。这有什么好的呢？在哪些情况下，能够处理无限数据结构显然是有优势的？
浏览 20提问于2011-03-13得票数 26
回答已采纳
2回答
我需要表达素数的序列。(与Euler项目中的ex 3作斗争)。
我遇到了这个递归定义：
is_not_dividable_by :: (Integral a) => a -> a -> Bool
is_not_dividable_by x y = x `rem` y /= 0
accumulate_and :: (Integral a) => [a] -> (a -> Bool) -> Bool
accumulate_and (x:xs) (f) = (accumulate_and xs (f)) && f(x)
accumulate
浏览 4提问于2014-09-13得票数 2
回答已采纳
2回答
Haskell具有挑战性！到目前为止，我想要做的是，我可以执行以下操作来模拟Haskell中的for循环，以从用户那里获得一个数字列表：
myList <- sequence [putStr "Enter an integer: " >> (
\s -> read s :: Int) <$> getLine | t <- [1..5]]
太棒了！所以myList包含了我输入的五个整数。太棒了！但这里有一个关键问题。我如何才能将上述代码转换为等效的while-loop，而不是迭代五次(或任意有限次)的for-loop呢？
所以我的
浏览 1提问于2020-03-23得票数 3
3回答
我在Haskell遇到了以下情况：foldl (&&) True [False | _ <- [1..]]。我知道foldl函数的作用，这个表达式包含无限递归，但是这个表达式实际上意味着什么呢？我主要不确定|和<-在这种情况下做了什么。
浏览 7提问于2017-11-09得票数 1
回答已采纳
对于赋值，我需要编写一些Haskell代码，它有一个有限列表作为输入，该列表由无限的整数列表组成，每个列表单调递增。
现在，我需要将它们合并到一个对整数进行排序的列表中。此外，某些整数可能会出现在多个列表中:在输出列表中，每个整数只能在列表中出现一次。
因此，如果输入是例如[ 1，2，6，10，28，40，...，任意数量的列表]，那么输出应该是1，2，3，4，6，10，28，40,100，...
我有点被困在这里了。我不知道如何有效地使用foldr来合并列表。我想我应该比较一下每个列表的头部，然后根据这个列表做一个新的列表。
浏览 2提问于2014-10-02得票数 8
3回答
我是F#的新手，我想知道是否有任何方法可以在F#中获得懒惰的素数序列。
在Haskell中，我使用next代码：
primes :: [Integer]
primes = sieve[2..]
where sieve (p:xs) = p : sieve [x | x <- xs, x `mod` p > 0]
在F#中，我可以检查数字是否为质数：
let isPrime (number : bigint) =
match number with
| _ -> seq { bigint(2) .. bigint(Math.Sqrt(flo
浏览 1提问于2011-03-23得票数 8
回答已采纳
Haskell函数
foo = zipWith ($) . repeat
就像
map
但我不明白为什么:-(谁能解释呢？经常这样！
浏览 2提问于2015-07-29得票数 8
回答已采纳
可能重复：
在Haskell中，您可以定义一个无限列表，例如[1..]。在Haskell中是否有一个内置函数来识别列表是否具有有限的长度？我认为编写用户提供的函数是不可能的，但是Haskell对列表的内部表示可能能够支持它。如果不是在标准Haskell中，是否有扩展提供这样的功能？
浏览 5提问于2012-03-27得票数 25
回答已采纳
我是Haskell初学者。上次我学习了斐波那契数列，这样我就可以创建Fib数列了。现在我想知道如何编写一个函数来检查number是否属于Fib序列。
我的意思是功能：
belongToFib :: Int -> Bool
我真的不需要代码。一些如何处理这个问题的提示就足够了。提前谢谢。
浏览 2提问于2012-05-24得票数 2
回答已采纳
我是haskell的新手，我做了个练习。理论上我知道该怎么做，但我不知道在Haskell我该怎么做。我的练习是创建一个列表生成器，它生成以下无限列表：[1,-1,3,-3,5,-5..]。我想用两种不同的顺序来做。
有什么办法解决这个问题吗？
[ something [a,b,a,b..] | a<-[1,3..], b<-[-1,-3..] ]
我已经尝试过搜索解决方案，但是我找不到关于列表生成器的任何信息。
浏览 0提问于2016-03-05得票数 1
回答已采纳
我会打印一个数字流，但是下面的代码只输出序列中的第一个数字：
for ( n <- Stream.from(2) if n % 2 == 0 ) yield println(n)
2
res4: scala.collection.immutable.Stream[Unit] = Stream((), ?)
在Haskell中，以下内容一直打印数字直到中断，我希望Scala中也有类似的行为：
naturals = [1..]
[n | n <- naturals, even n]
[2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,3
浏览 3提问于2014-06-16得票数 3
2回答
我的代码(如下所示)由于堆栈溢出异常而失效。我假设F#不像haskell，它不能很好地处理递归列表。在F#中处理这样的递归列表的正确方法是什么？我是否应该向它传递一个int，这样它就有了一个确定的大小？
let rec collatz num =
match num with
|x when x % 2 = 0 ->num :: collatz (x/2)
|x -> num :: collatz ((x * 3) + 1)
浏览 0提问于2011-11-11得票数 2
回答已采纳
今天，我在Haskell玩Collatz序列..。
这是我的代码：
collatzLength :: Int -> Integer -> Int
collatzLength count 1 = count
collatzLength count n = collatzLength (count+1) $ if n `mod` 2 == 0 then n `div` 2 else 3*n+1
main =
print (collatzLength 1 (10^10000 + 1))
我想做的是在1，3上进行无限迭代.每次发现新的最大Collatz长度时，我都希望在屏幕上显示
浏览 2提问于2017-05-20得票数 1
回答已采纳
3回答
我正在读一篇Haskell教程(向你学习Haskell)，其中作者说，懒惰与引用透明性很好。经过更多的阅读和搜索，我仍然不明白为什么。请注意，我确实理解引用透明性和懒惰的伟大之处，但它们一起困扰着我。
两者的结合有什么特别的好处吗？
或者也许作者只是想说他们都很好，并且表达得很模棱两可？
浏览 3提问于2010-10-05得票数 7
回答已采纳
5回答
在具有某种类型的反射/自定义的语言中，一个巨大的好处是可以从各种来源自动构造对象。
例如，在Java中，我可以使用相同的对象来持久化数据库(使用Hibernate)、序列化到XML (使用JAXB)和序列化到JSON (json-lib)。您可以在Ruby和Python中执行相同的操作，通常还需要遵循一些简单的Java属性或注释规则。
因此我不需要太多的“域转移对象”。我可以专注于我正在工作的领域。
在像Haskell和Ocaml这样非常严格的FP中，这似乎是不可能的。尤其是Haskell。我看到的唯一一件事就是做一些预处理或元编程(ocaml)。你必须从下往上做所有的转换，这是不是已经被接受
浏览 2提问于2010-04-22得票数 16
回答已采纳
这是一个非常简单的线性全等伪随机数生成器。当我播种它时，它工作得很好，但我想让它随着每个产生的数字而自我播种。问题是，我不知道如何在Haskell中做到这一点，因为Haskell中没有变量的概念。我可以递归地提供生成的数字，但这样我的结果将是一个整数列表，而不是单个数字。
linCongGen :: Int -> Int
linCongGen seed = ((2*seed) + 3) `mod` 100
浏览 0提问于2015-06-17得票数 1
在haskell中，我们编写的所有IO代码只是一个操作(许多人建议将其视为正在生成的脚本)。它是最终执行它们的主要方法(执行构造的脚本)。那么下面的程序是如何工作的呢？infi函数将永远不会返回。那么，为什么字符串会被无限打印呢？
infi =
do
print "hello"
infi
main =
do
infi
浏览 8提问于2017-03-22得票数 3
回答已采纳
2回答
我偶然发现了以下问题。假设我有一个递归函数
run :: [Int] -> [Int]
run [] = []
run (x:xs) = 1:x:run xs
重要的是，它的head $ run <whatever>总是1。这意味着以下内容将产生输出1
head $ run [error "shouldnt get here"]
这证明了，如果不需要的话，Haskell不会评估这个论点--显然，这是最著名的Haskell特性之一。但是，如果我将结果用作一个参数，比如：
let out = run (cycle out) in head out
我得到一个运行时
浏览 4提问于2019-12-11得票数 4
回答已采纳
我正在Haskell执行Burrows转换。作为转换的第一步，生成所有循环字符串的组合并将其存储在矩阵中。我正在使用Haskell列表来构造矩阵。列表将将原始单词存储在列表头上，并将其循环组合向下存储在尾中。
我编写了一个输出第一个循环字符串的函数。但是，如果我再次以递归的形式调用该函数，我将面临一个无限循环。
这是函数
type BWT = [String] -- List of Strings for Burrows Wheeler matrix
samplebwt = ["BANANA$"] -- Sample input
rotateBWT:: BWT ->
浏览 1提问于2016-04-26得票数 0
我正在将算法转换为Haskell。
在第一步中，我从常用单词列表(英语单词、姓氏、男性姓名等)生成几个大型数据结构。这些列表是静态的，只有在重新编译应用程序时才会偶尔重建。
这些列表和映射用于初始化实际密码强度算法。
当我将原始JavaScript转换为Scala时，我将静态值另存为JSON，算法在启动时会加载该JSON。我只想生成初始化的Scala val，但是Java Virtual Machine对类有64K字节的限制，并且我的数据超出了这个限制(每个结构包含数千个单词，并且大于64K字节)。
在Haskell中处理这个问题的最好方法是什么？我可以只生成一个包含数据的源代码模块吗？最大模
浏览 1提问于2013-01-01得票数 3
回答已采纳
3回答
如何模仿懒惰
、、、、
我正在看约翰·休斯的采访，有人问他从Haskell转到Erlang时，他是否怀念懒惰。作为回答，他回答说是，他使用工具来“模仿”它。我的问题是:如何在严格的语言中模仿懒惰？如果能在主流语言中看到很酷的例子，那就太好了。
浏览 0提问于2011-06-14得票数 8
1回答
我正在阅读理查德·伯德所著的“与Haskell一起思考”一书，并遇到了关于无限列表的归纳的链式完整的概念。上面写着：
当xs0，xs1，.是具有极限xs的部分列表序列，P(xsn)对所有n都保持，然后P(xs)也保持。
作为连锁完整属性的一个例子，它说：
所有方程e1 = e2，其中e1和e2是包含普遍量化的自由变量的Haskell表达式，都是链完备的。
我很难理解这个例子是如何适合链式完成的属性的。它还声明不等式e1 =/= e2不一定是链完全的。我如何理解这些属性的链的完整性？
顺便说一句，这不一定是关于Haskell的问题，而是一个数学方面的问题。
浏览 3提问于2017-08-06得票数 7
回答已采纳
1回答
我正在尝试编写一个函数fold n，其中n是一张纸在同一方向上折叠的次数。这个函数应该输出一个由"m"(山)和"v"(谷)组成的字符串来表示论文中的褶皱。例如，fold 1将输出"v"，fold 2将输出"mvv"，依此类推。我对Haskell非常陌生，正在寻找任何关于如何处理这个问题的建议。
浏览 2提问于2016-02-11得票数 2
3回答
作为我的第一个haskell程序，我试图做到这一点--这是获得1到10个整数的艰难途径。我正在构造一个无限个整数列表，并对它们进行排序，并取前10个整数。我的目的是说服自己，我可以处理无限个列表，而不会导致对它们的评估超出了所需结果的严格要求。
我的代码是..。
module Main where
import Data.List
minima n xs = take n (sort xs)
main = do
let x = [1..]
print (minima 10 x)
用ghc编译并运行生成的可执行文件。它坐在那里分配直到死亡。
有什么暗示吗？
浏览 6提问于2009-09-20得票数 4
回答已采纳
2回答
所以我试着做一些数论方面的工作，我在使用Mathematica，但是我认为Haskell将更适合处理无限列表(因为AFAIK Mathematica没有懒惰的评估)。我想要做的是让Haskell将1/x的所有数字存储在一个无限的惰性列表中。到目前为止，我的搜索还没有找到将比率拆分为返回数字列表而不是实际浮点数的数字的方法。
浏览 4提问于2014-01-14得票数 6
回答已采纳
6回答
有没有办法判断Haskell中的列表是否是无穷大的？原因是我不想将像length这样的函数应用于无限列表。
浏览 2提问于2011-09-10得票数 44
回答已采纳
4回答
我和Haskell纠缠了几天，遇到了一个问题。
我需要一个返回随机整数列表( Rand [Int] )的方法。
因此，我定义了一个类型：type Rand a = StdGen -> (a, StdGen)。我能够以某种方式生成Rand IO Integer和Rand [IO Integer] ( (returnR lst) :: StdGen -> ([IO Integer], StdGen) )。关于如何生成Rand [[Int]]有什么建议吗？
浏览 0提问于2010-04-29得票数 18
回答已采纳
有什么好的方法来捕获haskell异常，它是在由c函数调用的haskell回调函数中抛出的吗？
例如，让我有一个简单的c函数，它只调用给定的回调，
void callmeback ( void (*callback) () ) {
callback ();
}
以及通过ffi使用此函数的haskell代码。
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE ForeignFunctionInterface #-}
module Main (main) where
import Foreign
import Control.Exception
浏览 0提问于2015-04-19得票数 12
回答已采纳
我必须从自然数1，2，3的列表中创建每个4n+1项的列表.使用Haskell
我可以用一些例子来编写这个程序：
elem' n xs = case drop (4*n) xs of
(y:ys) -> y : elem' n ys
[] -> []
这将生成原始列表中每个第n个元素的列表。
但是我的代码没有给出正确的结果。有人能指出问题出在哪里吗？我不应该使用drop并做一些递归吗？
浏览 4提问于2020-05-05得票数 2
回答已采纳
我已经和Haskell接触了几个星期了，我在学你haskell方面取得了很大的进步。我觉得很多类型的类和普通的实现到应用程序和monads对我来说很有意义，我理解它们是如何工作的，但我仍然缺乏很多实际经验。
有一件事让我很不爽，因为它的背景大多是命令式/面向对象(OOP)，这就是价值/函数的概念，它可以计算到无限大的列表。当然，我可以看到如何使用它们来非常简洁地编写一些定义，而且在很多我甚至无法想象的情况下，它们肯定是有用的。不过，我不知道有什么共同的方法来减轻他们的风险。如果您在代码中的任何一个点意外地计算了一个“完全”的无限列表，您的程序就会陷入困境。当然，在命令式语言中也可以这样做(例如
浏览 0提问于2016-04-27得票数 7
在Haskell中，以下代码打印"[1,2,3,4,5"：
foo = take 10 $ show $ numbersFrom 1 where
numbersFrom start = start : numbersFrom (start + 1) -- could use [1..]
但在Frege中，它使用以下代码抛出OutOfMemoryError：
foo = take 10 $ unpacked $ show $ numbersFrom 1 where
numbersFrom start = start : numbersFrom (start + 1)
这
浏览 8提问于2012-08-15得票数 6
回答已采纳
具有特定起点的无限序列现在已经被很好地理解了。例如，斐波纳契数字可以像这那样编程：
def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
使用它的方法是从结果生成器获取特定数量的项，或者在a < 30这样的条件下使用项。
是否有标准的方法来处理在两个方向上都是无限的序列，例如双向Fibonacci数？这是相当简单的，因为Fibonacci数在0之前(1，-1，2，-3，5，-8，等等)很容易从正对称中导出，但考虑不存在这种对称性的情况。生成器是否适合这样的序列？你能
浏览 0提问于2020-07-03得票数 -1
我正在尝试学习Haskell (非常好)，我正在做的许多不同的事情之一是试图解决一些Project Euler问题，因为我正在测试我的勇气。
在做一些基于Fibonacci的问题时，我偶然发现并开始使用Fibonacci序列的递归无限列表版本：
fibs = 1 : 2 : zipWith (+) fibs (tail fibs)
对于其中一个PE问题，我需要提取小于4,000,000的偶数Fibonacci数的子序列。我决定用列表理解来做这件事，在我处理代码的过程中，我偶然发现了一些我不太理解的东西；我假设这是我对Haskell懒惰的评估方案的软弱理解，这让事情变得复杂。
下面的理解工作得很
浏览 0提问于2012-11-13得票数 14
回答已采纳
2回答
我对Haskell很陌生，我找到了一些可以练习的例子，但是我不知道如何处理它们。我需要将"abcd"分割成子序列。
至：
["",a,b,c,d,ab,ac,ad,bc,bd,cd,abc,abd,bcd,acd,abcd]
我发现我必须使用子序列函数。
subsequences :: [a] -> [[a]]
我该怎么做？
浏览 3提问于2014-06-17得票数 0
回答已采纳
3回答
我最近遇到了Haskell回忆录fibonacci的实现：
fibonacci :: Int -> Integer
fibonacci = (map fib [0 ..] !!)
where fib 0 = 0
fib 1 = 1
fib n = fibonacci (n - 1) + fibonacci (n - 2)
我想知道第一次生成第n个斐波那契数的时间复杂性。是因为Haskell的列表查找而导致的O(n^2)吗？如果是，那么在查找操作为O(1)的语言中，是否有办法使O(n)类似于O(N)？
浏览 4提问于2017-03-13得票数 6
回答已采纳
我试图在Haskell上实现Newton-Raphson方法，到目前为止，我已经设法通过使用iterate函数来实现它，但问题是，由于迭代函数的性质，它重新运行了一个无穷大的列表，所以我希望找到一种方法，在迭代中获得的值落入一定的误差范围时停止循环，并返回所述值。
我在这里看了一些博客文章，甚至是一些问题，但我对haskell还不太熟悉，对我来说，阅读代码实例或文档现在真的很难。
f(x)和g(x) (导数)的定义是相关的：
newton x0 = iterate step x0
where step xn = xn - ((f xn)/(g xn))
目前，我使用的是列表的第一个元素
浏览 0提问于2019-05-18得票数 0
回答已采纳
我是Haskell的新手，但有一些ActionScript 3.0面向对象的经验。因此，正在进行一个主要的编程过渡。我已经阅读了关于Haskel的基本知识，比如算术。我可以写一些简单的函数。
作为一项实际任务，我必须在Haskell中通过计算机生成名为tms1的。所以它应该是这样的：
>tms1 0
0
>tms1 1
1
>tms1 2
10
>tms1 3
1001
>tms1 4
10010110
以此类推。根据维基百科的说法，我应该使用这个公式。
t0 = 0
t2n = tn
t2n + 1 = 1 − tn
我不知道如何在Haskell中实现这个公式。
浏览 0提问于2011-09-25得票数 3
回答已采纳
我在想haskell是如何实现无限列表的.这是我的路障：
您有一个类型A的列表，A实现了Ord类型。您可以描述像so这样的有序元素的范围(例如intergers)：
[1..6]
这相当于..。
Cons 1 (Cons 2 (Cons 3 (Cons 4 (Cons 5 (Cons 6 (Empty))))))
haskell如何知道如何构造一个无限列表？haskell是否能够创建支持Ord的任何数据类型的无限列表？
浏览 2提问于2013-07-25得票数 2
回答已采纳
Haskell通常被解释为整个程序是一个纯函数(main)，它返回IO值(通常被描述为命令式IO程序)，然后由运行时执行。
这个心智模型对于简单的示例来说很好，但当我看到中的递归时，我就不太喜欢它了。例如：
main = do
line <- getLine
putStrLn line
main
或者，如果你喜欢：
main = getLine >>= putStrLn >> main
由于main永远不会终止，它实际上也不会返回IO值，但是程序不停地读取和回传回行很好，所以上面的简单解释不太管用。我是遗漏了一些简单的东西，还是有一个更完整的解释(或
浏览 2提问于2015-01-28得票数 10
回答已采纳
所以，我正在研究一个体育问题，有必要列出一个素数。所以我用Haskell的方法定义了一个无限的素数列表，如下所示：
primes = 1 : 2 : filter isPrime [3,5..]
我想知道为什么我看上去相当快的这个程序，却要花很长时间来处理一些小的数字。然后我试了一下：
*Main> takeWhile (<10) primes
[1,2
它甚至没有打印完列表，然后就挂在那里。我确信这只是一个愚蠢的初学者错误，因为我只使用了Haskell几个月(我来自Lisp世界)。
提前感谢！
浏览 1提问于2016-12-17得票数 1
回答已采纳
在Haskell中，有一个函数"take n list“，它返回列表中的前n个元素。例如，"sum (take 3Xs)“总结了列表xs中的前三个元素。F#有没有等价物？我希望它是列表函数之一，但我找不到任何似乎匹配的函数。
浏览 0提问于2010-04-14得票数 16
回答已采纳
在Haskell中，可以定义如下无限列表：
[1.. ]
如果发现了许多描述如何实现无限列表的文章，并且我理解这是如何工作的。然而，我想不出有什么理由使用无限数据结构的概念。
有人能给我举一个问题的例子吗?在Haskell中有一个无限的列表，可以更容易地(或者仅仅)解决这个问题？
浏览 2提问于2020-06-12得票数 10
回答已采纳
在Haskell中，我想生成一个长度未知的随机整数列表。(然而，比方说少于100万。)
我不太可能立即需要列表的所有元素，所以我想懒惰地生成它。然而，一旦生成，我将需要通过随机访问来访问列表中的元素。因此，我认为最好的技术是将一个无限列表复制到一个数组中。但是，我不知道数组是否可以很容易地与列表“互换”--例如，一旦我想要生成列表中的更多项，我就想从我离开的地方开始，然后展开数组。
无论如何，也许我应该满足于一些log(n)树结构而不是数组？你认为如何？
Haskell是否有可以使用类似列表的API访问的顺序元素的树结构？
浏览 0提问于2011-02-10得票数 5
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
