hledger "make ghcid" errors

gistfile1.txt

$ make ghcid
ghcid -c 'make ghci'
Loading make ghci ...
make[1]: Entering directory '/home/gueux/src/hledger'
stack exec -- ghci  -rtsopts -Wall -fno-warn-unused-do-bind -fno-warn-name-shadowing -fno-warn-missing-signatures -fno-warn-orphans -fno-warn-type-defaults  -ihledger-lib -ihledger-lib/other/ledger-parse -ihledger -ihledger-ui -ihledger-web -ihledger-web/app    -DPATCHLEVEL=236 -DDEVELOPMENT -DVERSION="\"1.17.99\""  hledger/Hledger/Cli/Main.hs
Stack has not been tested with GHC versions above 8.6, and using 8.8.3, this may fail
Stack has not been tested with Cabal versions above 2.4, but version 3.0.1.0 was found, this may fail
GHCi, version 8.8.3: https://www.haskell.org/ghc/  :? for help
Loaded GHCi configuration from /home/gueux/src/hledger/.ghci
Loaded GHCi configuration from /home/gueux/.ghci
[ 1 of 86] Compiling Hledger.Utils.Color ( hledger-lib/Hledger/Utils/Color.hs, hledger-lib/Hledger/Utils/Color.o )
[ 2 of 86] Compiling Hledger.Utils.UTF8IOCompat ( hledger-lib/Hledger/Utils/UTF8IOCompat.hs, hledger-lib/Hledger/Utils/UTF8IOCompat.o )
[ 3 of 86] Compiling Hledger.Utils.Regex ( hledger-lib/Hledger/Utils/Regex.hs, hledger-lib/Hledger/Utils/Regex.o )
[ 4 of 86] Compiling Hledger.Utils.Tree ( hledger-lib/Hledger/Utils/Tree.hs, hledger-lib/Hledger/Utils/Tree.o )
[ 5 of 86] Compiling Hledger.Data.Types ( hledger-lib/Hledger/Data/Types.hs, hledger-lib/Hledger/Data/Types.o )
[ 6 of 86] Compiling Hledger.Data.Period ( hledger-lib/Hledger/Data/Period.hs, hledger-lib/Hledger/Data/Period.o )
[ 7 of 86] Compiling Hledger.Data.Json ( hledger-lib/Hledger/Data/Json.hs, hledger-lib/Hledger/Data/Json.o )
[ 8 of 86] Compiling Text.Megaparsec.Custom ( hledger-lib/Text/Megaparsec/Custom.hs, hledger-lib/Text/Megaparsec/Custom.o )
[ 9 of 86] Compiling Hledger.Utils.Parse ( hledger-lib/Hledger/Utils/Parse.hs, hledger-lib/Hledger/Utils/Parse.o )
[10 of 86] Compiling Hledger.Utils.String ( hledger-lib/Hledger/Utils/String.hs, hledger-lib/Hledger/Utils/String.o )

hledger-lib/Hledger/Utils/String.hs:78:30: error:
    • Ambiguous type variable ‘t2’ arising from a use of ‘elem’
      prevents the constraint ‘(Foldable t2)’ from being solved.
      Probable fix: use a type annotation to specify what ‘t2’ should be.
      These potential instances exist:
        instance Foldable (Either a) -- Defined in ‘Data.Foldable’
        instance Foldable Maybe -- Defined in ‘Data.Foldable’
        instance Foldable ((,) a) -- Defined in ‘Data.Foldable’
        ...plus one other
        ...plus 67 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the first argument of ‘dropWhile’, namely ‘(`elem` "\r\n")’
      In the first argument of ‘(.)’, namely ‘dropWhile (`elem` "\r\n")’
      In the second argument of ‘(.)’, namely
        ‘dropWhile (`elem` "\r\n") . reverse’
   |
78 | chomp = reverse . dropWhile (`elem` "\r\n") . reverse
   |                              ^^^^^^^^^^^^^

hledger-lib/Hledger/Utils/String.hs:78:37: error:
    • Ambiguous type variable ‘t2’ arising from the literal ‘"\r\n"’
      prevents the constraint ‘(Data.String.IsString
                                  (t2 Char))’ from being solved.
      Probable fix: use a type annotation to specify what ‘t2’ should be.
      These potential instances exist:
        instance (a ~ Tokens s, Data.String.IsString a, Eq a, Stream s,
                  Ord e) =>
                 Data.String.IsString (ParsecT e s m a)
          -- Defined in ‘Text.Megaparsec.Internal’
        instance (a ~ Char) => Data.String.IsString [a]
          -- Defined in ‘Data.String’
        ...plus 7 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the second argument of ‘elem’, namely ‘"\r\n"’
      In the first argument of ‘dropWhile’, namely ‘(`elem` "\r\n")’
      In the first argument of ‘(.)’, namely ‘dropWhile (`elem` "\r\n")’
   |
78 | chomp = reverse . dropWhile (`elem` "\r\n") . reverse
   |                                     ^^^^^^

hledger-lib/Hledger/Utils/String.hs:85:28: error:
    • Ambiguous type variable ‘t0’ arising from a use of ‘elem’
      prevents the constraint ‘(Foldable t0)’ from being solved.
      Probable fix: use a type annotation to specify what ‘t0’ should be.
      These potential instances exist:
        instance Foldable (Either a) -- Defined in ‘Data.Foldable’
        instance Foldable Maybe -- Defined in ‘Data.Foldable’
        instance Foldable ((,) a) -- Defined in ‘Data.Foldable’
        ...plus one other
        ...plus 67 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the first argument of ‘dropWhile’, namely ‘(`elem` "([")’
      In the first argument of ‘(.)’, namely ‘dropWhile (`elem` "([")’
      In the expression:
          dropWhile (`elem` "([")
            . reverse . dropWhile (`elem` "])") . reverse ::
            String -> String
   |
85 | stripbrackets = dropWhile (`elem` "([") . reverse . dropWhile (`elem` "])") . reverse :: String -> String
   |                            ^^^^^^^^^^^

hledger-lib/Hledger/Utils/String.hs:85:35: error:
    • Ambiguous type variable ‘t0’ arising from the literal ‘"(["’
      prevents the constraint ‘(Data.String.IsString
                                  (t0 Char))’ from being solved.
      Probable fix: use a type annotation to specify what ‘t0’ should be.
      These potential instances exist:
        instance (a ~ Tokens s, Data.String.IsString a, Eq a, Stream s,
                  Ord e) =>
                 Data.String.IsString (ParsecT e s m a)
          -- Defined in ‘Text.Megaparsec.Internal’
        instance (a ~ Char) => Data.String.IsString [a]
          -- Defined in ‘Data.String’
        ...plus 7 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the second argument of ‘elem’, namely ‘"(["’
      In the first argument of ‘dropWhile’, namely ‘(`elem` "([")’
      In the first argument of ‘(.)’, namely ‘dropWhile (`elem` "([")’
   |
85 | stripbrackets = dropWhile (`elem` "([") . reverse . dropWhile (`elem` "])") . reverse :: String -> String
   |                                   ^^^^

hledger-lib/Hledger/Utils/String.hs:85:64: error:
    • Ambiguous type variable ‘t1’ arising from a use of ‘elem’
      prevents the constraint ‘(Foldable t1)’ from being solved.
      Probable fix: use a type annotation to specify what ‘t1’ should be.
      These potential instances exist:
        instance Foldable (Either a) -- Defined in ‘Data.Foldable’
        instance Foldable Maybe -- Defined in ‘Data.Foldable’
        instance Foldable ((,) a) -- Defined in ‘Data.Foldable’
        ...plus one other
        ...plus 67 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the first argument of ‘dropWhile’, namely ‘(`elem` "])")’
      In the first argument of ‘(.)’, namely ‘dropWhile (`elem` "])")’
      In the second argument of ‘(.)’, namely
        ‘dropWhile (`elem` "])") . reverse’
   |
85 | stripbrackets = dropWhile (`elem` "([") . reverse . dropWhile (`elem` "])") . reverse :: String -> String
   |                                                                ^^^^^^^^^^^

hledger-lib/Hledger/Utils/String.hs:85:71: error:
    • Ambiguous type variable ‘t1’ arising from the literal ‘"])"’
      prevents the constraint ‘(Data.String.IsString
                                  (t1 Char))’ from being solved.
      Probable fix: use a type annotation to specify what ‘t1’ should be.
      These potential instances exist:
        instance (a ~ Tokens s, Data.String.IsString a, Eq a, Stream s,
                  Ord e) =>
                 Data.String.IsString (ParsecT e s m a)
          -- Defined in ‘Text.Megaparsec.Internal’
        instance (a ~ Char) => Data.String.IsString [a]
          -- Defined in ‘Data.String’
        ...plus 7 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the second argument of ‘elem’, namely ‘"])"’
      In the first argument of ‘dropWhile’, namely ‘(`elem` "])")’
      In the first argument of ‘(.)’, namely ‘dropWhile (`elem` "])")’
   |
85 | stripbrackets = dropWhile (`elem` "([") . reverse . dropWhile (`elem` "])") . reverse :: String -> String
   |                                                                       ^^^^

hledger-lib/Hledger/Utils/String.hs:143:69: error:
    • Ambiguous type variable ‘f1’ arising from a use of ‘noneOf’
      prevents the constraint ‘(Foldable f1)’ from being solved.
      Probable fix: use a type annotation to specify what ‘f1’ should be.
      These potential instances exist:
        instance Foldable (Either a) -- Defined in ‘Data.Foldable’
        instance Foldable Maybe -- Defined in ‘Data.Foldable’
        instance Foldable ((,) a) -- Defined in ‘Data.Foldable’
        ...plus one other
        ...plus 67 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the second argument of ‘($)’, namely ‘noneOf "'"’
      In the third argument of ‘between’, namely ‘(many $ noneOf "'")’
      In the expression:
        between (char '\'') (char '\'') (many $ noneOf "'")
    |
143 |       singleQuotedPattern = between (char '\'') (char '\'') (many $ noneOf "'")
    |                                                                     ^^^^^^^^^^

hledger-lib/Hledger/Utils/String.hs:143:76: error:
    • Ambiguous type variable ‘f1’ arising from the literal ‘"'"’
      prevents the constraint ‘(Data.String.IsString
                                  (f1 Char))’ from being solved.
      Probable fix: use a type annotation to specify what ‘f1’ should be.
      These potential instances exist:
        instance (a ~ Tokens s, Data.String.IsString a, Eq a, Stream s,
                  Ord e) =>
                 Data.String.IsString (ParsecT e s m a)
          -- Defined in ‘Text.Megaparsec.Internal’
        instance (a ~ Char) => Data.String.IsString [a]
          -- Defined in ‘Data.String’
        ...plus 7 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the first argument of ‘noneOf’, namely ‘"'"’
      In the second argument of ‘($)’, namely ‘noneOf "'"’
      In the third argument of ‘between’, namely ‘(many $ noneOf "'")’
    |
143 |       singleQuotedPattern = between (char '\'') (char '\'') (many $ noneOf "'")
    |                                                                            ^^^

hledger-lib/Hledger/Utils/String.hs:144:67: error:
    • Ambiguous type variable ‘f0’ arising from a use of ‘noneOf’
      prevents the constraint ‘(Foldable f0)’ from being solved.
      Probable fix: use a type annotation to specify what ‘f0’ should be.
      These potential instances exist:
        instance Foldable (Either a) -- Defined in ‘Data.Foldable’
        instance Foldable Maybe -- Defined in ‘Data.Foldable’
        instance Foldable ((,) a) -- Defined in ‘Data.Foldable’
        ...plus one other
        ...plus 67 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the second argument of ‘($)’, namely ‘noneOf "\""’
      In the third argument of ‘between’, namely ‘(many $ noneOf "\"")’
      In the expression:
        between (char '"') (char '"') (many $ noneOf "\"")
    |
144 |       doubleQuotedPattern = between (char '"') (char '"') (many $ noneOf "\"")
    |                                                                   ^^^^^^^^^^^

hledger-lib/Hledger/Utils/String.hs:144:74: error:
    • Ambiguous type variable ‘f0’ arising from the literal ‘"\""’
      prevents the constraint ‘(Data.String.IsString
                                  (f0 Char))’ from being solved.
      Probable fix: use a type annotation to specify what ‘f0’ should be.
      These potential instances exist:
        instance (a ~ Tokens s, Data.String.IsString a, Eq a, Stream s,
                  Ord e) =>
                 Data.String.IsString (ParsecT e s m a)
          -- Defined in ‘Text.Megaparsec.Internal’
        instance (a ~ Char) => Data.String.IsString [a]
          -- Defined in ‘Data.String’
        ...plus 7 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the first argument of ‘noneOf’, namely ‘"\""’
Failed, 9 modules loaded.
      In the second argument of ‘($)’, namely ‘noneOf "\""’
      In the third argument of ‘between’, namely ‘(many $ noneOf "\"")’
    |
144 |       doubleQuotedPattern = between (char '"') (char '"') (many $ noneOf "\"")
    |                                                                          ^^^^

hledger-lib/Hledger/Utils/String.hs:78:30: error:
    • Ambiguous type variable ‘t2’ arising from a use of ‘elem’
      prevents the constraint ‘(Foldable t2)’ from being solved.
      Probable fix: use a type annotation to specify what ‘t2’ should be.
      These potential instances exist:
        instance Foldable (Either a) -- Defined in ‘Data.Foldable’
        instance Foldable Maybe -- Defined in ‘Data.Foldable’
        instance Foldable ((,) a) -- Defined in ‘Data.Foldable’
        ...plus one other
        ...plus 67 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the first argument of ‘dropWhile’, namely ‘(`elem` "\r\n")’
      In the first argument of ‘(.)’, namely ‘dropWhile (`elem` "\r\n")’
      In the second argument of ‘(.)’, namely
        ‘dropWhile (`elem` "\r\n") . reverse’
   |
78 | chomp = reverse . dropWhile (`elem` "\r\n") . reverse
   |                              ^^^^^^^^^^^^^
hledger-lib/Hledger/Utils/String.hs:78:37: error:
    • Ambiguous type variable ‘t2’ arising from the literal ‘"\r\n"’
      prevents the constraint ‘(Data.String.IsString
                                  (t2 Char))’ from being solved.
      Probable fix: use a type annotation to specify what ‘t2’ should be.
      These potential instances exist:
        instance (a ~ Tokens s, Data.String.IsString a, Eq a, Stream s,
                  Ord e) =>
                 Data.String.IsString (ParsecT e s m a)
          -- Defined in ‘Text.Megaparsec.Internal’
        instance (a ~ Char) => Data.String.IsString [a]
          -- Defined in ‘Data.String’
        ...plus 7 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the second argument of ‘elem’, namely ‘"\r\n"’
      In the first argument of ‘dropWhile’, namely ‘(`elem` "\r\n")’
      In the first argument of ‘(.)’, namely ‘dropWhile (`elem` "\r\n")’
   |
78 | chomp = reverse . dropWhile (`elem` "\r\n") . reverse
   |                                     ^^^^^^
hledger-lib/Hledger/Utils/String.hs:85:28: error:
    • Ambiguous type variable ‘t0’ arising from a use of ‘elem’
      prevents the constraint ‘(Foldable t0)’ from being solved.
      Probable fix: use a type annotation to specify what ‘t0’ should be.
      These potential instances exist:
        instance Foldable (Either a) -- Defined in ‘Data.Foldable’
        instance Foldable Maybe -- Defined in ‘Data.Foldable’
        instance Foldable ((,) a) -- Defined in ‘Data.Foldable’
        ...plus one other
        ...plus 67 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the first argument of ‘dropWhile’, namely ‘(`elem` "([")’
      In the first argument of ‘(.)’, namely ‘dropWhile (`elem` "([")’
      In the expression:
          dropWhile (`elem` "([")
            . reverse . dropWhile (`elem` "])") . reverse ::
            String -> String
   |
85 | stripbrackets = dropWhile (`elem` "([") . reverse . dropWhile (`elem` "])") . reverse :: String -> String
   |                            ^^^^^^^^^^^
hledger-lib/Hledger/Utils/String.hs:85:35: error:
    • Ambiguous type variable ‘t0’ arising from the literal ‘"(["’
      prevents the constraint ‘(Data.String.IsString
                                  (t0 Char))’ from being solved.