I’ve seen mentioned few times that if data structure contains a function, then it can’t be safely compared, as comparison may crash.
But if data structure contains
NaN in addition to the function, so that comparison always compares
NaN before the function, then comparison will never crash.
$ elm repl > a = (0/0, (\x -> x + 10)) > b = a > c = (0/0, (\x -> x + 100)) > a == b True: Bool > a == c False: Bool
If references are same, Elm does shallow comparison of references and returns
True. Otherwise Elm begins deep comparison starting from the first item of tuples which is
NaN == NaN is
False, Elm returns
False. So comparison never gets to actual functions in second item of tuple.
Simple example of an opaque type storing a function:
$ elm repl -- SETUP > type Func a = Func (Float, (a -> a)) > new fn = Func (0/0, fn) > run (Func (_, fn)) x = fn x -- CREATE FUNCTIONS > a = new (\x -> x + 10) > b = a > c = new (\x -> x + 100) -- COMPARE FUNCTIONS > a == b True : Bool > a == c False : Bool -- RUN FUNCTIONS > run a 1 11 : number > run b 2 12 : number > run c 3 103 : number