in reply to Re^3: Effeciency of key-only hash
in thread Effecicncy of key-only hash

my %hash = map {($_=>1)} qw(shave the modern way);
Hurrah for this solution! One minor note: Since map evaluates the 'mapping block' in list context (as opposed to grep, incidentally), you can shave off two characters by omitting the parentheses.

UPDATE: Thanks to betterworld for pointing out that, if map didn't already evaluate its mapping block in list context, then the parentheses wouldn't help.

Replies are listed 'Best First'.
Re^5: Effeciency of key-only hash
by betterworld (Curate) on Aug 24, 2008 at 22:34 UTC
    you can shave off two characters by omitting the parentheses.

    If you want to omit characters, you can write

    my %hash = map $_=>1, qw(shave the modern way);

    Update: I'm sorry, I should have tested this code... thanks to lodin, see below.

    (Not to mention the whitespace... but often some more characters make the code more readable.)

    I find it quite natural that map uses list context and grep uses scalar context. grep's block evaluates to a boolean value (whether or not to include the element), which is a scalar. map's block evaluates to... well, a list. If this were not the case, the parentheses would not help.

    One remark about this "map" solution: Note that this works only once. If you use the hash-slice solution, you can add something to the set several times.

      If you want to omit characters, you can write
      my %hash = map $_=>1, qw(shave the modern way);

      Interestingly, you can't. If you want to remove the block you need to have

      map +($_ => 1), ...
      as => is a comma, so what you actually wrote is equivalent to these two statements below.
      my %hash = map $_, 1, qw(shave the modern way); my %hash = map { $_ } 1, qw(shave the modern way);

      (If you write map ($_ => 1), LIST the "function rule" kicks in and it becomes map($_ => 1), LIST i.e. (map $_, 1), LIST.)

      This means that you can write

      map f($_) => LIST
      which one could read declaratively as "map the function f onto the list I'm pointing at". Personally though I usually think of map as acting in the other direction, "shifting" of one element at a time from the list.

      lodin