André Batista Martins andre_bm at netcabo.pt
Sun Oct 10 07:24:13 EDT 2010

```Sorry, i don't refer the paper on other email. But the paper was "Helium,

No dia 10 de Outubro de 2010 12:22, André Batista Martins <
andre_bm at netcabo.pt> 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 <yumagene at gmail.com> escreveu:
>
>
>>
>> 2010/10/9 André Batista Martins <andre_bm at netcabo.pt> 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
>>
>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...