Compiler running out of memory with polymorphically recursive function - recursion

Question

If I try to compile the following code for adding to a fingertree, the elm compiler waits a long time and then reports that it is out of memory.
module FingerTree exposing(..)
type Node a
= Node2 a a
| Node3 a a a
type Finger a
= One a
| Two a a
| Three a a a
| Four a a a a
type FingerTree a
=Empty
|Single a
|Deep (Finger a) (FingerTree(Node a)) (Finger a)
fLeftAdd: a -> Finger a -> Finger a
fLeftAdd a0 finger =
case finger of
One a1 -> Two a0 a1
Two a1 a2 -> Three a0 a1 a2
Three a1 a2 a3 -> Four a0 a1 a2 a3
Four a1 a2 a3 a4 -> finger
leftAdd: a -> FingerTree a -> FingerTree a
leftAdd a0 fingerTree=
case fingerTree of
Empty -> Single a0
Single a1 -> Deep (One a0) Empty (One a1)
Deep left middle right ->
case left of
Four a1 a2 a3 a4 ->
Deep(Two a0 a1) ( leftAdd (Node3 a2 a3 a4) middle) right
_ -> Deep (fLeftAdd left a0) middle right
My first thought was that perhaps you just can't have polymorphic recursion (a polymorphic function calling itself with a different type signature). However this variant, replacing the custom "Finger" and "Node" types with lists, compiles fine:
module HackyTree exposing(..)
type HackyTree a
= Empty
|Single a
|Deep (List a) (HackyTree (List a)) (List a)
leftAdd: a -> HackyTree a -> HackyTree a
leftAdd a0 tree=
case tree of
Empty -> Single a0
Single a1 -> Deep [a0] Empty [a1]
Deep left middle right ->
case left of
[a1, a2, a3, a4] ->
Deep [a0, a1] ( leftAdd [a2, a3, a4] middle) right
_ -> Deep (a0::left) middle right
I'd like to get the first version working. Is this a compiler bug? Is there a recommended way to refactor to avoid this?

Answer 1

Are you sure your last line is _ -> Deep (fLeftAdd left a0) middle right and not _ -> Deep (fLeftAdd a0 left) middle right? If I change it everything compiles fine.
Note that the signature of fLeftAdd is fLeftAdd: a -> Finger a -> Finger a. You are pattern matching on a FingerTree a, in particular the Deep (Finger a) (FingerTree(Node a)) (Finger a) case.
With _ -> Deep (fLeftAdd left a0) middle right you're applying fLeftAdd to a left, which is a Finger a and to a0, which is an a.
You also have the constraint that the result of (fLeftAdd left a0) and right have the same type.
This means that (fLeftAdd left a0) should produce a Finger a when given a Finger a and an a as parameters, which breaks type inference since fLeftAdd: a -> Finger a -> Finger a.
This is a minimal example where the compiler doesn't go out of memory:
leftAdd: a -> FingerTree a -> FingerTree a
leftAdd a0 fingerTree=
case fingerTree of
Deep left middle right ->
Deep (fLeftAdd left a0) middle right
_ -> Single a0
I pasted it in Try Elm and I got the following error messages:
-- TYPE MISMATCH ---------------------------------------------------------------
The type annotation for leftAdd does not match its definition.
27| leftAdd: a -> FingerTree a -> FingerTree a
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The type annotation is saying:
a -> FingerTree a -> FingerTree a
But I am inferring that the definition has this type:
Finger ? -> FingerTree ? -> FingerTree (Finger ?)
Hint: A type annotation is too generic. You can probably just switch
to the type I inferred. These issues can be subtle though, so read
more about it.
https://github.com/elm-lang/elm-compiler/blob/0.17.0/hints/type-annotations.md
-- INFINITE TYPE ---------------------------------------------------------------
I am inferring a weird self-referential type for left
30| Deep left middle right ->
^^^^ Here is my best effort at writing down the type. You will see ? and ∞ for parts of the type that repeat something already
printed out infinitely.
?
Usually staring at the type is not so helpful in these cases, so
definitely read the debugging hints for ideas on how to figure this
out:
https://github.com/elm-lang/elm-compiler/blob/0.17.0/hints/infinite-type.md
I'd recommend you to try to create a simple self contained compilable example and raise an issue on the compiler project