奇怪的haskell分析错误

所以我对Haskell只有一点经验，我一直在做下面的程序来实现一个搜索，在函数中找到最大值，但是我收到了一个奇怪的错误。当我编译时，它说：

MaximaSearch.hs:26:1: 分析错误（可能缩进不正确或括号不匹配）

这是写着“main=do”的那一行，所以我认为这是我在前面代码中缩进的某种尾随错误，但我无法发现任何错误

代码如下：

 module Main where                                                                  
  g :: Float -> Float                                                                
  --your function here                                                               
  g x = cos(x^2)                                                                     

  --goldenSectionSearch                                                              
  goldenSS :: (Float -> Float) -> Float -> Float -> Float -> Float -> Float          
  goldenSS f a b c tau                                                               
    | (c-a) < tau * (abs b + abs x) = (c+a)/2                                        
    |f x > f b = let                                                                 
                  t1|(c - b) > (b-a) = goldenSS f b x c tau                          
                    |otherwise = goldenSS f a x b tau                                
                  in t1                                                              
    |otherwise = let                                                                 
                  t2|(c-b) > (b-a) = goldenSS f a b x tau                            
                    |otherwise = goldenSS f x b c tau                                
                  in t2                                                              
    where                                                                            
      let x                                                                          
            | (c-b) >  (b-a) = b + resphi*(c-b)                                      
            |otherwise = b - resphi*(b-a)                                            
            where resphi = 2 - phi where phi = (1+ sqrt 5)/2                         
        in x                                                                         

  --main                                                                             
  main = do                                                                          
          print x                                                                    
          print (g x)                                                                
            where                                                                    
              x = goldenSS g a ((a+b)/2) b tau                                       
                where                                                                
                  a = 2                                                              
                  b = 3                                                              
                  tau = 0.001      

modulemain其中
g:：Float->Float
--你在这里的职能
gx=cos（x^2）
--黄金搜索
goldenSS:：（浮动->浮动）->浮动->浮动->浮动->浮动->浮动->浮动
金丝f a b c头
|（c-a）fb=let
t1 |（c-b）>（b-a）=黄金f b x c tau
|否则=黄金f a x b tau
在t1中
|否则=让
t2 |（c-b）>（b-a）=黄金f a b x头
|否则=黄金f x b c tau
在t2
哪里
让x
|（c-b）>（b-a）=b+resphi*（c-b）
|否则=b-resphi*（b-a）
式中resphi=2-φ，其中φ=（1+sqrt 5）/2
在x中
--主要
main=do
打印x
打印（Gx）
哪里
x=黄金g a（（a+b）/2）b tau
哪里
a=2
b=3
tau=0.001

---

有什么想法吗？

出现解析错误的原因是代码中非惯用的

let

和

where

绑定

Haskell允许使用多种语法结构进行临时绑定和模式匹配，但是您以一种非常奇怪和混乱的方式将它们组合在一起

为了学习如何以Haskell更常见的方式编写代码清理器，我建议查找现有的Haskell库和程序（例如上），了解

let

和

绑定通常在哪里工作。一般来说，我发现对于纯函数，我几乎只使用
where
（而不是
let
），但某些东西是风格上的

对于这段代码，我对它做了一些修改，使用了
where
绑定，而不是
let
，它现在为我编译并运行。即使您必须对其进行一些调整以使其能够为您进行编译，此总体结构也更清晰，并且不太可能给您带来解析错误：

module Main where                                 

g :: Float -> Float                                                      
g x = cos(x^2)                                                           

goldenSS :: (Float -> Float) -> Float -> Float -> Float -> Float -> Float 
goldenSS f a b c tau                                        
  |(c-a) < tau * (abs b + abs x) = (c+a)/2                               
  |f x > f b = t1                         
  |otherwise = t2                                      

  where x | (c-b) >  (b-a) = b + resphi*(c-b)                  
          |otherwise = b - resphi*(b-a)    

        resphi = 2 - phi

        phi = (1+ sqrt 5)/2                         

        t1 |(c - b) > (b-a) = goldenSS f b x c tau                         
           |otherwise = goldenSS f a x b tau       


        t2 |(c-b) > (b-a) = goldenSS f a b x tau                            
           |otherwise = goldenSS f x b c tau  



main =
  do                                                                          
    print x                                                                    
    print (g x)                                                                
  where x = goldenSS g a ((a+b)/2) b tau                                       
        a = 2                                                              
        b = 3                                                              
        tau = 0.001      

modulemain其中
g:：Float->Float
gx=cos（x^2）
goldenSS:：（浮动->浮动）->浮动->浮动->浮动->浮动->浮动->浮动
金丝f a b c头
|（c-a）fb=t1
|否则=t2
其中x |（c-b）>（b-a）=b+resphi*（c-b）
|否则=b-resphi*（b-a）
resphi=2-φ
φ=（1+sqrt 5）/2
t1 |（c-b）>（b-a）=黄金f b x c tau
|否则=黄金f a x b tau
t2 |（c-b）>（b-a）=黄金f a b x头
|否则=黄金f x b c tau
主要=
做
打印x
打印（Gx）
式中x=黄金g a（（a+b）/2）bτ
a=2
b=3
tau=0.001
请删除代码示例中的行号。好的，删除了行号您的代码有很多问题。。。特别是，您在
let
绑定中使用的保护非常奇怪。如果

-

那么

-