Sorry, i don't refer the paper on other email. But the paper was "Helium, for Learning Haskell"
No dia 10 de Outubro de 2010 12:22, André Batista Martins < [email protected]> escreveu: > I thanks for the answers. > On this paper, i found this example > "The student has accidental given the arguments of map in the wrong > order. Again, the logged student programs show that this is indeed > a common mistake. > (1,8): Type error in application > expression : map [1 .. 10] even > term : map > type : (a -> b) -> [a] -> [b] > does not match : [Int] -> (Int -> Bool) -> c > probable fix : re-order arguments > " > The solution i think was in reordering of function arguments and the > elements of a tuple, and the insertion or removal of function arguments. > > In general, this problem appears also in sequence of functions. So if we do > the bridge between the functions, and that bridge was one function to > re-order the elements of output to the correct input of next function. > > I think that work has been done, in helium compiler. But i can't identify > the algorithm for this propose. > > How i can find the type of one function that i was done, on code, not on > compiler? > > > Cheers, > André > > > > > > No dia 10 de Outubro de 2010 07:58, Gene A <[email protected]> escreveu: > > >> >> 2010/10/9 André Batista Martins <[email protected]> Said: >> >>> >>> Might have not been clear, but i will try illustrate . >>> >>> f:: a-> b -> c -> (b,(c,a)) >>> f1 :: c -> a -> d >>> >> ----------------------------- >> >> >>> >>> I think I would attack this with glue consisting of: >> >> comb f f1 a b c = arr (\(a,b,c) -> f a b c) >>> arr (\(b,(c,a))) ->f1 c >> a) $ (a,b,c) >> >> and yes, have to agree that easier to roll your own if only a few >> functions are like this.. >> but should be able to parse the type signatures of the functions involved >> and write a program to automate this process.. using this format as a >> template.. >> >> Actually if you just set it to take all the variables prior to last (->) >> in sig you can put them >> put them together in an uncurried format.. for instance the "a -> b -> c" >> portion would become always \(a,b,c) -> then the function so arr (\(a,b,c) >> -> f a b c) then the term (output) would be the last term in this case >> (b,(c,a) add that with a "->" between to give that to first part of another >> lambda construction (\(c,a) -> f1 c a) ... arrowizing the whole thing with >> arr (first lambda) >>> arr (second lambda) $ and a tuple from all but the >> last variables in all cases of first function ... so for f it would be >> (a,b,c). if for some odd reason it was a single it would just become ((a)) >> an added parenthesis, which would not hurt a thing for the case where it was >> a sig like f :: a -> b >> >> So for your case it becomes as shown above: >> comb f f1 a b c = arr (\(a,b,c) -> f a b c) >>> arr (\(b,(c,a))) ->f1 c >> a) $ (a,b,c) >> and say for: >> >> f :: a -> (b,c) >> f1:: b -> d >> >> (\(a) -> f a) >>> (\(b,c) -> f1 b) $ (a) <- it just harmlessly adds the >> '( ' and ')' around the 'a' even though it doesn't need it as the only >> parameter prior to the last '->'. >> >> This is probably clear as mud, on first look, but I think a way forward in >> automating from >> this is possible.. I am sure of it.. but it would be at the source code >> level and a string parse and output from that .. >> >> cheers, >> gene >> >> >> >
_______________________________________________ Haskell-Cafe mailing list [email protected] http://www.haskell.org/mailman/listinfo/haskell-cafe
