Comments on: Recless: A Type Inferring Parse Transform for Erlang (Experimental)

By: Yariv

Yariv — Tue, 27 Feb 2007 17:40:17 +0000

Mike, I like this idea. Unfortunately, I don’t have any time to spend on Recless right now… :(

By: Mike

Mike — Tue, 27 Feb 2007 07:55:28 +0000

Hi Yariv,

What do you think about support for

Project.owner.city

as a short for Project.owner.address.city

when the city is unique (not a part of the owner in this case)?

I beleive this became part of some modern languages.

Thanks,
Mike.

By: Tobbe

Tobbe — Wed, 13 Dec 2006 08:24:00 +0000

Looks promising i think. However, I tried the following, but got an error when compiling: -module(test). -compile({parse_transform, recless}). -export([new/0,upd_street/2]). -record(adr, { name = "Bill Smith", street = "Main street 23", phone }). new() -> #adr{}. upd_street(A = #adr{}, Street) -> A.street = Street. Also, it would be nice to be able to write: upd_street(A, Street) when record(A, adr) -> ....

By: Yariv

Yariv — Fri, 13 Oct 2006 02:39:24 +0000

Yes, Recless lets you do that, with the condition that the ‘project’ record has the other records in its default initializers.

You should also be able to explicity state the nested record types of the root record by writing something such as

get_name(Project = #project{owner = #person{}}) -> Project.owner.name.

This is helpful when the record ‘project’ doesn’t initialize the ‘owner’ field by default.

By: bengt kleberg

bengt kleberg — Fri, 13 Oct 2006 02:11:14 +0000

you have an example where
get_name(Person = #person{}) -> Person.name.
does this imply that i can write:
city( Project = #project{} ) -> Project.owner.address.city.
???
if so, then it is a great help.

however, if i only have access to the top level of the record, then i think you might not have added much to the existing:
name(#person{name=Name) -> Name.

By: Yariv

Yariv — Thu, 12 Oct 2006 21:24:53 +0000

Thanks for the feedback. I can add some logic to recless to remove all runtime checks in guards that don’t help disambiguate which clause matches a pattern. For example, if you have a function such as

foo(A = #bar{}, true) -> boing; foo(A = #bar{}, false) -> blub.

recless can figure out that the pattern A = #bar{} is purely a type indicator and can therefore remove it from the resulting tree.

Regarding the last problem you mentioned, I don’t think off the top of my head this will actually happen, but I will look into it.

Thanks!

By: Bengt

Bengt — Thu, 12 Oct 2006 12:10:55 +0000

greetings,

thank you for something that will make records much easier to handle.

some nitpicking (sorry but you know â€œthose who can not, critiqueâ€ :-)

accessing a record can be done in 4 ways, not three. you have forgotten the best way:

address{street=Street} = Address,

the two direct tuple accesses are way to unmaintainable to be considered in a realistic setting.

the record syntax you use is maintainable, but doing it like in the above example will include a runtime check that Address is a #address{}. the way you showed does not check. ie, the following code will work (but probably not as intended): Project = #project{name=â€Project1â€}, Street = Project#adress.street, â€œProject1â€ = Street.