Haskell：where句はラムダの束縛変数を参照しています

Question

私は積分する区間の終点の引数a、bを取る反微分を返して、台形則を使ってHaskellで関数を数値的に積分しようとしています。上記で

integrate :: (Float -> Float) -> (Float -> Float -> Float) 

integrate f 
    = \ a b -> d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
    where 
     d = (b - a)/n 
     n = 1000 

、私は

n - for the number of subintervals 
d - for the width of each subinterval 

これを使用し、ほぼラムダ中の結合の引数、Bを除き、動作します。私は エラーメッセージが出ます：

Not in scope: `b' 
Not in scope: `a' 

を私は（の範囲は、bはちょうどそのラムダ式に制限されないが、私は記述する必要はありませんように はHaskellでは回避策は存在していることを理解することができますba）/ nは上記のdの出現ごとに？

Answer 1

試してみてください。

integrate f a b = d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
    where 
     d = (b - a)/n 
     n = 1000 

Answer 2

あなたは2 Float秒を取り、Floatを返す関数を返す必要が考えているが、実際にそれがあなたのintegrate機能に2つの余分なFloatの引数を取り、使用に何ら変わりませんカリング（つまり、それらを提供しないでください。戻り値の型はFloat -> Float -> Floatになります）。

だから、この

integrate :: (Float -> Float) -> Float -> Float -> Float 

integrate f a b 
    = d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
    where 
     d = (b - a)/n 
     n = 1000 

それとも、代わりにwhereのlet ... inを使用することができますようにあなたの関数を書き換えることができます。

integrate f 
    = \a b -> 
     let d = (b - a/n) 
      n = 1000 
     in d * sum [ f (a + d * k) | k <- [0..n] ] - d/2.0 * (f a + f b) 

Answer 3

確かに。あなたはどこに主張する場合

integrate f a b = d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
    where 
     d = (b - a)/n 
     n = 1000 

Answer 4

：

integrate f = \a b -> case() of 
    () -> d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
      where 
       d = (b - a)/n 
       n = 1000 

はかなり良さそうだが、それをしないのですか？ は、ケースはもう少しやる気に見えるようにするには：

integrate f = \a b -> case (f a + f b) of 
    fs -> d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * fs 
      where 
       d = (b - a)/n 
       n = 1000 

Answer 5

あなたは回避策がたくさんあります。

あなたはラムダ式を除く任意の結合構文がわからない場合、あなたがこれを行うことができます（私は、その理論的な美しさを最も愛しているが、その構文上の醜さを使用することはありませんどの）：

integrate f 
    = \a b -> (\d -> d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b)) 
      ((b - a)/n) 
    where 
     n = 1000 

の場合

integrate f = go 
    where 
    n = 1000 
    go a b = d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
     where 
     d = (b - a)/n 

あなたもlet -syntaxを知っている場合は、あなたがこれを行うことができます：

を定義し、唯一のあなたがこれを行うことができ-syntax whereを知っているあなたのような

integrate f = 
    \a b -> let d = (b - a)/n 
      in d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
    where 
    n = 1000 

あなたはa -> (b -> c -> d)がa -> b -> c -> dと同じであることを覚えていれば最後に、あなたが明白な操作を行うことができます。

integrate f a b = d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
    where 
    n = 1000 
    d = (b - a)/n