1

我编写了以下 Haskell 程序，其目的是像凯撒密码一样运行：

  1 import System.IO
  2 import System.Environment
  3 import System.Exit
  4 import Data.Char
  5 
  6 shiftRight :: Int -> Char -> Char
  7 shiftRight shift char = do
  8   if isAsciiLower char
  9   then if (toEnum (fromEnum char + shift) :: Char) > 'z'
 10     then shiftRight (shift - 26) char
 11     else toEnum (fromEnum char + shift) :: Char
 12   else if isAsciiUpper char
 13     then if (toEnum (fromEnum char + shift) :: Char) > 'Z'
 14       then shiftRight (shift - 26) char
 15       else toEnum (fromEnum char + shift) :: Char
 16     else char
 17     
 18 shiftLeft :: Int -> Char -> Char
 19 shiftLeft shift char = do
 20   if isAsciiLower char  
 21   then if (toEnum (fromEnum char - shift) :: Char) < 'a'
 22     then shiftLeft (shift + 26) char
 23     else toEnum (fromEnum char - shift) :: Char
 24   else if isAsciiUpper char
 25     then if (toEnum (fromEnum char - shift) :: Char) < 'A'
 26       then shiftLeft (shift + 26) char
 27       else toEnum (fromEnum char - shift) :: Char
 28     else char
 29 
 30 main = do 
 31   args <- getArgs
 32   message <- getLine
 33   case args of
 34     [aString, aInt] -> 
 35       if aString == "-encode"
 36       -- `read` converts aInt from string to int
 37       -- `map` is used to apply `shiftRight` to each char in the string `message`
 38       then putStrLn $ show $ map (shiftRight $ read $ aInt) message
 39       else 
 40         if aString == "-decode"
 41         then putStrLn $ show $ map (shiftLeft $ read $ aInt) message
 42         else do
 43           putStrLn ("Second argument should be either '-decode' or '-encode'!")
 44           exitFailure
 45     _ -> do 
 46       progName <- getProgName
 47       putStrLn ("Usage: " ++ progName ++ " [-encode|-decode] [0-9]")
 48       exitFailure

我的ghc版本如下：

$ ghc --version
The Glorious Glasgow Haskell Compilation System, version 8.6.5

我在macos（Catalina）上编译Haskell：

$ ghc Prog1d.hs -o Prog1d
Loaded package environment from $HOME/.ghc/x86_64-darwin-8.6.5/environments/default
[1 of 1] Compiling Main             ( Prog1d.hs, Prog1d.o )
Linking Prog1d ...

然后我运行我的代码：

$ echo "ABCXYZabcxyz" | ./Prog1d -encode 1
"BCDYZAbcdyza"
$ echo "ABCXYZabcxyz" | ./Prog1d -encode 2
"CDEZABcdezab"
$ echo "ABCXYZabcxyz" | ./Prog1d -encode 4
"EFGBCDefgbcd"
$ echo "ABCXYZabcxyz" | ./Prog1d -encode 100
"WXYTUVwxytuv"
$ echo "ABCXYZabcxyz" | ./Prog1d -decode 1
Prog1d: Prelude.chr: bad argument: (-14)
$ echo "ABCXYZabcxyz" | ./Prog1d -decode 2
Prog1d: Prelude.chr: bad argument: (-15)
$ echo "ABCXYZabcxyz" | ./Prog1d -decode 4
Prog1d: Prelude.chr: bad argument: (-17)
$ echo "ABCXYZabcxyz" | ./Prog1d -decode 100
Prog1d: Prelude.chr: bad argument: (-35)

为什么我会得到Prelude.chr: bad argument？是什么原因造成的，我能做些什么来解决这个问题？

我读过其他人遇到此错误，但在他们的情况下，删除*.hi文件解决了问题。我已删除Prog1d.hi（以及Prog1d.oand Prog1d），但没有效果。我觉得这可能是由我的代码中的某些内容引起的，可能是第 41 行：

then putStrLn $ show $ map (shiftLeft $ read $ aInt) message

但是这条线就像第 38 行一样，它适用于-encode用例。我一定遗漏了一些明显的东西。

我是Haskell的新手，所以请帮助我。我主要习惯于用 C++、python、Java 等命令式语言编写代码，还不熟悉 Haskell 和其他函数式语言的思想和语法。

感谢您阅读本文！

4

1 回答 1

0

我发现了问题。

在我的代码中，我将一个字符转换为其对应的 ASCII 码。

例如，fromEnum 'A'会给你65. 问题是，如果您将值从 ASCII 值表中移出，例如，您会导致我用来比较-1的错误参数错误，以检查移位是否过大。toEnum

例如：

echo "A" | ./Prog1d -decode 66

这将带我到程序中的第 25 行：

25     then if (toEnum (fromEnum char - shift) :: Char) < 'A'

fromEnum char将是fromEnum 'A'哪个会给我65。

65然后我从值中减去shift：66。所以，65 - 66 = -1。

然后toEnum -1导致Prelude.chr: bad argument: (-1).

那是因为没有 ASCII 字符，-1并且该值超出了范围。

这意味着我只需要比较 int 值而不是 chars 来检查我的班次是否超出范围。

这是更正后的代码：

import System.IO
import System.Environment
import System.Exit
import Data.Char
 
shiftRight :: Int -> Char -> Char
shiftRight shift char = do
  if isAsciiLower char 
  then if (fromEnum char + shift) > 122 -- 122 is 'z' in ASCII
    then shiftRight (shift - 26) char
    else toEnum (fromEnum char + shift) :: Char
  else if isAsciiUpper char
    then if (fromEnum char + shift) > 90 -- 90 is `Z` in ASCII
      then shiftRight (shift - 26) char
      else toEnum (fromEnum char + shift) :: Char
    else char
 
shiftLeft :: Int -> Char -> Char
shiftLeft shift char = do
  if isAsciiLower char 
  then if (fromEnum char - shift) < 97 -- 97 is 'a' in ASCII
    then shiftLeft (shift - 26) char
    else toEnum (fromEnum char - shift) :: Char
  else if isAsciiUpper char
    then if (fromEnum char - shift) < 65 -- 65 is 'A' in ASCII
      then shiftLeft (shift - 26) char
      else toEnum (fromEnum char - shift) :: Char
    else char
 
main = do
  args <- getArgs
  message <- getLine
  case args of
    [aString, aInt] -> 
      if aString == "-encode"
      -- `read` converts aInt from string to int
      -- `map` is used to apply `shiftRight` to each char in the string `message`
      then putStrLn $ map (shiftRight $ read $ aInt) message
      else 
        if aString == "-decode"
        then putStrLn $ map (shiftLeft $ read $ aInt) message
        else do
          putStrLn ("Second argument should be either '-decode' or '-encode'!")
          exitFailure
    _ -> do 
      progName <- getProgName
      putStrLn ("Usage: " ++ progName ++ " [-encode|-decode] [0-9]")
      exitFailure

这是正确的，所需的输出：

$ echo "ABCXYZabcxyz" | ./Prog1d -encode 1
BCDYZAbcdyza
$ echo "ABCXYZabcxyz" | ./Prog1d -encode 2
CDEZABcdezab
$ echo "ABCXYZabcxyz" | ./Prog1d -encode 4
EFGBCDefgbcd
$ echo "ABCXYZabcxyz" | ./Prog1d -encode 100
WXYTUVwxytuv
$ echo "ABCXYZabcxyz" | ./Prog1d -decode 1
ZABWXYzabwxy
$ echo "ABCXYZabcxyz" | ./Prog1d -decode 2
YZAVWXyzavwx
$ echo "ABCXYZabcxyz" | ./Prog1d -decode 4
WXYTUVwxytuv
$ echo "ABCXYZabcxyz" | ./Prog1d -decode 100
EFGBCDefgbcd

编辑 (2020-09-01)：John Purdy 给了我一些反馈，这促使我从根本上重构我的代码。这是改进的版本：

import System.IO
import System.Environment
import System.Exit
import Data.Char

shift :: Int -> Char -> Char
shift amount char
  -- `ord` is `fromEnum` but only for `Char` types; converts a Char to an Int, 
  -- which gives us the ASCII number for that character
  -- see: https://hackage.haskell.org/package/base-4.14.0.0/docs/Data-Char.html#v:ord
  | isAsciiLower char && (shifted < ord 'a' || shifted > ord 'z') = shift cycled char
  -- `chr` is `toEnum` but only for `Char` types; it converts from an Int to Char
  -- see: https://hackage.haskell.org/package/base-4.14.0.0/docs/Data-Char.html#v:chr
  | isAsciiLower char = chr shifted
  | isAsciiUpper char && (shifted < ord 'A' || shifted > ord 'Z') = shift cycled char
  | isAsciiUpper char = chr shifted 
  | otherwise = char
  where shifted = ord char + amount -- e.g. 'A' (ASCII: 66) shifted 1 = 'B' (ASCII: 67), so shifted would be 67. 
        -- cycled: the shift amount, but cycled by 26 to start over the alphabet, 
        -- e.g. 'Z' (by ASCII: 90) shifted 1 is 91, so -26 to get 65, which is 'A'
        -- the amount `div` amount makes sure we add or subtract 26 as needed to cycle 
        -- e.g. 'A' (65) shifted -1 is 64, but if we subtracted 26 from 64, it wouldn't cycle us to Z, 
        -- it is in the wrong direction
        -- so instead we multiply by the sign of the amount: -1 - (26 * (-1 / |-1|) to get +25, 
        -- so 65 ('A') + 25 = 90 ('Z')
        cycled = amount - ((amount `div` abs (amount)) * 26) 

main = do
  args <- getArgs
  message <- getLine
  case args of
      -- `read` converts aInt from string to int
      -- `map` is used to apply `shiftRight` to each char in the string `message`
    ["-encode", aInt] -> putStrLn $ map (shift $ read $ aInt) message
    ["-decode", aInt] -> putStrLn $ map (shift $ negate $ read $ aInt) message
    _ -> do 
      progName <- getProgName
      putStrLn ("Usage: " ++ progName ++ " [-encode|-decode] [0-9]")
      exitFailure
于 2020-08-31T16:41:50.417 回答