Segmented code for modular parts from different languages

[mavavilj]

I have been thinking about this idea for a while, and I noticed that it could complement Fut or be implementable based on Fut.

The idea is to be able to interleave code from multiple programming languages into "global programs". For example, consider if we wanted to write while we are writing a C program, then we could want to do e.g.:

int main(int argc, char *argv[]) {
    statements in C;
    #lang.Python
        statements in Python
    #/lang.Python
    statements in C;
    return 0;
}

or, for using nice idioms from other languages, we would want to do:

int main(int argc, char *argv[]) {
    statements in C;
    #loop.Python
        for x in somexs:
        #lang.C
            printf(x); // or something
        #/lang.C
    #/loop.Python
    statements in C;
    return 0;
}

Now these are just very naive and probably non-reasonable examples, but I wanted to give the ideas. So what if one wanted to write different languages in the same file (and not using FFI or the sorts) and use suitable idioms from other languages that are smarter than those of the host language. So that one may mix different abstractions in the same language.

I am, at this point, not exactly sure, how one would implement such, but based on Fut, my naive idea points to e.g. translating what's between # -statements to modules that can be compiled using the target language (e.g. #lang.C scopes can be compiled using gcc/clang). In short one-liners it might be possible to just statically infer what the corresponding host-language statement is and then do text replacement.

Further questions would be about type conversions needed to switch from another scope to another scope.

[mavavilj]

Another Fut-like feature would be that a similar syntax could allow one to drop to a "general language" as opposed to remembering the syntaxes of target languages. So one could want to write:

#class
HelloWorld {
#function[public,static]
    void main() {
        print('Hello world!');
    }
#/function
}
#/class

which is translateable to e.g. C++, Java or Python at least. The benefit here is that we don't care how classes or public and static functions, in this case, are declared in a target language, but we just use a general expression for what we mean.

[pfusik]

Mixing different programming languages within a single function is a crazy idea. What is the advantage of that? What is the expected result? (a standalone executable?)

Another Fut-like feature would be that a similar syntax could allow one to drop to a "general language" as opposed to remembering the syntaxes of target languages. So one could want to write:

#class
HelloWorld {
#function[public,static]
    void main() {
        print('Hello world!');
    }
#/function
}
#/class

which is translateable to e.g. C++, Java or Python at least. The benefit here is that we don't care how classes or public and static functions, in this case, are declared in a target language, but we just use a general expression for what we mean.

This is basically what Fut does now, but your syntax is more verbose.

[mavavilj]

Mixing different programming languages within a single function is a crazy idea. What is the advantage of that? What is the expected result? (a standalone executable?)

A single executable in the host language (in the example it would be C) or a collection of interconnected modules from different language targets (in the example we would have a C "host" program that calls a Python module generated from the global program. However, based on where Fut is, I speculated that the host language could be any language that Fut already supports. And naively the modification I am proposing only requires "modularizing" the other targets.

The advantages are similar to as when using FFIs or other languages, we can use a better or easier abstraction for something.

The benefit of having these in the same file is that we don't need to search through large text files in other languages to look for the particular thing that we are using, but rather we can see that particular thing right where it's used, mixed into the host language we are working with.

Another Fut-like feature would be that a similar syntax could allow one to drop to a "general language" as opposed to remembering the syntaxes of target languages. So one could want to write:

#class
HelloWorld {
#function[public,static]
    void main() {
        print('Hello world!');
    }
#/function
}
#/class

which is translateable to e.g. C++, Java or Python at least. The benefit here is that we don't care how classes or public and static functions, in this case, are declared in a target language, but we just use a general expression for what we mean.

This is basically what Fut does now, but your syntax is more verbose.

Not exactly, because using e.g. list notation [] we don't need to even care about the order of things, just that they're mentioned.

[pfusik]

My understanding is that you want FFI as a single-source file, much like what SYCL does compared to OpenCL. This is an interesting idea, but very loosely related to Fusion. Fut only accepts Fusion as input while C, Python etc. are its outputs. Someone suggested translating to Fusion, which would open possibility for more transpilations. You should not expect that we can translate any language into another one, as some statements cannot be directly translated, for instance pointer arithmetic in C.

There was also an earlier attempt to transpile C# to Fusion (then called Ć). Note that Fusion is designed specifically to be transpiled to mainstream imperative languages, not from them.

[mavavilj]

Well I thought the topic is similar to "piecewise" Fut, where we'd compiled separate lines (not full programs) to different target languages, but not all of them.

[mavavilj]

And like you said, since Fut already gives the kind of "global language", then I thought that one can use Fut for inferring what the C and Python blocks would be, based on a program in "global syntax".

[pfusik]

The problem you have is not translating statements, but passing data over language boundaries. All data is represented differently in C than in Python, not to mention other languages. Python is dynamic, garbage collected. C is statically-typed, with manual memory management. Passing something as simple as one object from Python to C would be troublesome and Fusion has no solution for that.

[mavavilj]

But for data we have existing FFI libraries, or we may, possibly, also use some sort of universal marshalling such as JSON Objects. In fact, we may use existing FFI libraries, but we might allow the code on the other side of the FFI to be placed (with slight modifications) to the calling code.

[mavavilj]

While it's now clear that this deviates from Fut's goals, I still think such could complement Fut's goals.