Início / coding / Perguntas / 79302828
Accepted
Xelote
Asked: 2024-12-23 18:43:06 +0800 CST

O recuo de uma função aninhada parece exigir pelo menos 5 espaços em haskell

  • 772

Estou tentando aprender Haskell por meio do advento do código (eu sei, já estamos no fim da temporada), mas estou encontrando problemas de recuo que não entendo, apesar de verificar o que acredito serem as seções relevantes em haskell.org ou wikibooks .

Especificamente, ao recuar minha função auxiliar interna, o haskell enviará um erro de análise se eu recuar em 4 ou menos espaços (sem contar os 4 espaços de recuo do bloco principal), mas funcionará se recuar em pelo menos 5 espaços adicionais. Então, preciso recuar meu let ... em pelo menos 9 espaços. No entanto, recuar o bloco principal em apenas 4 espaços e não 5 parece funcionar bem, e não entendo a diferença.

Então isso funciona:

solvePart1 :: String -> IO ()
solvePart1 input = do
    let parsedInput = map (map read . words) . lines $ input :: [[Int]]
    let validateReport report =
         let differences = zipWith (-) report (tail report)
         in all (\d -> d >= 1 && d <= 3) differences || all (\d -> d <= -1 && d >= -3) differences
    let areReportsValid = map validateReport parsedInput
    let validReportsCount = sum $ map fromEnum areReportsValid

    putStrLn $ "Day 2, Part 1: " ++ show validReportsCount

mas isso não :

solvePart1 :: String -> IO ()
solvePart1 input = do
    let parsedInput = map (map read . words) . lines $ input :: [[Int]]
    let validateReport report =
        let differences = zipWith (-) report (tail report)
        in all (\d -> d >= 1 && d <= 3) differences || all (\d -> d <= -1 && d >= -3) differences
    let areReportsValid = map validateReport parsedInput
    let validReportsCount = sum $ map fromEnum areReportsValid

    putStrLn $ "Day 2, Part 1: " ++ show validReportsCount

O problema não está relacionado à sintaxe do vs let ..., pois reescrever a função interna como um bloco do não altera o problema: 5 espaços ainda são necessários.

(Estou usando vscode como editor e construindo com stack caso seja relevante)

haskell

2 respostas

  1. Best Answer

    Até certo ponto, é o mesmo que:

    solvePart1 input = do
 let parsedInput = map (map read . words) . lines $ input :: [[Int]]
 -- …

    contra:

    solvePart1 input = do
let parsedInput = map (map read . words) . lines $ input :: [[Int]]
-- …

    O item precisa estar uma coluna à direita do início do identificador que define o escopo. Então o letem si não conta, de fato, por exemplo, o mesmo também não funciona:

    let     x y =
     let tmp = y
     in tmp
in x 5

    Funciona se houver letuma coluna a mais à direita do que x:

    let     x y =
         let tmp = y
         in tmp
in x 5

    Dito isso, normalmente você não usa muito lets em um dobloco, mas trabalha com uma função sem um dobloco, como:

    validateReport :: [Int] -> Bool
validateReport report = all (\d -> d >= 1 && d <= 3) differences || all (\d -> d <= -1 && d >= -3) differences
  where
    differences = zipWith (-) report (tail report)

solve :: [[Int]] -> Int
solve parsedInput = sum (map fromEnum (map validateReport parsedInput))

    e então resolva com:

    solvePart1 :: String -> IO ()
solvePart1 input = do
  let parsedInput = map (map read . words) . lines $ input :: [[Int]]
  putStrLn $ "Day 2, Part 1: " ++ show (solve parsedInput)
    • 2

  2. Isso é algo que frequentemente confunde os novatos em Haskell. A letpalavra-chave é um arauto de layout como do, where, e of(como em case… of), o que significa que ela inicia um bloco quando não é seguida por uma chave de abertura. A primeira coisa depois da palavra-chave determina a margem esquerda do bloco. Se preferir, você sempre pode colocar uma nova linha e recuo depois de uma palavra-chave de layout, então você não precisará alinhar nada. E quando você tem várias letligações, você pode mesclá-las em um único letbloco.

    solvePart1 :: String -> IO ()
solvePart1 input = do
    let
        parsedInput = map (map read . words) . lines $ input :: [[Int]]
        validateReport report = let
            differences = zipWith (-) report (tail report)
            in all (\d -> d >= 1 && d <= 3) differences || all (\d -> d <= -1 && d >= -3) differences
        areReportsValid = map validateReport parsedInput
        validReportsCount = sum $ map fromEnum areReportsValid

    putStrLn $ "Day 2, Part 1: " ++ show validReportsCount

    Tente usar chaves e ponto e vírgula explicitamente em um programa. Isso o deixará familiarizado com o local onde a regra de layout os insere.

    solvePart1 :: String -> IO ();
solvePart1 input = do {
    let {
        parsedInput = map (map read . words) . lines $ input :: [[Int]];
        validateReport report = let {
            differences = zipWith (-) report (tail report);
        } in all (\d -> d >= 1 && d <= 3) differences || all (\d -> d <= -1 && d >= -3) differences;
        areReportsValid = map validateReport parsedInput;
        validReportsCount = sum $ map fromEnum areReportsValid;
    };
    putStrLn $ "Day 2, Part 1: " ++ show validReportsCount;
};
    • 2

relate perguntas