(Отредактировано) Как получить случайное число в Haskell без ввода-вывода

Это не очень хорошее использование unsafePerformIO.

Причина, по которой вы постоянно видите одно и то же число в GHCi, заключается в том, что сам GHCi не знает, что значение нечисто, и поэтому помнит значение с момента последнего вызова. Вы можете вводить команды ввода-вывода на верхнем уровне GHCi, поэтому вы ожидаете увидеть другое значение, если просто наберете getStdGen. Однако это тоже не сработает из-за неясной части работы GHCi, включающей невозврат выражений верхнего уровня. Вы можете включить это с помощью :set +r:

> :set +r
> getStdGen
2144783736 1
> getStdGen
1026741422 1

Обратите внимание, что ваша нечистая функция, притворяющаяся чистой, все равно не будет работать.

> myStdGen
480142475 1
> myStdGen
480142475 1
> myStdGen
480142475 1

Вы действительно не хотите идти по этому пути. unsafePerformIO не должен использоваться таким образом, да и вообще это не очень хорошая идея. Есть способы получить то, что вы хотели (например, unsafePerformIO randomIO :: Int), но они не приведут вас к чему-то хорошему. Вместо этого вы должны выполнять вычисления на основе случайных чисел внутри случайной монады и запускать их в монаде IO.

Обновлять

Я вижу из вашего обновления, почему вы хотели этого в первую очередь.

В этом ответе есть много интересных мыслей о проблеме случайности внутри ссылочно прозрачных функций. .

Несмотря на то, что некоторые люди выступают за использование unsafePerformIO в этом случае, это все еще плохая идея по ряду причин, которые изложены в различных частях этой страницы. В конце концов, если функция зависит от источника случайности, лучше всего указать это в ее типе, и самый простой способ сделать это — поместить ее в случайную монаду. Это по-прежнему чистая функция, просто она принимает генератор при вызове. Вы можете предоставить этот генератор, запросив случайный генератор в основной подпрограмме IO.

Хороший пример использования случайной монады можно найти здесь.

Я злоупотреблял unsafePerformIO

Черт, да! «Отличительные черты чистой функции»

• Нет побочных эффектов
• Ссылочная прозрачность, т. е. каждая последующая оценка результата должна давать один и тот же результат.

На самом деле способ достижения вашей «цели» есть, но идея просто неверна.

myStdGen :: () -> StdGen
myStdGen () = unsafePerformIO getStdGen

Поскольку это (бесполезный) вызов функции вместо CAF, он оценит действие IO при каждом звонке отдельно.

Тем не менее, я думаю, что компилятор в значительной степени может оптимизировать это, поэтому определенно не полагайтесь на него.

ИЗМЕНИТЬ при попытке я заметил, что сам getStdGen всегда дает один и тот же генератор при использовании в данном процессе, поэтому, даже если вышеприведенное будет использовать более разумные типы, это не сработает.

Есть еще один способ получить «случайность» в полностью чистом алгоритме: потребовать, чтобы ввод был Hashable! Затем вы можете эффективно использовать любой аргумент функции в качестве случайного начального числа. Это немного странное решение, но оно может сработать для вашего приложения treap (хотя я думаю, что некоторые люди больше не будут классифицировать его как treap, а как особый вид хэш-карты).

Да, вы оскорбили unsafePerformIO. Есть очень мало веских причин для использования unsafePerformIO, например, при взаимодействии с библиотекой C, и он также используется в реализации нескольких основных библиотек (я думаю, что ST является одной из них). Короче говоря, не используйте unsafePerformIO, если вы действительно не уверены в том, что делаете. Он не предназначен для генерации случайных чисел.

Напомним, что функции в Haskell должны быть чистыми, а это означает, что они зависят только от своих входных данных. Это означает, что у вас может быть чистая функция, которая генерирует «случайное» число, но это число зависит от генератора случайных чисел, который вы ему передаете, вы можете сделать что-то вроде

myStdGen :: StdGen
myStdGen = mkStdGen 42

Тогда вы могли бы сделать

randomInt :: StdGen -> (Int, StdGen)
randomInt g = random

Но тогда вы должны использовать новый StdGen, возвращаемый этой функцией, в дальнейшем, иначе вы всегда будете получать один и тот же результат от randomInt.

Итак, вам может быть интересно, как правильно генерировать случайные числа, не прибегая к IO? Ответ — монада State. Это похоже на

newtype State s a = State { runState :: s -> (a, s) }

И его экземпляр монады выглядит так

instance Monad (State s) where
    return a = State $ \s -> (a, s)
    (State m) >>= f = State $ \s -> let (a, newState) = m s
                                        (State g)     = f a
                                    in g newState

На первый взгляд это немного сбивает с толку, но, по сути, все, что делает монада состояния, — это причудливая композиция функций. Подробнее см. LYAH. Здесь важно отметить, что тип s не меняется между шагами, может измениться только параметр a.

Вы заметите, что s -> (a, s) очень похоже на нашу функцию StdGen -> (Int, StdGen) с s ~ StdGen и a ~ Int. Это означает, что если бы мы сделали

randomIntS :: State StdGen Int
randomIntS = State randomInt

Тогда мы могли бы сделать

twoRandInts :: State StdGen (Int, Int)
twoRandInts = do
    a <- randomIntS
    b <- randomIntS
    return (a, b)

Затем его можно запустить, указав начальное состояние:

main = do
    g <- getStdGen
    print $ runState twoRandInts g

StdGen по-прежнему выходит из IO, но тогда вся логика происходит исключительно внутри монады состояния.