elm-lang.org brought down by infinite loop in compiler about compiler HOT 8 CLOSED

Thanks for the report! The server is back up, and I'll work on figuring this one out. The type you describe is recursive, not infinite (I think this is a standard distinction, not sure though). The point is that the type of DragCircle can be written down with a finite amount of characters. This sort of thing should type-check, but I'll look into this more.

The mutually recursive functions you define (move and rest) actually have an infinite type:

move :: (Int,Int) -> Bool -> ( (Int,Int) -> Bool -> ( (Int,Int) -> Bool -> (...) ) )

I should be detecting this and throwing an error, but I guess not in this case!

Were you also seeing this behavior on functions that did not have infinite types?

from compiler.

Were you also seeing this behavior on functions that did not have infinite types?

I don't think so. I'm pretty sure dragCircle had an infinite type. Going by my definition above:

dragCircle :: (Form, (Number, Number) -> Bool -> (Form, (Number, Number) -> Bool -> (Form, (Number, Number) -> Bool -> ...)))

I used type in the Haskell sense, meaning a type alias. Does Elm treat type differently?

Also, note that if you change the offending code sample to:

move pos down = rest
rest pos down = (move, rest)

It doesn't crash, it just accepts the code (which Haskell rejects due to an occurs check failure).

from compiler.

To clarify, I didn't use the type keyword in the actual code. The type signatures I gave were the types I was expecting the code to have.

from compiler.

Ok, makes sense. I was treating type as data in my mind. I'll work on this!

from compiler.

I found a more innocent-looking piece of code that blows up the compiler:

f = foldr1 (:) [1..10]

The problem is that the Elm compiler does not seem to implement an occurs check. Namely, when unifying types, and you have a situation like this:

unify a [[a]]

This should be treated as a type error, since the substitution a ==> [[a]] forms an infinite type.

In general, when unifying a type variable a with type T:

• If T is the type variable a, no need for a substitution.
• If T contains the type variable a (e.g. [a], Maybe a, a -> Int), produce an "occurs check" error.

Typing Haskell in Haskell, section 6 describes unification and matching algorithms pretty nicely.

from compiler.

I am pretty certain you are correct, and I believe this can be corrected pretty easily. I'll take a look now.

I'll take a read through the link you provided to see if I can clean things up / find other mistakes!

from compiler.

Ok, fixed and pushed to master!

from compiler.

Released!

from compiler.