6 ms·
You can litter printfs in your code, you'll just get a lot of hate if you do it in library code that you share. It's fine when debugging to write a "debug prin
by klodolph 16y ago
You can litter printfs in your code, you'll just get a lot of hate if you do it in library code that you share. It's fine when debugging to write a "debug printf" function using "unsafePerformIO". Yes, it mixes side effects into pure code, but that's fine for debugging purposes.
-- totally OK! go ahead! it won't crash or anything!
debugPrint :: String -> a -> a
debugPrint s x = unsafePerformIO (putStrLn s >> return x)
You could also implement a memoization function using "unsafePerformIO". No, you won't get a visit from the FP purity police for doing so, it's perfectly fine. Why? Using "unsafePerformIO" in a function does NOT mean that that function is impure. It merely means that the compiler will not inform you whether the function is pure or impure -- the compiler's safety checks are bypassed when you use the function.
Here's how I'd type the memoize function:
memoize :: Ord a => (a -> b) -> IO (a -> b)
Notice how it gives you a pure function out. No need to do stuff at the runtime level, or write compiler hints. It just works. If you want to memoize some nasty function:
-- Totally fine! Unless nastyFunction is polymorphic...
nastyFunction :: Paper -> PublishedBook
nastyFunctionMemoized = unsafePerformIO (memoize nastyFunction)
If you're new to Haskell, don't write memoize yourself if you want a version that works with polymorphic functions as that requires some more advanced techniques. Most people who need a memoized function don't need a polymorphic one though.
- masklinn 16y ago> You can litter printfs in your code, you'll just get a lot of hate if you do it in library code that you share. It's fine when debugging to write a "debug printf" function using "unsafePerformIO". Well obviously but I considered we were ignoring such "hacks" as unsafePerformIO. If you introduce it, then all of that is trivial to do so the discussion has no reason to be.
- klodolph 16y agoThe function "unsafePerformIO" is not a hack, it is the tool that allows you to write safe functions with the correct, pure type signature even though the compiler cannot prove that the function is safe. For example, suppose you write "memoize" without using "unsafePerformIO". Here's the resulting type signature: badMemoize :: Ord a => (a -> b) -> IO (a -> IO b) The resulting output has type "a -> IO b", but it doesn't actually do IO and it has no side effects! It's a normal, pure, referentially transparent function, and it shouldn't be in the IO Monad. The correct signature is "a -> b", just like the input. The "unsafePerformIO" function is a non-hack used by careful programmers to expose pure interfaces to code that uses impure constructs. See the FFI tutorials for more examples of using unsafePerformIO. (Of course, unsafe does mean unsafe... you can easily cause segfaults with that thing, you have to use it correctly.)
- masklinn 16y ago> The function "unsafePerformIO" is not a hack, it is the tool that allows you to write safe functions with the correct, pure type signature even though the compiler cannot prove that the function is safe. It is a hack, since it subverts the type system. It allows you to write safe functions with a pure (and potentially lying) type signature, but it also has no problem letting you create completely unsafe and broken functions. > The resulting output has type "a -> IO b", but it doesn't actually do IO and it has no side effects! Of course it does in its implementation, you do have to fill the memoization cache on a miss don't you? > The "unsafePerformIO" function is a non-hack used by careful programmers to expose pure interfaces to code that uses impure constructs. I don't agree with the first part of your declaration. At all. > Of course, unsafe does mean unsafe... you can easily cause segfaults with that thing, you have to use it correctly. And that's why it's a hack, just as using bit shifting instead of multiplication or division is a hack as it relies on the implementation details of the language and the hardware infrastructure. Yeah careful programmers can use it to wring out the latest drop of performance out of their software (assuming there is no optimizing compiler on the platform), but it's still a hack.
- applicative 16y agoI don't get this, what is hackish or immoral about this: http://hackage.haskell.org/packages/archive/bytestring/0.9.0.4/doc/html/src/Data-ByteString-Internal.html http://hackage.haskell.org/packages/archive/bytestring/0.9.0... which makes as many uses of unsafePerformIO as it exports functions, and the beautiful pure interface that is thereby created: http://hackage.haskell.org/packages/archive/bytestring/0.9.0.4/doc/html/Data-ByteString.html http://hackage.haskell.org/packages/archive/bytestring/0.9.0... It seems to me that there is an element of hypocrisy in some of the complaints above; it is as if they were saying: > In Haskell, it's a nightmare to define a pure function with IO. You have to use that dreadful hack `unsafePerformIO`! In practical languages, by contrast, we are spared this boilerplate, since basically every line is already unsafePerformIO.
- masklinn 16y ago> It seems to me that there is an element of hypocrisy in some of the complaints above; it is as if they were saying Apart from the "nightmare" part, this statement you made up happens to be factually true. What is your issue with it? It's exactly what happens: in most other langages, every line is indeed unsafePerformIO. Isn't that fact one of the reasons Haskellers give for using haskell in the first place?
- yummyfajitas 16y agoYou could also just use Debug.Trace.trace. http://www.haskell.org/ghc/docs/6.12.2/html/libraries/base-4.2.0.1/Debug-Trace.html http://www.haskell.org/ghc/docs/6.12.2/html/libraries/base-4...