Core Erlang apply target expression behaviour

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
5 messages Options
Reply | Threaded
Open this post in threaded view
|

Core Erlang apply target expression behaviour

Karl Nilsson-2
Whilst trying to compile some code to core erlang I came across a problem when the target expression (e0 in spec) to apply was another apply expression. According to the spec I thought that would be ok however when compiling the .core file with erlc I got an "no_file: Warning: invalid function call" error.

What I then tried, not thinking it would work, was to wrap the inner apply expression in a let expression. This to my surprise worked just fine. I've included the code below. 'addSix` is the working function and `addSix2` is the dodgy one. Am I doing something wrong in `addSix2` to in terms of how I print my AST or is it simply that `addSix2` cannot be made to work? I also tried putting some parens around it but that also didn't work.

'add'/2 =
    fun (_a0,_b0) ->
        call 'erlang':'+'(_a0,_b0)

'addFive'/0 =
    fun () ->
        let <_a0> = 5
        in fun (_b0) ->
    apply 'add'/2 (_a0,_b0)

'addSix'/1 =
    fun (_x0) ->
        call 'erlang':'+'(let <_fez0> = apply 'addFive'/0 ()
in apply _fez0 (_x0),1)

'addSix2'/1 =
    fun (_x0) ->
        call 'erlang':'+'(apply     apply 'addFive'/0 () (_x0),1)


Cheers
Karl

_______________________________________________
erlang-questions mailing list
[hidden email]
http://erlang.org/mailman/listinfo/erlang-questions
Reply | Threaded
Open this post in threaded view
|

Re: Core Erlang apply target expression behaviour

Robert Virding
I would try doing 2 things:

- Write the equivalent Erlang code which does what you want the code to do, compile it with the to_core0 option and see what it generates. This then becomes your target code. This is how I did it with LFE.

- Or you can try flattening out your code to remove the nested calls. While Core erlang in principle should be able to manage nested code the Erlang compiler generally flattens things.

What I found when doing LFE was that while the language *in principle* allows a lot of things *in practice* later passes in the compiler, for example the optimisation passes, assume that the code looks like what the Erlang compiler compiler generates. One example of this is how literal structures are represented.

to_core0 returns the Core erlang which has been generated by the erlang->core conversion pass which is then what is passed on to optimisation and and code generation. This is what you should be targeting.

To check what the actual Core erlang data structures look like, not the pretty printed code, in the shell try doing:

> c("foo", [binary,to_core0,return]).

This call will *return* the actual data structure so you can put it in variable then pretty print it to a file so you can what you really need to get. Note that some of the attributes are important in later passes.

What language are you working on?

Robert


On 21 April 2017 at 19:12, Karl Nilsson <[hidden email]> wrote:
Whilst trying to compile some code to core erlang I came across a problem when the target expression (e0 in spec) to apply was another apply expression. According to the spec I thought that would be ok however when compiling the .core file with erlc I got an "no_file: Warning: invalid function call" error.

What I then tried, not thinking it would work, was to wrap the inner apply expression in a let expression. This to my surprise worked just fine. I've included the code below. 'addSix` is the working function and `addSix2` is the dodgy one. Am I doing something wrong in `addSix2` to in terms of how I print my AST or is it simply that `addSix2` cannot be made to work? I also tried putting some parens around it but that also didn't work.

'add'/2 =
    fun (_a0,_b0) ->
        call 'erlang':'+'(_a0,_b0)

'addFive'/0 =
    fun () ->
        let <_a0> = 5
        in fun (_b0) ->
    apply 'add'/2 (_a0,_b0)

'addSix'/1 =
    fun (_x0) ->
        call 'erlang':'+'(let <_fez0> = apply 'addFive'/0 ()
in apply _fez0 (_x0),1)

'addSix2'/1 =
    fun (_x0) ->
        call 'erlang':'+'(apply     apply 'addFive'/0 () (_x0),1)


Cheers
Karl

_______________________________________________
erlang-questions mailing list
[hidden email]
http://erlang.org/mailman/listinfo/erlang-questions



_______________________________________________
erlang-questions mailing list
[hidden email]
http://erlang.org/mailman/listinfo/erlang-questions
Reply | Threaded
Open this post in threaded view
|

Re: Core Erlang apply target expression behaviour

Karl Nilsson-2
Thanks for the advice. A few things to think about there. 
I have been writing things in erlang, compiling and comparing but rather than writing a language from scratch I am working from the AST (or rather the TAST) from another language, fsharp. As fsharp is an ML and core erlang is ML-ish I was hoping to avoid having to do too much mangling but flattening out applies and mod calls with let expressions is easy enough so I'll definitely do that. 

Cheers
Karl

On Sat, 22 Apr 2017 at 20:19 Robert Virding <[hidden email]> wrote:
I would try doing 2 things:

- Write the equivalent Erlang code which does what you want the code to do, compile it with the to_core0 option and see what it generates. This then becomes your target code. This is how I did it with LFE.

- Or you can try flattening out your code to remove the nested calls. While Core erlang in principle should be able to manage nested code the Erlang compiler generally flattens things.

What I found when doing LFE was that while the language *in principle* allows a lot of things *in practice* later passes in the compiler, for example the optimisation passes, assume that the code looks like what the Erlang compiler compiler generates. One example of this is how literal structures are represented.

to_core0 returns the Core erlang which has been generated by the erlang->core conversion pass which is then what is passed on to optimisation and and code generation. This is what you should be targeting.

To check what the actual Core erlang data structures look like, not the pretty printed code, in the shell try doing:

> c("foo", [binary,to_core0,return]).

This call will *return* the actual data structure so you can put it in variable then pretty print it to a file so you can what you really need to get. Note that some of the attributes are important in later passes.

What language are you working on?

Robert


On 21 April 2017 at 19:12, Karl Nilsson <[hidden email]> wrote:
Whilst trying to compile some code to core erlang I came across a problem when the target expression (e0 in spec) to apply was another apply expression. According to the spec I thought that would be ok however when compiling the .core file with erlc I got an "no_file: Warning: invalid function call" error.

What I then tried, not thinking it would work, was to wrap the inner apply expression in a let expression. This to my surprise worked just fine. I've included the code below. 'addSix` is the working function and `addSix2` is the dodgy one. Am I doing something wrong in `addSix2` to in terms of how I print my AST or is it simply that `addSix2` cannot be made to work? I also tried putting some parens around it but that also didn't work.

'add'/2 =
    fun (_a0,_b0) ->
        call 'erlang':'+'(_a0,_b0)

'addFive'/0 =
    fun () ->
        let <_a0> = 5
        in fun (_b0) ->
    apply 'add'/2 (_a0,_b0)

'addSix'/1 =
    fun (_x0) ->
        call 'erlang':'+'(let <_fez0> = apply 'addFive'/0 ()
in apply _fez0 (_x0),1)

'addSix2'/1 =
    fun (_x0) ->
        call 'erlang':'+'(apply     apply 'addFive'/0 () (_x0),1)


Cheers
Karl

_______________________________________________
erlang-questions mailing list
[hidden email]
http://erlang.org/mailman/listinfo/erlang-questions



_______________________________________________
erlang-questions mailing list
[hidden email]
http://erlang.org/mailman/listinfo/erlang-questions
Reply | Threaded
Open this post in threaded view
|

Re: Core Erlang apply target expression behaviour

Robert Virding
I have been thinking about f# as well, but from a different direction. I would want to use as much as possible of the existing f# compiler which is written in f# so I would write an interpreter in Erlang for AST generated by f# parser which you could then use that to run all the early parts of the compiler, like type-checking and such. Then hopefully you could replace the backend with a new bit which generates core erlang and use the erlang compiler for the rest.

I fully realise it would not be as simple as it sounds :-) but I think it would be a doable of reusing as much as possible of what is written in f#. For me time is the limiting factor.

Robert


On 22 April 2017 at 21:52, Karl Nilsson <[hidden email]> wrote:
Thanks for the advice. A few things to think about there. 
I have been writing things in erlang, compiling and comparing but rather than writing a language from scratch I am working from the AST (or rather the TAST) from another language, fsharp. As fsharp is an ML and core erlang is ML-ish I was hoping to avoid having to do too much mangling but flattening out applies and mod calls with let expressions is easy enough so I'll definitely do that. 

Cheers
Karl

On Sat, 22 Apr 2017 at 20:19 Robert Virding <[hidden email]> wrote:
I would try doing 2 things:

- Write the equivalent Erlang code which does what you want the code to do, compile it with the to_core0 option and see what it generates. This then becomes your target code. This is how I did it with LFE.

- Or you can try flattening out your code to remove the nested calls. While Core erlang in principle should be able to manage nested code the Erlang compiler generally flattens things.

What I found when doing LFE was that while the language *in principle* allows a lot of things *in practice* later passes in the compiler, for example the optimisation passes, assume that the code looks like what the Erlang compiler compiler generates. One example of this is how literal structures are represented.

to_core0 returns the Core erlang which has been generated by the erlang->core conversion pass which is then what is passed on to optimisation and and code generation. This is what you should be targeting.

To check what the actual Core erlang data structures look like, not the pretty printed code, in the shell try doing:

> c("foo", [binary,to_core0,return]).

This call will *return* the actual data structure so you can put it in variable then pretty print it to a file so you can what you really need to get. Note that some of the attributes are important in later passes.

What language are you working on?

Robert


On 21 April 2017 at 19:12, Karl Nilsson <[hidden email]> wrote:
Whilst trying to compile some code to core erlang I came across a problem when the target expression (e0 in spec) to apply was another apply expression. According to the spec I thought that would be ok however when compiling the .core file with erlc I got an "no_file: Warning: invalid function call" error.

What I then tried, not thinking it would work, was to wrap the inner apply expression in a let expression. This to my surprise worked just fine. I've included the code below. 'addSix` is the working function and `addSix2` is the dodgy one. Am I doing something wrong in `addSix2` to in terms of how I print my AST or is it simply that `addSix2` cannot be made to work? I also tried putting some parens around it but that also didn't work.

'add'/2 =
    fun (_a0,_b0) ->
        call 'erlang':'+'(_a0,_b0)

'addFive'/0 =
    fun () ->
        let <_a0> = 5
        in fun (_b0) ->
    apply 'add'/2 (_a0,_b0)

'addSix'/1 =
    fun (_x0) ->
        call 'erlang':'+'(let <_fez0> = apply 'addFive'/0 ()
in apply _fez0 (_x0),1)

'addSix2'/1 =
    fun (_x0) ->
        call 'erlang':'+'(apply     apply 'addFive'/0 () (_x0),1)


Cheers
Karl

_______________________________________________
erlang-questions mailing list
[hidden email]
http://erlang.org/mailman/listinfo/erlang-questions




_______________________________________________
erlang-questions mailing list
[hidden email]
http://erlang.org/mailman/listinfo/erlang-questions
Reply | Threaded
Open this post in threaded view
|

Re: Core Erlang apply target expression behaviour

Karl Nilsson-2
That is pretty much the approach I am taking. I use the FSharp.Compiler.Service to do all the checking and get access to the typed AST, then I transform that to a core erlang AST which I then "pretty" (ugly) print to a core erlang file, all in fsharp.

On Sun, 23 Apr 2017 at 01:07 Robert Virding <[hidden email]> wrote:
I have been thinking about f# as well, but from a different direction. I would want to use as much as possible of the existing f# compiler which is written in f# so I would write an interpreter in Erlang for AST generated by f# parser which you could then use that to run all the early parts of the compiler, like type-checking and such. Then hopefully you could replace the backend with a new bit which generates core erlang and use the erlang compiler for the rest.

I fully realise it would not be as simple as it sounds :-) but I think it would be a doable of reusing as much as possible of what is written in f#. For me time is the limiting factor.

Robert


On 22 April 2017 at 21:52, Karl Nilsson <[hidden email]> wrote:
Thanks for the advice. A few things to think about there. 
I have been writing things in erlang, compiling and comparing but rather than writing a language from scratch I am working from the AST (or rather the TAST) from another language, fsharp. As fsharp is an ML and core erlang is ML-ish I was hoping to avoid having to do too much mangling but flattening out applies and mod calls with let expressions is easy enough so I'll definitely do that. 

Cheers
Karl

On Sat, 22 Apr 2017 at 20:19 Robert Virding <[hidden email]> wrote:
I would try doing 2 things:

- Write the equivalent Erlang code which does what you want the code to do, compile it with the to_core0 option and see what it generates. This then becomes your target code. This is how I did it with LFE.

- Or you can try flattening out your code to remove the nested calls. While Core erlang in principle should be able to manage nested code the Erlang compiler generally flattens things.

What I found when doing LFE was that while the language *in principle* allows a lot of things *in practice* later passes in the compiler, for example the optimisation passes, assume that the code looks like what the Erlang compiler compiler generates. One example of this is how literal structures are represented.

to_core0 returns the Core erlang which has been generated by the erlang->core conversion pass which is then what is passed on to optimisation and and code generation. This is what you should be targeting.

To check what the actual Core erlang data structures look like, not the pretty printed code, in the shell try doing:

> c("foo", [binary,to_core0,return]).

This call will *return* the actual data structure so you can put it in variable then pretty print it to a file so you can what you really need to get. Note that some of the attributes are important in later passes.

What language are you working on?

Robert


On 21 April 2017 at 19:12, Karl Nilsson <[hidden email]> wrote:
Whilst trying to compile some code to core erlang I came across a problem when the target expression (e0 in spec) to apply was another apply expression. According to the spec I thought that would be ok however when compiling the .core file with erlc I got an "no_file: Warning: invalid function call" error.

What I then tried, not thinking it would work, was to wrap the inner apply expression in a let expression. This to my surprise worked just fine. I've included the code below. 'addSix` is the working function and `addSix2` is the dodgy one. Am I doing something wrong in `addSix2` to in terms of how I print my AST or is it simply that `addSix2` cannot be made to work? I also tried putting some parens around it but that also didn't work.

'add'/2 =
    fun (_a0,_b0) ->
        call 'erlang':'+'(_a0,_b0)

'addFive'/0 =
    fun () ->
        let <_a0> = 5
        in fun (_b0) ->
    apply 'add'/2 (_a0,_b0)

'addSix'/1 =
    fun (_x0) ->
        call 'erlang':'+'(let <_fez0> = apply 'addFive'/0 ()
in apply _fez0 (_x0),1)

'addSix2'/1 =
    fun (_x0) ->
        call 'erlang':'+'(apply     apply 'addFive'/0 () (_x0),1)


Cheers
Karl

_______________________________________________
erlang-questions mailing list
[hidden email]
http://erlang.org/mailman/listinfo/erlang-questions




_______________________________________________
erlang-questions mailing list
[hidden email]
http://erlang.org/mailman/listinfo/erlang-questions