Or at least MLixir (though ExML is genius).
mischov
OvermindDL1
I cannot help but read that as “Em Licks Her”… >.>
Lol, but the name can still easily be changed if this thing is worth releasing someday. ^.^
1
OvermindDL1
Got type application in, it can type down to any type’s type, I should probably get more types in… ^.^
defmlmodule MLModuleTest_Specific do
type t = MLModuleTest.type_definition
type Specific = MLModuleTest_Generalized.(t: float)
type st = Specific.t
type a(t) = t
type b(c) = c
type ra = a(integer)
type rb = b(integer)
def testering0 | t = 42
def testering1 | st = 6.28
def testering2 | ra = 42
def testering3 | rb = 42
def testering4 | a(integer) = 42
def testering5 | a(float) = 6.28
end
I was going back and forth on syntax, between these options:
type a(t) = t
type a.(t) = t
type a[t] = t
type a t = t
I was really torn between the last one, the second to last, and the first, but due to limitations in Elixir’s syntax the last version could potentially cause issues when I want to start refining the arguments to a limited set and the other versions have no such limitation. Between the first and third, the third seemed nice from a type perspective, but it means I cannot use it for some other type purposes later that I am wanting. So that left me with the a(b, c) format for the fewest issues in the Elixir syntax, so I went with it. 
1
OvermindDL1
Got first version of a variant/union/enum/adt/etc… type in now too, it is planned to be expanded substantially:
defmlmodule MLModuleTest_Specific do
type t = MLModuleTest.type_definition
type Specific = MLModuleTest_Generalized.(t: float)
type st = Specific.t
type a(t) = t
type b(c) = c
type ra = a(integer)
type rb = b(integer)
type testering_enum
| none
| one
| integer integer
| two
| float float
| float2 float
def testering0 | t = 42
def testering1 | st = 6.28
def testering2 | ra = 42
def testering3 | rb = 42
def testering4 | a(integer) = 42
def testering5 | a(float) = 6.28
def testering6 | testering_enum = none()
def testering7 | testering_enum = one
def testering8 | testering_enum = two
def testering9 | testering_enum = integer # Curried!
def testering10 | testering_enum = integer 42
def testering11(x) | testering_enum = integer x
end
Calling MLModuleTest_Specific.testering11(42) for example will return {:integer, 42} as right now value-less heads (like none) are encoded as the atom of their name (so :none) and multi-value ones (like integer integer) are encoded as a tuple of the same length as the args +1 where the first element is the atom of the name, kind of like erlang records. I have syntax ready to handle a few other various ones such as maps (they will act like elixir structs) and possible a keyword list but unsure if I want that one…
Oh, and I got guards generating now, so calling MLModuleTest_Specific.testering11(6.28) throws this error:
** (FunctionClauseError) no function clause matching in MLElixirTest.MLModuleTest_Specific.testering11/1
stacktrace:
test/ml_elixir_test.exs:69: MLElixirTest.MLModuleTest_Specific.testering11(6.28)
test/ml_elixir_test.exs:108: (test)
I’m planning to generate guards and matchers and other conditional checks to ensure the types match what the function is expecting, I might make an option to not generate those either but honestly I’m not wanting to lean that way that way I can know for sure guards are available for some better matchers later.
Oh, and also yes, auto-currying is started, I added it to the adt heads because I hate making manual wrappers for those, as you can see in testering9/1, if you call that function it returns another function, which you can then call as expected, thus calling MLModuleTest_Specific.testering9().(42) from elixir returns {:integer, 42}
I’m building this so functions are not auto-curried, so if you want to call a function then its arguments must be complete, that way you can control which erlang/elixir/whatever function is called by arity, but to compensate I’m having auto-currying happen at the call site (which is the erlang way anyway), as you can see with testering9/1, that will happen with all calls, partially applied arguments will be auto-wrapped in an anonymous function.
1
OvermindDL1
Got a few minutes available today so I got records in, usage:
type record0 = %{} # Empty record
type record1 = %{
x: integer,
y: float,
}
type record2(t) = %{t: t}
type record_ex_0 = %{_: record0, z: integer}
type record_ex_1 = %{_: record1, z: integer}
type record_ex_2(t) = %{_: record2(t), z: integer}
type record_ex_2_float = %{_: record2(float), z: integer}
def testering_record0 | record0 = %{}
def testering_record1 | record1 = %{x: 42, y: 6.28}
def testering_record2(i) | record1 = %{x: i, y: 6.28}
def testering_record3(t | !t) | record2(!t) = %{t: t}
def testering_record4 | record_ex_0 = %{z: 42}
def testering_record5 | record_ex_1 = %{x: 42, y: 6.28, z: 42}
def testering_record6 | record_ex_2(integer) = %{t: 42, z: 42}
def testering_record7(t | !t) | record_ex_2(!t) = %{t: t, z: 42}
def testering_record8 | record_ex_2_float = %{t: 6.28, z: 42}
And the tests pass:
assert MLModuleTest_Specific.testering_record0() === %{}
assert MLModuleTest_Specific.testering_record1() === %{x: 42, y: 6.28}
assert MLModuleTest_Specific.testering_record2(42) === %{x: 42, y: 6.28}
assert MLModuleTest_Specific.testering_record3(42) === %{t: 42}
assert MLModuleTest_Specific.testering_record4() === %{z: 42}
assert MLModuleTest_Specific.testering_record5() === %{x: 42, y: 6.28, z: 42}
assert MLModuleTest_Specific.testering_record6() === %{t: 42, z: 42}
assert MLModuleTest_Specific.testering_record7(42) === %{t: 42, z: 42}
assert MLModuleTest_Specific.testering_record8() === %{t: 6.28, z: 42}
And the usual typing failures fail as expected, and as you can see a record maps to an elixir map with atom() keys and any value (so kind of like elixir structs, except typed).
As you can see it supports static typing the fields as well as extended the types as well. I have row typing/polymorphism planned as well with a syntax that works.
2
OvermindDL1
I do have one question, I’m using the underscore atom as the extension syntax right now due to similarity with erlang records, but there is the option of using elixir’s map update syntax like %{record0 | z: integer} however I want to use that in expressions to update individual elements and so that adds a discrepency between type and expressions syntax that I do not like. I did have another idea in mind, which allows very fine grained control of both adding and removing record elements, however it would mean not allowing the plus and minus atoms either, but it would work like this in the full full version of it:
%{
+: record0,
+: record1,
-: x,
+: record2,
-: z
}
- At the
record0line it adds all record0’s records to this record, so its basically record0 at this point. - At the
record1line it adds all record1’s fields to this record, if any duplicates happen with record0 then it is a compile error, but should I make it not error if the fields are identically typed? I’m unsure yet, thoughts? - At the
xline it removed the current field with the name ofxfrom this record type, compile error if it does not exist. - At the
record2line it then adds all fields in record2 to this record, ditto as before. - At the
zline it removed the current field with the name ofzfrom this record type, compile error again if it does not exist.
It is more powerful, and the EVM/BEAM supports it fine, but should I do it?
0
OvermindDL1
Went ahead and made that change, can add/remove types now:
type record0 = %{} # Empty record
type record1 = %{
x: integer,
y: float,
}
type record2(t) = %{t: t}
type record_ex_0 = %{+: record0, z: integer}
type record_ex_1 = %{+: record1, z: integer}
type record_ex_2(t) = %{+: record2(t), z: integer}
type record_ex_2_float = %{+: record2(float), z: integer}
type record_rem_0 = %{+: record1, -: x}
And of course trying to do this:
def testering_record10 | record_rem_0 = %{x: 42, y: 6.28}
Gives you this:
{:NO_TYPE_RESOLUTION, :RECORD_LENGTH_DOES_NOT_MATCH, [:x, :y], [:y]}
And trying to do the wrong one:
def testering_record10 | record_rem_0 = %{x: 42}
Gives you:
{:NO_TYPE_RESOLUTION, :RECORD_LABEL_MISMATCH, :x, :EXPECTED, :y}
And the wrong type returns the usual type error of cannot cast, say, integer to float.
EDIT: And of course no duplicate keys allowed still, even from multiple records:
type record_ex_1 = %{+: record1, +: record1, z: integer}
Results in:
{:RECORD_DUPLICATE_LABELS, [:x, :y]}
0
OvermindDL1
Also added an FFI interface to type and call to arbitrary erlang/elixir calls, like here is integer addition:
external addi(integer, integer) | integer = Kernel.+
Calling it is as expected:
def testering_ffi_addi_0 = addi(1, 2)
def testering_ffi_addi_1(i) = addi(1, i)
def testering_ffi_addi_2(a, b) = addi(a, b)
In addition if you call it from non-typed (normal elixir) code, you can call the external directly, so just this from normal elixir:
assert MLModuleTest_Specific.addi(1, 2) === 3
And that works, and is properly typed, so if you try passing, say, 2.2 instead of 2 there will be no head match as normal, so you can have some of those guarantees as normal but for elixir too.
EDIT: I have alternative names for a lot of things too, so instead of external you can use defexternal, and instead of def you can use let, and for the def/let you can use = or you can use , do:, whichever all works whether you want it more ML’y or more Elixir’y.
2
OvermindDL1
Barely started it, but wanted to play for a second, however this:
js =
defmlmodule :testing_js, output_format: :js do
type t = MLModuleTest.type_definition
type Specific = MLModuleTest_Generalized.(t: float)
type st = Specific.t
type a(t) = t
type b(c) = c
type ra = a(integer)
type rb = b(integer)
type testering_enum
| none
| one
| integer integer
| two
| float float
| float2 float
def testering0 | t = 42
def testering1 | st = 6.28
def testering2 | ra = 42
def testering3 | rb = 42
def testering4 | a(integer) = 42
def testering5 | a(float) = 6.28
def testering6 | testering_enum = none() # Just testing that it works with 0-args too, elixir ast oddness reasons
def testering7 | testering_enum = one
def testering8 | testering_enum = two
def testering9 | testering_enum = integer # Curried!
def testering9x(x) | testering_enum = integer x # Not-Curried!
def testering10 | testering_enum = integer 42
def testering11(x) | testering_enum = integer x
end
Currently translates into this for the string in js:
// Module Name: testing_js
// Version: 0.0.1
function testering0() {
return 42;
}
function testering1() {
return 6.28;
}
function testering2() {
return 42;
}
function testering3() {
return 42;
}
function testering4() {
return 42;
}
function testering5() {
return 6.28;
}
function testering6() {
return 'none';
}
function testering7() {
return 'one';
}
function testering8() {
return 'two';
}
function testering9() {
return function(__ANON_ARG__){return['integer', __ANON_ARG__];};
}
function testering9x(x) {
return x;
}
function testering10() {
return 42;
}
function testering11(x) {
return x;
}
Which is just the start of the tests. It is nice to see alternate output though. ^.^
1
OvermindDL1
Finished up the javascript conversion, it works, unsure about the final output, but eh…
Given this:
test "MLElixir Javascript output" do
js =
defmlmodule :testing_js, output_format: :js do
type t = MLModuleTest.type_definition
type Specific = MLModuleTest_Generalized.(t: float)
type st = Specific.t
type a(t) = t
type b(c) = c
type ra = a(integer)
type rb = b(integer)
type testering_enum
| none
| one
| integer integer
| two
| float float
| float2 float
def testering0 | t = 42
def testering1 | st = 6.28
def testering2 | ra = 42
def testering3 | rb = 42
def testering4 | a(integer) = 42
def testering5 | a(float) = 6.28
def testering6 | testering_enum = none() # Just testing that it works with 0-args too, elixir ast oddness reasons
def testering7 | testering_enum = one
def testering8 | testering_enum = two
def testering9 | testering_enum = integer # Curried!
def testering9x(x) | testering_enum = integer x # Not-Curried!
def testering10 | testering_enum = integer 42
def testering11(x) | testering_enum = integer x
type record0 = %{}
type record1 = %{
x: integer,
y: float,
}
type record2(t) = %{t: t}
type record_ex_0 = %{+: record0, z: integer}
type record_ex_1 = %{+: record1, +: record0, z: integer}
type record_ex_2(t) = %{+: record2(t), z: integer}
type record_ex_2_float = %{+: record2(float), z: integer}
type record_rem_0 = %{+: record1, -: x}
def testering_record0 | record0 = %{}
def testering_record1 | record1 = %{x: 42, y: 6.28}
def testering_record2(i) | record1 = %{x: i, y: 6.28}
def testering_record3(t | !t) | record2(!t) = %{t: t}
def testering_record4 | record_ex_0 = %{z: 42}
def testering_record5 | record_ex_1 = %{x: 42, y: 6.28, z: 42}
def testering_record6 | record_ex_2(integer) = %{t: 42, z: 42}
def testering_record7(t | !t) | record_ex_2(!t) = %{t: t, z: 42}
def testering_record8 | record_ex_2_float = %{t: 6.28, z: 42}
def testering_record10 | record_rem_0 = %{y: 6.28}
# FFI
external addi(integer, integer) | integer = Kernel.add
def testering_ffi_addi_0 = addi(1, 2)
def testering_ffi_addi_1(i) = addi(1, i)
def testering_ffi_addi_2(a, b) = addi(a, b)
end
IO.puts(js)
end
Outputs this:
// Module Name: testing_js
// Version: 0.0.1
function testering0() {
return 42;
}
function testering1() {
return 6.28;
}
function testering2() {
return 42;
}
function testering3() {
return 42;
}
function testering4() {
return 42;
}
function testering5() {
return 6.28;
}
function testering6() {
return 'none';
}
function testering7() {
return 'one';
}
function testering8() {
return 'two';
}
function testering9() {
return function(__ANON_ARG__){return['integer', __ANON_ARG__];};
}
function testering9x(x) {
return x;
}
function testering10() {
return 42;
}
function testering11(x) {
return x;
}
function testering_record0() {
return {};
}
function testering_record1() {
return {"x": 42, "y": 6.28};
}
function testering_record2(i) {
return {"x": i, "y": 6.28};
}
function testering_record3(t) {
return {"t": t};
}
function testering_record4() {
return {"z": 42};
}
function testering_record5() {
return {"x": 42, "y": 6.28, "z": 42};
}
function testering_record6() {
return {"t": 42, "z": 42};
}
function testering_record7(t) {
return {"t": t, "z": 42};
}
function testering_record8() {
return {"t": 6.28, "z": 42};
}
function testering_record10() {
return {"y": 6.28};
}
function addi(add__var__0, add__var__1) {
return require("Kernel").add(add__var__0, add__var__1);
}
function testering_ffi_addi_0() {
return require("Kernel").add(1, 2);
}
function testering_ffi_addi_1(i) {
return require("Kernel").add(1, i);
}
function testering_ffi_addi_2(a, b) {
return require("Kernel").add(a, b);
}
1