Poor error message on unbound variable

[ocharles]

Given

    let GitHubProject : Type = { owner : Text, repo : Text }

in  let gitHubProject =
            λ(github : GitHubProject)
          →     let gitHubRoot =
                          "https://github.com/"
                      ++  github.owner
                      ++  "/"
                      ++  github.repo
                      ++  ""
            
            in    ./empty-package.dhall 
                ⫽ { bugReports = gitHubRoot ++ "/issues", name = repo }

in  gitHubProject

I get:

dhall-to-cabal: 
↳ ./dhall/gitHubProject.dhall 

majorVersion : List Natural → VersionRange
VersionRange : Type
anyVersion : VersionRange
github : { owner : Text, repo : Text }

Error: Unbound variable

Explanation: Expressions can only reference previously introduced (i.e. "bound")
variables that are still "in scope"                                           
                                                                                
For example, the following valid expressions introduce a "bound" variable named
❰x❱:                                                                            
                                                                                
                                                                                
    ┌─────────────────┐                                                         
    │ λ(x : Bool) → x │  Anonymous functions introduce "bound" variables      
    └─────────────────┘                                                         
        ⇧                                                                       
        This is the bound variable                                              
                                                                                
                                                                                
    ┌─────────────────┐                                                         
    │ let x = 1 in x  │  ❰let❱ expressions introduce "bound" variables        
    └─────────────────┘                                                         
          ⇧                                                                     
          This is the bound variable                                            
                                                                                
                                                                                
However, the following expressions are not valid because they all reference a   
variable that has not been introduced yet (i.e. an "unbound" variable):       
                                                                                
                                                                                
    ┌─────────────────┐                                                         
    │ λ(x : Bool) → y │  The variable ❰y❱ hasn't been introduced yet            
    └─────────────────┘                                                         
                    ⇧                                                           
                    This is the unbound variable                                
                                                                                
                                                                                
    ┌──────────────────────────┐                                                
    │ (let x = True in x) && x │  ❰x❱ is undefined outside the parentheses      
    └──────────────────────────┘                                                
                             ⇧                                                  
                             This is the unbound variable                       
                                                                                
                                                                                
    ┌────────────────┐                                                          
    │ let x = x in x │  The definition for ❰x❱ cannot reference itself          
    └────────────────┘                                                          
              ⇧                                                                 
              This is the unbound variable                                      
                                                                                
                                                                                
Some common reasons why you might get this error:                               
                                                                                
● You misspell a variable name, like this:                                      
                                                                                
                                                                                
    ┌────────────────────────────────────────────────────┐                      
    │ λ(empty : Bool) → if emty then "Empty" else "Full" │                  
    └────────────────────────────────────────────────────┘                      
                           ⇧                                                    
                           Typo                                                 
                                                                                
                                                                                
● You misspell a reserved identifier, like this:                                
                                                                                
                                                                                
    ┌──────────────────────────┐                                                
    │ foral (a : Type) → a → a │                                                
    └──────────────────────────┘                                                
      ⇧                                                                         
      Typo                                                                      
                                                                                
                                                                                
● You tried to define a recursive value, like this:                             
                                                                                
                                                                                
    ┌─────────────────────┐                                                     
    │ let x = x + +1 in x │                                                     
    └─────────────────────┘                                                     
              ⇧                                                                 
              Recursive definitions are not allowed                             
                                                                                
                                                                                
● You accidentally forgot a ❰λ❱ or ❰∀❱/❰forall❱                                 
                                                                                
                                                                                
        Unbound variable                                                        
        ⇩                                                                       
    ┌─────────────────┐                                                         
    │  (x : Bool) → x │                                                         
    └─────────────────┘                                                         
      ⇧                                                                         
      A ❰λ❱ here would transform this into a valid anonymous function           
                                                                                
                                                                                
        Unbound variable                                                        
        ⇩                                                                       
    ┌────────────────────┐                                                      
    │  (x : Bool) → Bool │                                                      
    └────────────────────┘                                                      
      ⇧                                                                         
      A ❰∀❱ or ❰forall❱ here would transform this into a valid function type    

────────────────────────────────────────────────────────────────────────────────

let GitHubProject : Type = { owner : Text, repo : Text }

in  let gitHubProject =
            λ(github : GitHubProject)
          →     let gitHubRoot =
                          "https://github.com/"
                      ++  github.owner
                      ++  "/"
                      ++  github.repo
                      ++  ""
            
            in    ./empty-package.dhall 
                ⫽ { bugReports = gitHubRoot ++ "/issues", name = repo }

in  gitHubProject

dhall/gitHubProject.dhall:1:5

The unbound variable is repo, but the error message doesn't tell me that.

[Gabriel439]

Yeah, we can add the variable name to the error message.

For some context: https://github.com/dhall-lang/dhall-haskell/blob/master/src/Dhall/TypeCheck.hs#L743-L744

The original reason I recommended against the error message having the variable name is because the source span for the error should be localized to exactly the unbound variable. However, for some reason it looks like that didn't work here, so it's probably worth including the variable name in the error message as a fallback.

[Gabriel439]

Actually, I think I found the root cause for why the source span localization was so bad. This was related to the recent support for type synonyms and it's pretty simple fix, which produces this much better output:

dhall <<< './yourExample' 

Use "dhall --explain" for detailed errors

↳ ./yourExample 

github : { owner : Text, repo : Text }

Error: Unbound variable

repo

foo:12:66

Once I fix that would that satisfy your concerns or would you still like to see the name of the unbound variable on the Error: line?

[Gabriel439]

Fix up in #218

Try that out and see if that improves the error messages for you. If it does, then I'll merge

[ocharles]

As long as something shows me the erroneous variable then I think I'm ok with it. Will check that out

…

On 21 Jan 2018 5:54 am, "Gabriel Gonzalez" ***@***.***> wrote: Fix up in #218 <#218> Try that out and see if that improves the error messages for you. If it does, then I'll merge — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub <#217 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AABRjjjtAIM2HTjVE_7APrHnPdkCCDTgks5tMtEXgaJpZM4RlbUp> .

[Gabriel439]

In that case I will go ahead and close this since it should print the source span equivalent to the unbound variable now (assuming no other bugs in source span localizaiton)