如何使用unsafePerformIO编写unsafeCoerce？
unsafePerformIO是Haskell编程语言中的一个函数，它允许在纯函数式代码中执行具有副作用的IO操作。unsafeCoerce是Haskell中的另一个函数，它用于类型转换。使用unsafePerformIO编写unsafeCoerce的过程如下：
- 导入必要的模块：
import System.IO.Unsafe (unsafePerformIO)
import Unsafe.Coerce (unsafeCoerce)- 创建一个包含IO操作的函数：
coerceWithIO :: a -> b
coerceWithIO x = unsafePerformIO $ do
let y = unsafeCoerce x
return y- 在纯函数中调用该函数：
pureFunction :: a -> b
pureFunction x = coerceWithIO x这样，通过使用unsafePerformIO和unsafeCoerce，我们可以在纯函数式代码中执行类型转换操作。然而，需要注意的是，使用unsafePerformIO和unsafeCoerce可能会导致不安全的行为，因为它们绕过了Haskell的类型系统和纯函数的限制。因此，在使用这些函数时应格外小心，并确保了解其潜在的风险。
关于unsafePerformIO和unsafeCoerce的更多信息，可以参考以下链接：
请注意，以上答案仅供参考，使用这些函数需要谨慎，并确保了解其潜在的风险和适用场景。
相关·内容
人们普遍认为unsafePerformIO不是类型安全的。这通常通过使用它来实现unsafeCoerce来演示 box :: IORef a
box = unsafePerformIO (newIORef undefined)
{-# NOINLINE box #-}
unsafeCoerce :: a -> b
unsafeCoerce a = unsafePerformIO $
writeIORef box a >> readIORef box 正如我在几年前所展示的，这种实现不是线程安全的。一个线程可以写入盒子，然后在第一个线程可以读取之前，另一个线程可以再次写
浏览 18提问于2021-07-10得票数 7
在Haskell中，error函数具有签名String -> a。它可以返回任何类型，因为它实际上从未返回。(它打印其参数并终止程序。)
我用C编写了一个类似的函数。它记录传递的字符串并终止进程。我是否可以编写一个Haskell包装器，使其具有与error相同的签名？
C函数的形式为void RaiseError(char* msg) { ... }
到目前为止，我
foreign import capi safe "file.h RaiseError"
c_RaiseError :: CString -> IO ()
raiseError :: Stri
浏览 11提问于2022-04-18得票数 4
1回答
我有一个文件名(以字符串形式)，该文件包含一定数量(例如，1000000)的双精度浮点值(以二进制形式存储，显然，每个值8个字节)。
将这些双精度数读入向量的最佳方法是什么？
浏览 0提问于2013-05-09得票数 3
回答已采纳
我有一个类型级别名单的证人类型，
data List xs where
Nil :: List '[]
Cons :: proxy x -> List xs -> List (x ': xs)
以及以下实用程序。
-- Type level append
type family xs ++ ys where
'[] ++ ys = ys
(x ': xs) ++ ys = x ': (xs ++ ys)
-- Value level append
append :: List xs -> List ys
浏览 5提问于2014-11-01得票数 9
回答已采纳
2回答
关于Haskell，我最喜欢的事情之一是编译器如何通过函数签名中的IO单体来定位副作用。但是，通过导入2个GHC原语似乎很容易绕过这种类型检查：
{-# LANGUAGE MagicHash #-}
import GHC.Magic(runRW#)
import GHC.Types(IO(..))
hiddenPrint :: ()
hiddenPrint = case putStrLn "Hello !" of
IO sideEffect -> case runRW# sideEffect of
_ -> ()
hiddenPrint是一个单元类型
浏览 5提问于2016-09-10得票数 4
回答已采纳
我在努力实现这个节选，但是在Haskell
编写了一个名为transform的高阶函数，该函数将相同的函数应用于列表中的所有元素，将其转换为新的值。但是，如果在转换列表元素时出现异常，则应使用给定列表中的原始值。例如，
变换(fn x => 15 div x) 1,3,0,5
当涉及到haskell中的异常处理时，我真的很困惑，我不明白。我已经编写了这个基本代码，但是它必须适应于处理异常处理程序。
import Control.Exception
import System.Environment
import System.IO
data MyError = Error der
浏览 0提问于2020-05-23得票数 1
回答已采纳
GHC在这一点上速度惊人。不过，我对Haskell的类型系统不满意，所以我决定将自己的DSL作为DSL来实现。现在，为了使用GHC的性能，我想通过翻译后置检查未输入的lambda演算表达式将我的语言编译到Haskell。唯一的问题是，我的系统上的一些有效表达式不会在GHC上编译。我怎样才能避免这个问题--也就是说，通过告诉GHC“我已经检查过了，相信我”，完全禁用了类型系统？
浏览 2提问于2015-04-11得票数 2
回答已采纳
4回答
我想创建三个Haskell函数：a、b和c。
每个函数都有一个参数。论点是三种功能之一。
我希望函数a具有这样的行为：
如果参数是函数a，那么返回函数a。
如果参数为b函数，则返回函数b。
如果参数是函数c，则返回函数a。
下面是我想要的函数a的行为概述
a a = a
a b = c
a c = a
下面是我想要的另外两个功能的行为：
b a = a
b b = a
b c = c
c a = c
c b = b
c c = c
创建之后，我希望能够以各种方式组合这些函数，例如：
a (c b)
= a (b)
= c
如何创建这些函数？
浏览 2提问于2012-03-16得票数 1
回答已采纳
这个问题说明了一切。更具体地说，我正在向一个C库编写绑定，我想知道可以将unsafePerformIO与哪些c函数一起使用。我认为将unsafePerformIO与任何涉及指针的东西一起使用是一个大禁忌。
如果能看到其他也可以使用unsafePerformIO的情况，那就太好了。
浏览 4提问于2012-05-10得票数 31
回答已采纳
2回答
如果您想要按照向量的长度进行索引，您可以这样做：
{-# LANGUAGE
DataKinds, GADTs, TypeOperators, TypeFamilies, StandaloneDeriving
#-}
data N = P N | Z
type family Add (n :: N) (m :: N) :: N
type instance Add Z a = a
type instance Add (P a) b = P (Add a b)
infixr 5 :>
data Vect n a where
V0 :: Vect Z a
浏览 2提问于2014-05-14得票数 8
回答已采纳
如何确定Haskell类型在给定平台上是否具有等效强制实例？
我刚刚在GHC7.8中听说了，这似乎很棒。在这种情况下，我想解决我的具体问题的一个同样好的问题是:是否有一种方法来询问GHC关于哪一对类型的a、b有Coercible a b实例(例如，在当前平台上)？
在我看来，要使在编译器和平台无关的程序中很有用，人们需要知道--最好是在编译时--但在编写代码时也可能明确地知道给定的Coercible a b实例是否存在于给定的平台上，并以其他方式使用更慢的非noop回退(我猜是通过CPP )。
后续问题：为GHC提供一个功能是否合理？
coerceOrConvert :: (a -> b
浏览 1提问于2014-03-17得票数 8
回答已采纳
1回答
我有一个新类型的代表休斯的列表(即列表结构)：
newtype Hughes a = Hughes {unHughes :: [a] -> [a]}
有一些功能可以做：
mkHughes :: [a] -> Hughes a
mkHughes = Hughes . (++)
runHughes :: Hughes a -> [a]
runHughes h = unHughes h []
Monoid实例就像上面的函数一样简单：
instance Monoid (Hughes a) where
mempty = Hughes id
mappend (Hughe
浏览 1提问于2015-07-11得票数 4
回答已采纳
下面的代码部分是用ghci编写的
type GNum = TVar Int
-- updateNum will read a num and add the given value to it
updateNum :: GNum -> Int -> STM ()
updateNum n v =
do t <- readTVar n
writeTVar n (v + t)
-- transaction read a number say n1 and replace value of n2 by n1 + v.
-- v is a given value.
浏览 3提问于2014-10-17得票数 1
回答已采纳
例如，javascript库具有以下层次结构
class Base
class Foo:Base
class Bar:Base
而这个功能
calc(x:Base) : Int
calc(new Bar())
如何用PureScript编写这个函数？
foreign import calc :: ??? -> Int
浏览 8提问于2016-01-01得票数 1
回答已采纳
1回答
我编写了一个简单的函数，用于打印(1)用户输入+ (2)添加了"foobar“的输入：
import scalaz.effect.IO
import scalaz.effect.IO._
def simplePrint: (IO[Unit], IO[String]) = {
val input = readLn
val result = input.map(_ + "foobar")
(input.flatMap(putStrLn), result)
}
def runExample: Unit = {
val (in, result
浏览 4提问于2015-03-31得票数 2
回答已采纳
1回答
我计划用Haskell编写一个小玩具编译器，用于一种非常简单的语言，以增强我的Haskell技能，并有趣地设计一种新的语言。我仍然在考虑一些一般性的决定，其中一个最大的亮点是我将如何进行集成测试。我有以下要求：
应该可以创建一个三元组列表(输入、程序、输出)，这样，我的集成测试运行我的编译器来编译程序，运行已编译的二进制文件，将输入传递给它，并验证运行的输出是否等于给定的输出。
应该可以在以后扩展集成测试，以测试与程序的更复杂的交互，例如，它更改文件或至少睡20秒或诸如此类的事情。
我还有以下可选要求：
它应该是尽可能多的“端到端”，也就是说，它应该尽可能地把整个
浏览 2提问于2015-10-09得票数 10
回答已采纳
unsafeVacuous in Data.Void.Unsafe和#. in Data.Profunctor.Unsafe都警告使用这些函数与属于GADT的函子/终止函子的危险性。一些危险的例子是显而易见的：
data Foo a where
P :: a -> Foo a
Q :: Foo Void
instance Functor Foo where
fmap f (P x) = P (f x)
fmap f Q = P (f undefined)
在这里，unsafeVacuous Q将生成一个假类型的Q构造函数。
这个例子并不是很麻烦，因为它看起来一点也不像一
浏览 1提问于2015-10-05得票数 6
回答已采纳
2回答
如何在每次调用时在haskell中打印列表或其他内容，例如：
funct a list = funct (a + 1) (a : list)
print list here ??????? but how ?
浏览 0提问于2012-04-22得票数 6
回答已采纳
1回答
在Mathematica中，通常使用进行调试。基本上，ShowIt是一个标识函数，它将其参数的值打印到控制台。我想知道，怎么可能为Haskell编写相同的函数。Haskell的问题是，由于函数执行IO，所以它不能具有与输入类型相同的返回类型。我认为我们必须使用不安全IO来实现showIt。但我不知道怎么做。
浏览 6提问于2015-02-11得票数 4
回答已采纳
2回答
强迫幻影型
、、
在这里，我似乎陷入了一种有趣的边缘语言。很难解释我想要做什么，所以让我用代码编写它：
data Foobar x =
Foo1 {field1 :: x, field2 :: String} |
Foo2 {field1 :: x, field3 :: Int} |
Foo3 { field4 :: Bool} |
Foo4 { field2 :: String, field4 :: Bool}
如您所见，一些构造函数依赖于x，而另一些则不依赖。我正在尝试编写一个类似于fmap的函数
transform :: (x -> y
浏览 0提问于2014-02-08得票数 2
回答已采纳
我正在尝试开发一个使用Haskell的聊天服务器。
有很多有用的工具，如TChan，TSkiplist，forkIO ...etc，但我的大部分代码都是在IO monads和unsafePerformIO中编写的，这听起来效率很低。
是否可以这样做，或者haskell不是用于此目的的正确工具？
浏览 0提问于2012-10-16得票数 8
回答已采纳
使用来允许对纯代码中的非更改文件进行只读IO调用合适吗?还是会导致很多问题？
主要原因是因为我希望将它们存储在容器中，例如，使它们成为Ord的实例，但我似乎无法想象如果不在unsafePerformIO中包装IO调用，该如何做到这一点。
浏览 3提问于2014-02-08得票数 0
这在ghc 7.8.4中运行良好，但在7.10.3中失败：
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Foo where
import qualified Data.Array.Unboxed as A
import GHC.Generics (Generic)
newtype Elt = Elt Int deriving (Eq, Ord, Show, Num, Integral, R
浏览 2提问于2016-12-05得票数 3
回答已采纳
我想用haskell编写一个简单的the服务器，它提供了当前的时间。时间应以json格式返回。
以下是我到目前为止所拥有的：
{-# LANGUAGE DeriveDataTypeable #-}
import Happstack.Server
import Text.JSON.Generic
import Data.Time
import System.IO.Unsafe
data TimeStr = TimeStr {time :: String} deriving (Data, Typeable)
main = simpleHTTP nullConf $ ok $ toRespon
浏览 2提问于2014-10-16得票数 0
回答已采纳
我很难让编译器相信我的类型是正确的。对于带有Zero和Succ构造函数的常规Nat，它非常简单(目标是为长度索引列表(Vect)编写replicate函数)：
replicate' :: SNat n -> a -> Vect n a
replicate' SZero _ = Nil
replicate' (SSucc n) a = a :> replicate' n a
但是普通的Nat速度非常慢。
因此，有一个包可以镜像单例库中的GHC.TypeLits，以实现更快的Nats。但是我不能让上面的例子使用它：
sameNat :: foral
浏览 18提问于2017-10-09得票数 4
我正在尝试将一个entryText转换成一个字符串，这样我就可以将它用于其他函数。
`unsafePerformIO (entryGetText txtMagn)`
在试图编译这段代码时，我得到了错误消息：
`Couldn't match type ‘IO a0 -> a0’ with ‘[Char]’
Expected type: String
Actual type: IO a0 -> a0
Probable cause: ‘unsafePerformIO’ is applied to too few arguments
In the
浏览 4提问于2016-08-29得票数 1
回答已采纳
GHC API要求在调用之前进行一些初始化。具体地说，parseStaticFlags只能调用一次。
我有一些函数可以多次调用runGhc :: MaybeFilePath :: Ghc a -> IO a来运行一些GHC方法。然而，某些初始化应该仅在第一次调用该函数时发生。
我似乎记得从Yi源码中可以创建一个全局变量，如下所示
ghcInitialised :: MVar (Bool,[String])
ghcInitialised = unsafePerformIO $ newMVar (False,[])
因此，在调用runGhc的一元操作中，我们可以
(init,flags) &
浏览 2提问于2011-06-27得票数 3
回答已采纳
将给定的Char转换为小写版本的更好方法是什么？
一种方法是转换为String
charToLower :: Char -> Char
charToLower char =
Maybe.fromMaybe char
$ CodeUnits.charAt 0
$ String.toLower
$ CodeUnits.singleton char
在性能/简单性方面，有没有更合适的方法？
也有一个包，但我想知道它是否是首选的方式。
浏览 21提问于2021-05-16得票数 2
我有：
data Time a = NoTime | Time a
我想按照规则来转换它：
NoTime -> Nothing
Time a -> Just a
Time a和Maybe a是同构类型(是吗？)，但我似乎不能强迫Time a到Maybe a (由于“自定义类型错误”)。什么是最优雅，也许最短的方式来做它(不是普通的case)？
浏览 5提问于2022-10-02得票数 1
回答已采纳
1回答
在haskell中，我需要一个全局变量，所以我选择使用IORef插槽，以下是我的计划：
memo :: IORef Int
memo = unsafePerformIO $ newRefInt 9999
evaluate ARGs s = do
v <- Right $ unsafePerformIO $ readIORef memo
val <- Right $ VInt v
return $ (val, s)
evaluate (Call funcID exp) s = do
...
Right $ writeIORef memo 100
...
我的计划是，当
浏览 2提问于2013-12-05得票数 0
我想要像这样的
f :: [forall m. (Mutable v) (PrimState m) r -> m ()] -> v r -> v r -- illegal signature
f gs x = runST $ do
y <- thaw x
foldM_ (\_ g -> g y) undefined gs -- you get the idea
unsafeFreeze y
实际上，我在的位置和维图斯说的一样：
如果希望将多态函数保留在某些结构中，则需要专门的数据类型(例如，newtype i=i(foralla.a -> a)
浏览 8提问于2013-11-14得票数 7
回答已采纳
来自包的GHC实现使用了一个涉及unsafeCoerce的技巧，它利用了GHC使用字典传递编译类型分类的方式。实现很短，所以我可以在这里完整地复制它：
class Reifies s a | s -> a where
reflect :: proxy s -> a
newtype Magic a r = Magic (forall (s :: *). Reifies s a => Proxy s -> r)
reify :: forall a r. a -> (forall (s :: *). Reifies s a => Proxy s ->
浏览 2提问于2017-12-09得票数 7
回答已采纳
假设我们有一个有签名的函数
foo :: a -> b -> Int
是否有可能强制执行约束，以确保a、和b是不同的？那是
foo :: Int -> String -> Int -- ok
foo :: Int -> Int -> Int -- not ok
这个问题的目的是了解更多关于Haskell的知识，或许还可以解决我面临的一个设计问题。如果是a == b，那么我的特殊情况就没有意义了，所以我想在编译器级别上不允许这样做。我也许可以用一个完全不同的设计来解决这个问题，但这并不是现在的问题--潘多拉盒子已经打开，我想知道类型级别上的等式约束是否可
浏览 2提问于2021-07-09得票数 11
回答已采纳
1回答
这个问题与另一个相关，但简化为一个简单得多的情况：
我假定下列进口：
import scalaz._, Scalaz._
import Free._, effect._
我有下列发电机：
val fromOneIO: () => IO[Int] = {
var i = 0; () => { i += 1; IO(i) }
}
val fromOne: () => Int = {
var i = 0; () => { i += 1; i }
}
以及以下非尾递归定义：
def rec(i: Int): Int = {
if (i == 0) {
fr
浏览 2提问于2013-04-23得票数 2
import System.IO.Unsafe
main :: IO ()
main = do
_ <- return $ unsafePerformIO $ do
print "test2"
print "test"
上面只输出test (通过runghc运行时)，我假设由于Haskell的懒惰特性，第一个IO操作实际上没有得到评估。我怎样才能强迫它去评估和执行这个动作？
以上仅用于调试目的。
浏览 1提问于2018-02-25得票数 2
回答已采纳
C++代码版本 (从它复制的描述)
gameKeys id是MMO游戏服务器的身份验证功能。当有人想和朋友玩时，他会向服务器发送请求，服务器调用generateId，然后gameKeys id并使用encodeJSON通过API将其作为JSON返回给player。当朋友建立连接时，他发送游戏id和他的密钥，服务器调用gameKeys id，其中id是用户数据，然后检查用户的密钥。
算法是：
使用当前时间和内部计数器生成id (如果没有提供)，或者使用提供的id
使用id和Blake2函数进行快速加密哈希(是的，我知道HMAC并使用它作为密钥，但在本例中并不重要)
将64位哈希拆分为四个16位值
浏览 0提问于2018-07-19得票数 1
type Foo = {
x :: Int,
y :: Int
}
type Bar = {
x :: Int
}
foo :: Foo
foo = {x:1,y:2}
bar :: Bar
bar = foo
无法匹配类型
()
带型
(y :：Int )
为什么这不可能？
我不能用
type Bar a = {
x :: Int | a
}
也不想重新创建记录
bar = {x : foo.x}
unsafeCoerce是唯一的选择吗？
使用unsafeCoerce会有什么问题？
浏览 3提问于2016-03-27得票数 2
回答已采纳
可以这样想:应用程序动态加载一个模块，或者有一个可供用户选择的函数列表，等等。我们有一种机制来确定某种类型是否可以成功地与该模块中的函数一起工作。所以现在我们要调用这个函数。我们需要强迫它打这个电话。这个函数可以接受一个具体的类型，也可以是一个多态的类型，下面的例子中只有一个类型类约束，我在使用它时遇到了问题。
下面的代码导致了下面的错误。我认为可以通过指定具体类型来解决这个问题，但我不想这样做。该代码旨在与作为类实例的任何类型一起使用。指定一个具体的类型违背了这个目的。
这是模拟程序的一部分，它不知道另一部分，也不知道它正在处理的内容的类型。我有一个单独的机制，它允许我确保类型确实正确匹配，
浏览 0提问于2011-09-09得票数 0
回答已采纳
1回答
我正在为C++类编写一个Haskell包装器。我决定将其表示为包含指向C++中类实例的指针(C++)的Haskell数据结构。差不多吧。
在C++中：
class MyClass {
public:
double my_method();
// ...
};
extern "C" MyClass* cpp_new_MyClass() {
return new MyClass();
}
extern "C" double cpp_my_method(MyClass *obj) {
return obj->my_metho
浏览 3提问于2015-08-31得票数 8
回答已采纳
我认为不安全函数是一个函数，它会返回某种类型的值，但是它实际上可以抛出异常并结束执行，因此根本不返回任何值，但我不确定。
还是不安全函数是一个函数，它可以返回签名中声明的值以外的其他类型的值？那不是弱类型函数吗？
还是Haskell中的弱类型和不安全的同义词？
这也许是个愚蠢的问题，但我找不到一个直截了当的答案。
我查看了的文档，希望看到对不安全函数的引用，但没有。
本文提到了一些关于破坏类型系统的内容，但是它没有通过返回错误类型的值来指定哪种方式；通过异常？
那么，在Haskell，什么是不安全的功能？
浏览 4提问于2015-09-27得票数 10
回答已采纳
4回答
给定一个存在数据类型，例如：
data Foo = forall a . (Typeable a, Binary a) => Foo a
我想写instance Binary Foo。我可以编写序列化(序列化TypeRep，然后序列化值)，但我不知道如何编写反序列化。基本的问题是，给定一个TypeRep，您需要映射回该类型的类型字典-我不知道是否可以做到这一点。
这个问题以前已经在haskell邮件列表上被提出过，但没有给出任何答案。
浏览 3提问于2011-11-12得票数 13
回答已采纳
1回答
我正在尝试创建一些函数来处理以下类型。以下代码在GHC-8.4.1上使用了和库：
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedT
浏览 2提问于2018-04-05得票数 2
回答已采纳
1回答
从其他模块与套接字通信
、、、
我想运行一个websocket服务器，并将消息从另一个模块发送到它。
到目前为止，我只向启动服务器的模块传递了一个通道。但是我想拥有和writeFile一样的全局功能，它可以在任何时候从任何模块调用。
另外，我希望有多个sendMessage客户端。一旦连接关闭，我假设线程仍然停留在forever循环中。
Server.hs
import Network.WebSockets
import Control.Concurrent
import Control.Monad
import Data.ByteString
createServer :: IO (Chan ByteString)
cr
浏览 5提问于2016-02-06得票数 0
回答已采纳
1回答
{-# LANGUAGE ScopedTypeVariables,BangPatterns #-}
import qualified Data.Attoparsec.Internal as I
import qualified Data.Attoparsec.Internal.Types as T
import qualified Data.Vector.Unboxed as UVec
import qualified Data.Vector.Unboxed.Mutable as UMVec
import qualified Data.Vector as Vec
import qualifi
浏览 13提问于2016-08-13得票数 1
众所周知，实现Haskell打字机的一种方法是通过“打字机词典”。(这当然是ghc中的实现，尽管我必须指出其他实现是可能的。)为了修复这些想法，我将简要描述一下这是如何工作的。类声明，如
class (MyClass t) where
test1 :: t -> t -> t
test2 :: t -> String
test3 :: t
可以机械地转换为数据类型的定义，如：
data MyClass_ t = MyClass_ {
test1_ :: t -> t -> t,
test2_ :: t -> String,
test3
浏览 3提问于2014-03-03得票数 9
回答已采纳
让我们有两个没有任何方法的类，另一个是子类。此外，让我们假设函数f5和f6从类型到其他类型执行unsafeCoerce。
现在，ghci可以组合这些函数并找到它们的签名(在ScopedTypeVariables的帮助下)，参见下面的f56, f56b and f56'。这些本质上是具有约束Hmm的函数。
是否可以编写f56c，也就是说，在不引用约束中的类SHmm的情况下编写它？例如，ghci能在某种语言-语用的帮助下编译它吗？
当类没有任何方法时，使用unsafeCoerce有什么危险？(或者当子类SHmm没有任何方法时？)有其他方法/推荐的方法来编写f5和f6吗？
作
浏览 3提问于2017-12-15得票数 0
回答已采纳
让我们假设我在GHCi中执行以下代码：
[unsafePerformIO (randomRIO (0,1)) | _ <- [1..10]].
结果可能类似于[1,1,0,0,1,0,0,0,0,1]，每次执行时都会有所不同。现在假设我定义了以下函数：
f :: Int
f = unsafePerformIO (randomRIO (0,1))
试着打电话给：
[f | _ <- [1..10]].
结果总是[0,0,0,0,0,0,0,0,0,0]。如果我只调用一个f，它总是返回0。撇开我不应该抛弃IO，我做错了什么？
浏览 3提问于2014-09-03得票数 1
回答已采纳
2回答
我正在为一项任务写一份报告，其中我使用STM包实现了一个并发的多核分支和绑定算法，但我遇到了一个问题。
使用STM的实现显然是在IO monad中，因为它同时使用STM的“原子”和并发的“forkIO”，但它是确定性的。尽管使用了共享内存变量，但对于相同的输入，函数的最终结果始终是相同的。
我的问题是，除了“不安全的性能IO”之外，我还有什么选择呢？我是否应该尝试将其从IO monad中删除，因为使用多核可能会潜在地影响其他对确定性没有相同保证的并发代码。
我听说过Par monad包(虽然没有使用它)，但是STM存在于IO monad中，为了获得线程安全的全局变量，我对STM的唯一替代方案是
浏览 0提问于2011-10-14得票数 1
回答已采纳
我用haskell编写了一个函数，它接受一些参数，比如Word32、String (忽略运行)和输出IO Word32。现在，这是一个真正意义上的函数：对于相同的输入，输出总是相同的。没有副作用。函数返回IO Word32而不是Word32的原因是该函数在一个循环中多次更新32位线性反馈移位寄存器(lfsr)和其他寄存器，以便计算最终的Word32输出。
我的问题是:考虑到这个函数实际上没有副作用，是否可以在函数实现中隐藏这些注册更新，以便函数返回Word32而不是IO Word32？如果是这样的话，是怎么做的？
浏览 0提问于2011-05-20得票数 7
回答已采纳
我经常在Haskell代码中找到这种模式：
options :: MVar OptionRecord
options = unsafePerformIO $ newEmptyMVar
...
doSomething :: Foo -> Bar
doSomething = unsafePerformIO $ do
opt <- readMVar options
doSomething' where ...
基本上，一个人有一个选项或类似的记录，这是最初设置在程序的开始。由于程序员很懒，他不想把options记录传遍整个程序。他定义了一个MVar来保持它--用一个丑
浏览 4提问于2011-05-20得票数 19
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
