Início / coding / Perguntas / 77250658
Accepted
Alejandro Caro
Asked: 2023-10-08 00:34:07 +0800 CST

Definir variável na função de formato de compreensão de lista

  • 772

Tenho esse pseudocódigo que calcula o fatorial de um número fornecido pelo usuário.

Process without_title
     Define i, tmp, x As Integers;
     tmp<-1;
     Write "Enter a number to calculate its factorial";
     Read x;
     For i <- 1 Until x Do
         tmp<-tmp * i;
     EndTo
     Write tmp;
EndProcess

Agora eu gostaria de implementar o mesmo código em Haskell usando compreensões de lista

import Data.IORef

factorial::Int -> Int
factorial x = [tmp|i<-[1..x], modifyIORef tmp (*i)]

Lança erro dizendo tmpvariável não definida

Como defino a tmpvariável para poder utilizá-la?

list

2 respostas

  1. Best Answer

    Para implementar uma função fatorial usando um mutável IORefcomo este, você precisará trabalhar na mônada IO e usar uma newIORefoperação para criar sua IORefe, em seguida, usar forM_, traverse_, sequence_ou uma função semelhante para sequenciar um conjunto de operações IO nessa função IORef. Pode ser algo como:

    import Control.Monad
import Data.IORef

factorial :: Int -> IO Int
factorial x = do
  tmp <- newIORef 1
  forM_ [1..x] $ \i -> modifyIORef' tmp (*i)
  readIORef tmp

    ou, se você preferir usar uma compreensão de lista para que fique um pouco mais parecida com sua tentativa acima, algo como:

    import Data.IORef

factorialIO :: Int -> IO Int
factorialIO x = do
  tmp <- newIORef 1
  sequence_ [modifyIORef' tmp (*i) | i <- [1..x]]
  readIORef tmp

    (Usar o strict modifyIORef'fornece melhor desempenho do que o lazy modifyIORef.)

    Isso pode então ser chamado assim:

    main :: IO ()
main = do
  result <- factorial 10
  print $ result

    Geralmente, isso será mais lento do que uma solução mais direta e "pura", como:

    factorial :: Int -> Int
factorial x = product [1..x]

    Meus benchmarks sugerem que a IORefversão baseada em - é cerca de duas vezes mais lenta que a productversão baseada em - pura.

    • 3

  2. Bem, é muito anti -Haskellish trabalhar com variáveis ​​mutantes. Esta é uma das razões pelas quais você precisará trabalhar com IO Refs: já que o ref em si não muda, e modificar seu valor é visto como um efeito colateral.

    Se você deseja implementar o fatorial manualmente, a recursão é usada como forma de repetir uma determinada tarefa, e ao passar valores diferentes para o parâmetro pode ser visto como realizando esta iteração com valores modificados, então:

    factorial::Int -> Int
factorial 0 = 1
factorial n = n * (factorial (n-1))

    Mas como Haskell possui algumas funções utilitárias de nível superior, podemos, por exemplo, gerar uma lista de itens e então determinar o produto deles.

    • 0

relate perguntas