Warum gibt in Haskell der |> - Operator in diesem Beispiel den Bereichsfehler aus?

Question

{-# LANGUAGE ScopedTypeVariables #-} 

module Main where 
    import Control.Applicative ((<$>)) 
    import Data.ByteString (ByteString) 
    import qualified Data.ByteString as B 
    import qualified Data.ByteString.Char8 as C 
    import qualified Data.Vector.Unboxed as V 
    import qualified Data.Vector as VB 
    import qualified Data.List as L 

    (|>) :: a -> (a -> b) -> b 
    x |> f = f x 

    main :: IO() 
    main = 
    let 
     parse (s :: ByteString) = s |> L.unfoldr (C.readInt . C.dropWhile (== ' ')) 
     solve (l :: Int) (ars :: VB.Vector ByteString) = 
      let 
       (n :: V.Vector (Int, Int)) = V.fromList [(x,y) | x <- [0..l-1], y <- [x+1..l-1]] 
      in 
       n 
    in do 
     [n,l :: Int] <- parse <$> B.getLine 
     (ars :: VB.Vector ByteString) <- VB.replicateM n B.getLine 
     ars 
     |> solve l 
     |> print 

Der Compiler beklagt, dass l aus irgendeinem Grund hier nicht in Betracht kommt. Warum das?

Not in scope: `l' 

auch der Grund, warum der Code so aussieht, weil ich gerade dachte ich heraus, was die ScopedTypeVariables Erweiterung tut. Es sollte in der richtigen Sprache und in den Einsteigertutorials sein. Es hätte mir in den letzten Wochen viel Schmerz erspart.

Answer 1

Ihre Einrückung ist falsch. Eine der folgenden Arbeiten.

{-# LANGUAGE ScopedTypeVariables #-} 
import Data.ByteString as B 
import qualified Data.Vector.Unboxed as V 
import qualified Data.Vector as VB 
import Data.List as L 
import Data.ByteString.Char8 as C 

(|>) :: a -> (a -> b) -> b 
x |> f = f x 

main :: IO() 
main = 
    let 
    parse (s :: ByteString) = s |> L.unfoldr (C.readInt . C.dropWhile (== ' ')) 
    solve (l :: Int) (ars :: VB.Vector ByteString) = 
     let 
     (n :: V.Vector (Int, Int)) = V.fromList [(x,y) | x <- [0..l-1], y <- [x+1..l-1]] 
     in 
     n 
    in do 
    [n,l :: Int] <- parse <$> B.getLine 
    (ars :: VB.Vector ByteString) <- VB.replicateM n B.getLine 
    ars |> solve l |> print 

-

{-# LANGUAGE ScopedTypeVariables #-} 
import Data.ByteString as B 
import qualified Data.Vector.Unboxed as V 
import qualified Data.Vector as VB 
import Data.List as L 
import Data.ByteString.Char8 as C 

(|>) :: a -> (a -> b) -> b 
x |> f = f x 

main :: IO() 
main = 
    let 
    parse (s :: ByteString) = s |> L.unfoldr (C.readInt . C.dropWhile (== ' ')) 
    solve (l :: Int) (ars :: VB.Vector ByteString) = 
     let 
     (n :: V.Vector (Int, Int)) = V.fromList [(x,y) | x <- [0..l-1], y <- [x+1..l-1]] 
     in 
     n 
    in do 
    [n,l :: Int] <- parse <$> B.getLine 
    (ars :: VB.Vector ByteString) <- VB.replicateM n B.getLine 
    ars |> 
     solve l |> 
     print