Polymorphic Functions

[umuro]

Polymorphic functions defined by Users

Well, eventually they will be... However, they are at the lowest bottom of the things to do...

In the mean time, I have some notes so that anybody who works on imports does not make them impossible in the future...

The ReducerProject has a private function "linkDependencies". That's where all the linking happens. As long as all the linking for any type of import/include invented happens there we can easily fit the upcoming changes to the language to whatever importing means introduced. This encapsulation exists because

• The assumption that bindings are enough to continue the execution is wrong. It won't be the case for strong typing as well as the polymorphic functions. So there will be more runtime info outside bindings to be used for linking.
• If it is in one place then it will be easier to amend linking for the new runtime-data that does not exist in bindings.
• If we don't go this way then the new language features will always be broken by various importing files ideas.

However, as long as, linking is happening inside "linkDependencies", it will be easy to amend it for new language features.

Linking is something. Just using the bindings applies only for the short term.

Anyway, this is one of the reasons why I moved into ReducerProject.

Anybody can try a better way to import, as long as respecting "linkDependencies"

---

An example for the need for explicit linking. @Slava Matyuhin @Ozzie Gooen

Currently users can define only normal functions. The language will evolve in 2 steps in the future

• Level 1. Users can specify polymorphic functions
• Level 2. Users can specify classes

Level 1 is the preceding infrastructure for Level 2

Let's see Level 0 - current situation:

//fileA
concat(aString, anOtherString) = ...

//fileB
concat(anArray, anOtherArray) = ...

//fileC (Level 0)
import concat from fileA
import concat from fileB
concat("hello", "world")  //does not work 
//This is overriden by an array concat

However at Level 1

//fileC (Level 1)
import concat from fileA
import concat from fileB
concat("hello", "world")  //works
concat([1], [2]) //works

As you see linking is not simply merging bindings as records at all!

That's why i am mentioning linkDependencies method and why it will have to be rewritteng for Level 1 and Level 2.

Linking files is part of the language semantics. Linking cannot go independent of the language semantics implementation. Any idea and syntax can be invented/examined for importing. However, the implementation has to be contained in ReducerProject.

Currently the implementation of Level 1 is underway