问题[haskell](coding)

我找不到此行为的文档，它看起来像是一个错误（[编辑] 确实是：gitlab.haskell.org/ghc/ghc /-/issues/10387）。我遗漏了什么吗？

在 GHCi 中：

    > import GHC.Real
    > inf = 1/O :: Double

    > inf
    Infinity

    > infinity
    1 % 0

    > fromRational infinity
    Infinity

    > toRational inf
    179769313486231590... % 1
    
    > toRational inf == infinity 
    False

[编辑 ： ]

有一个解决方法。使用包ieee754，可以定义以下内容：

import GHC.Real
import qualified Numeric.IEEE as IEEE

toRational' :: (IEEE.IEEE a, Real a) => a -> Rational
toRational' a
  | a == IEEE.infinity = infinity
  | a == -IEEE.infinity = -infinity
  | otherwise = toRational a

data Zero = Zero 
data Succ x = Succ x 

class NatToPeano a b | a -> b where 
    toPean :: b
instance NatToPeano 0 Zero where toPean = Zero 
instance (NatToPeano (x-1) a) => NatToPeano x (Succ a) where
     toPean = Succ (toPean @(x-1))

这会产生错误：

 Functional dependencies conflict between instance declarations:
  instance NatToPeano 0 Zero -- Defined at parsejava.hs:26:10
  instance NatToPeano (x - 1) a => NatToPeano x (Succ a)
    -- Defined at parsejava.hs:28:10

 26 | instance NatToPeano 0 Zero where

使用 Haskellcrypton包，我尝试生成相同的输出，openssl dgst但不知道哪里出错了。请帮忙。

openssl dgst：

$ echo "TheMessage" | openssl dgst -sha256 -mac HMAC -macopt key:"TheKey"
SHA2-256(stdin)= 7b2e5669f4a5fa30a3fa0e9147f8975883cddff77725c99a6db07395b9665974

加密：

ghci> hmacGetDigest ( hmac ("TheKey" :: ByteString) ("TheMessage" :: ByteString) :: HMAC SHA256 )
39c17c48adbc2ea4d469af9ecb2569f921053843af2a0a7716b7a180b0cedff6

谢谢。

我读到变量在 haskell 中是不可变的，并且类似下面的内容在 haskell 中不起作用。

x = 30
x = x+1

但我仍然尝试这样做，看看编译器返回了什么，我得到了以下结果：

编译器变得无响应并且不执行任何操作，直到我按下 ctrl+c 并中断它。

为什么会发生这种情况？为什么编译器变得无响应而不是返回某种错误？

我正在使用 Haskell 实现的生成器来完成家庭作业。我有一个andAlso函数应该为生成器添加一个额外的谓词，但它在所有测试用例中都无法正常工作。虽然它看起来是正确的

这是我的生成器类型定义：

-- Type definition for a generator: a function producing a sequence of values
-- 1. The first function generates the next value.
-- 2. The second function checks if generation should continue.
-- 3. The third value is the initial value, or seed. It does not count as being generated by the generator.
type Generator a = (a -> a, a -> Bool, a)

我目前的实现andAlso：

-- Adds an additional predicate to a generator.
andAlso :: (a -> Bool) -> Generator a -> Generator a
andAlso p (f, g, s) = (f, \x -> g x && p x, s)

我正在使用辅助函数takeGen来可视化测试结果：

takeGen :: Int -> ((a -> a), (a -> Bool), a) -> [a]
takeGen 0 _ = []
takeGen n (next, pred, seed)
  | not (pred seed) = []
  | otherwise = seed : takeGen (n-1) (next, pred, next seed)

测试用例和结果

以下是我的测试用例及其结果：

-- Test 1: Filter for odd numbers
takeGen 10 (andAlso (\x -> x `mod` 2 == 1) ((+1), (<10), 0))
-- Expected: [1,3,5,7,9], but getting: [1]

-- Test 2: Filter for numbers divisible by 3
takeGen 10 (andAlso (\x -> x `mod` 3 == 0) ((+1), (<10), 0))
-- Expected: [0,3,6,9], but getting: [0]

-- Test 3: Filter for numbers greater than 5
takeGen 10 (andAlso (>5) ((+1), (<10), 0))
-- Works correctly: [6,7,8,9]

-- Test 4: Combine two additional predicates
takeGen 10 (andAlso (>3) (andAlso (<8) ((+1), (<10), 0)))
-- Works correctly: [4,5,6,7]

-- Test 5: Test with a different generator function
takeGen 10 (andAlso (<15) ((+2), (<20), 1))
-- Works correctly: [1,3,5,7,9,11,13]

takeGen 10 (andAlso (<10) ((+1), (<10), 0))
-- Works correctly: [0,1,2,3,4,5,6,7,8,9]

我尝试过的方法

我尝试过的各种实现andAlso，包括：

1. 当前实现如上所示
2. 调整谓词在序列中的应用方式
3. 尝试找到满足两个谓词的第一个有效值

一些测试用例运行正常，但其他测试用例（特别是测试 1 和 2）并未返回所有预期值。

我的问题

我的实现有什么问题andAlso？我应该如何修复它才能使所有测试用例按预期工作？问题在于生成器的定义方式、takeGen工作原理，还是andAlso附加谓词的应用方式？

其他背景信息

我已经实现的其他与生成器相关的功能：

nthGen :: Integer -> Generator a -> a
nextGen :: Generator a -> Generator a
lengthGen :: Generator a -> Integer
hasLengthOfAtLeast :: Integer -> Generator a -> Bool
constGen :: a -> Generator a
foreverGen :: (a -> a) -> a -> Generator a
emptyGen :: Generator a

感谢您帮助我了解我的实施出了什么问题。

绝对最小的解析库可能是：

{- | Input error type. -}
data InputError = InputError
    deriving (Eq, Show)

instance Semigroup InputError where
    (<>) _ _ = InputError

instance Monoid InputError where
    mempty = InputError


{- | The parsing monad. -}
newtype Parser s e a = Parser ([s] -> Either e (a, [s]))
    deriving stock Functor


-- Instances.
instance Applicative (Parser s e) where
    pure x = Parser $ \ xs -> pure (x, xs)

    (<*>) p q = Parser $ \ xs -> do
        (f, ys) <- run p xs
        (x, zs) <- run q ys
        pure (f x, zs)

instance Monad (Parser s e) where
    (>>=) p h = Parser $ \ xs -> do
        (x, ys) <- run p xs
        run (h x) ys

instance Monoid e => Alternative (Parser s e) where
    empty = Parser $ \ _ -> Left mempty

    (<|>) p q = Parser $ \ xs ->
        case run p xs of
            r1@(Right _) -> r1
            Left e1      ->
                case run q xs of
                    r2@(Right _) -> r2
                    Left e2      -> Left $ e1 <> e2

{- | Primitive parser getting one element out of the stream. -}
one :: Parser s InputError s
one = Parser $ \ xs ->
    case uncons xs of
        Nothing -> Left InputError
        Just p  -> Right p

{- | Run the parser on input and return the results. -}
run :: Parser s e a -> [s] -> Either e (a, [s])
run (Parser p) = p

编译（使用 GHC2021 语言；必须添加一些导入）。在 cabal repl 中的 ghci 中加载它：

ghci> let p = take 2 <$> many one
ghci> run p "0123"
Right ("01","")

这意味着解析器已经使用了所有的输入——我期望看到的是Right ("01", "23")。

所以我的问题是：懒惰在哪里“中断”，可以这么说，有什么办法可以恢复它吗？我说的“恢复它”是指以不同的方式执行实例实现，这样它就many和预期的一样懒惰，因为如果我添加

{- | Implement lazy 'many' -}
atMostN :: Monoid e => Word -> Parser s e a -> Parser s e [a]
atMostN n p = go n
    where
        go 0 = pure []
        go m = do
            r <- optional p
            case r of
                Nothing -> pure []
                Just x  -> (x: ) <$> go (pred m)

并将其加载到 ghci 中，我得到了预期的结果：

ghci> let q = atMostN 2 one
ghci> run q "0123"
Right ("01","23")

以下是《Learn You a Haskell》第 13 章中状态单子的定义

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

根据此定义，在我看来，虽然返回的是较新的版本，但tuple 中的状态f a似乎将被 替换。以Real World Haskell第 10 章中的具体示例为例，这显然不是作者的本意（请注意使用而不是 ，因为他们尚未正式引入 monad）newState ==>>>=

parseByte :: Parse Word8
parseByte =
    getState ==> \initState ->
    case L.uncons (string initState) of
      Nothing ->
          bail "no more input"
      Just (byte,remainder) ->
          putState newState ==> \_ ->
          identity byte
        where newState = initState { string = remainder,
                                     offset = newOffset }
              newOffset = offset initState + 1

在哪里

newtype Parse a = Parse {
      runParse :: ParseState -> Either String (a, ParseState)
    }

identity :: a -> Parse a
identity a = Parse (\s -> Right (a, s))
 
(==>) :: Parse a -> (a -> Parse b) -> Parse b
firstParser ==> secondParser  =  Parse chainedParser
  where chainedParser initState   =
          case runParse firstParser initState of
            Left errMessage ->
                Left errMessage
            Right (firstResult, newState) ->
                runParse (secondParser firstResult) newState

在parseByte，我不明白如何initState不取代newState。

我有一个用 Haskell 构建的很长的字符串

let str = "(\"" ++ (int_list_to_string (printed ctx) "") ++ "\",\"" ++ (int_list_to_string (stack ctx) "") ++ "\")"

这很难看，我一直试图把东西放在不同的行上，但是当我做类似的事情时，我得到了一个错误

let str = "(\"" 
    ++ (int_list_to_string (printed ctx) "")
    ++ ...

似乎不管我在每行前面加了多少缩进。

如何在单独的行上编写长字符串连接？如果这很重要，我会使用 GHC。

在 Haskell 中，独立表达式3 + 5表示fromInteger (3 :: Integer) + fromInteger (5 :: Integer)。在 GHCi 中，它被评估为fromInteger 8类型Num a => a。很明显，Haskell 可以计算(3 :: Integer) + (5 :: Integer)，但评估原始多态表达式似乎需要 形式的某种规则，而我在 Prelude 中没有看到这样的规则。在 GHCi 中fromInteger x + fromInteger y = fromInteger (x + y)， 的评估究竟是如何完成的？3 + 5

默认设置在这里起作用吗？似乎没有，因为如果我default ()在提示符下输入，则3 + 5仍然计算正确，而例如，\(x :: Float) -> x^2无法进行类型检查。如果我使用恢复默认设置default (Integer, Double)，则\(x :: Float) -> x^2类型检查将按预期进行。

https://hackage.haskell.org/package/base-4.21.0.0/docs/GHC-Base.html、 https://hackage.haskell.org/package/base-4.21.0.0/docs/Data-List.html以及许多其他页面都正常，但是https://hackage.haskell.org/package/lazysmallcheck不正常。我见过很多像上一个这样的模块，但一直找不到答案。