ditto mark feature

[PavelVozenilek]

Ditto mark is typographic feature to ease reading of repeated words. Source code is full of them.

Example from zig compiler code:

FnTypeId fn_type_id;
fn_type_id.is_extern = fn_proto->is_extern || (fn_proto->visib_mod == VisibModExport);
fn_type_id.is_naked = is_naked;
fn_type_id.is_cold = is_cold;
fn_type_id.param_count = node->data.fn_proto.params.length;

How it could be made more readable:

FnTypeId fn_type_id;
fn_type_id.is_extern = fn_proto->is_extern || (fn_proto->visib_mod == VisibModExport);
  ---     .is_naked = is_naked;
  ---     .is_cold = is_cold;
  ---     .param_count = node->data.fn_proto.params.length;

One look at the structure of code reveals the repetition, one does not need to mentally parse the same word again and again.

Rules of thumb may be employed to avoid ambiguities. E.g. the effect of --- ends with empty line.

[andrewrk]

Interesting idea. I think it goes against the goal of keeping the language small and simple. I feel like this is solving something that is not really a problem.

[thejoshwolfe]

Also, consider this syntax:

const fn_type_id = FnTypeId{
    .is_extern = fn_proto.is_extern || (fn_proto.visib_mod == VisibModExport),
    .is_naked = is_naked,
    .is_cold = is_cold,
    .param_count = node.data.fn_proto.params.len,
};

I feel like this accomplishes your goal, and this syntax is already implemented in Zig. (Of course, this is just one specific application of the ditto mark that you're proposing.)

[PavelVozenilek]

This feature was invented by old scribes to solve a real problem. Sentences which start with the same word(s) tend to be nuisance to type (or typeset) and hard to read.

It gets worse for cryptic names so often used in code. Ditto would allow to break down scary blobs of letters and to spot repetition.

@thejoshwolfe: yes, better initialization does help. But it is yet another single purpose feature. Ditto is more versatile: it could be used e.g. when one re-assigns several fields in a structure, or when one invokes several functions with the same parameters.

Ditto can handle more than trivial initialization:

SomeType some_name;
some_name.field_x = 1;
   ---   .field_y = a + b;
   ---   .field_z = c / d + 1;

if (something) {
    ---  .field_u = 10;
    ---  .field_v = aaa;
}

@andrewrk

language small and simple

This is not explicitly stated priority of zig, as presented in the intro. Readability, however, is there.

Last but not least: there are many languages vying for attention. To succeed language should provide advantage over competing ones. Ditto is natural and easy to use tiny feature. It doesn't need pages of explanation and examples.

[andrewrk]

SomeType some_name;
some_name.field_x = 1;
   ---   .field_y = a + b;
   ---   .field_z = c / d + 1;

Better written with struct initialization.

if (something) {
    ---  .field_u = 10;
    ---  .field_v = aaa;
}

This is not readable at all.

I'm confident this will never be a feature of zig.