On Wednesday, February 15, 2017 at 8:49:13 PM UTC, Rupert Smith wrote:
>
> What I don't understand is why this fails to type check:
>
> mapWhenWithPosition : (WithPosition b -> a) -> State -> Maybe a
> mapWhenWithPosition func state =
>     case state of
>         Aware rect ->
>             Just <| func rect
>
>         Active rect ->
>             Just <| func rect
>
>         Inactive rect ->
>             Just <| func rect
>
>         _ ->
>             Nothing
>

I can get it to type check by defining the more general function in a 
let..in construct:
 
mapWhenWithPosition : (WithPosition {} -> a) -> State -> Maybe a
mapWhenWithPosition func state =
    let
        func_ : WithPosition b -> a
        func_ { rect } =
            func { rect = rect }
    in
        case state of
            Aware position ->
                Just <| func_ position

            Active position ->
                Just <| func_ position

            Inactive position ->
                Just <| func_ position

            _ ->
                Nothing

let..in behaves somewhat like the existential qualifier - "let us say that 
a more general type exists, by defining its implementation". I still have 
to unpack and repack the record but at least now, only once.

-- 
You received this message because you are subscribed to the Google Groups "Elm 
Discuss" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to [email protected].
For more options, visit https://groups.google.com/d/optout.

Reply via email to