Back to Questions
642
views1
comment
Forward Function Composition: compiler appears confused
f#compiler

I can illustrate my problem with this useless snippet:

type LabeledList = ( string * list<int> )
let TwoLabeledLists (l1:LabeledList) (l2:LabeledList) : list<LabeledList> =
[ l1 ; l2 ]
let DoNothing (l:list<LabeledList>) =
l
let ComposedFunc = TwoLabeledLists >> DoNothing

The minor problem is that the compiler reads the type definition of TwoLabeledLists as String * int list -> String * int list -> LabeledList list. This even though I've added the type annotations.

The major problem is that the compiler shows this error over the call to DoNothing:

Type mismatch. Expecting a (LabeledList -> LabeledList list) -> 'a but given a LabeledList list -> LabeledList list.

I've no idea what to make of the type that the function composition operator expects. Since the first function returns list<LabeledList> and the second function accepts the same type, what is throwing the compiler off?

.

The composition operator expects an ('a -> 'b) as its first argument, and you gave it a (LabeledList -> LabeledList -> LabeledList list).
It will therefore infer 'a as LabeledList and 'b as (LabeledList -> LabeledList list) and complain that the latter doesn't match the type of the argument of DoNothing. The solution in this snippet is to declare TwoLabeledLists as taking a pair as argument.

By on 12/8/2009 12:41 PM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper