What Does the '&' Mean in the Following Ruby Syntax

What does the `&` mean in the following ruby syntax?

&:price is shorthand for "use the #price method on every member of the collection".

Unary "&", when passed as an argument into a method tells Ruby "take this and turn it into a Proc". The #to_proc method on a symbol will #send that symbol to the receiving object, which invokes the corresponding method by that name.

what is the functionality of &: operator in ruby?

There isn't a &: operator in Ruby. What you are seeing is the & operator applied to a :symbol.

In a method argument list, the & operator takes its operand, converts it to a Proc object if it isn't already (by calling to_proc on it) and passes it to the method as if a block had been used.

my_proc = Proc.new { puts "foo" }

my_method_call(&my_proc) # is identical to:
my_method_call { puts "foo" }

So the question now becomes "What does Symbol#to_proc do?", and that's easy to see in the Rails documentation:

Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:

# The same as people.collect { |p| p.name }
people.collect(&:name)

# The same as people.select { |p| p.manager? }.collect { |p| p.salary }
people.select(&:manager?).collect(&:salary)

What does &. (ampersand dot) mean in Ruby?

It is called the Safe Navigation Operator. Introduced in Ruby 2.3.0, it lets you call methods on objects without worrying that the object may be nil(Avoiding an undefined method for nil:NilClass error), similar to the try method in Rails.

So you can write

@person&.spouse&.name

instead of

@person.spouse.name if @person && @person.spouse

From the Docs:

my_object.my_method
This sends the my_method message to my_object. Any
object can be a receiver but depending on the method's visibility
sending a message may raise a NoMethodError.
You may use &. to designate a receiver, then my_method is not invoked
and the result is nil when the receiver is nil. In that case, the
arguments of my_method are not evaluated.

What does map(&:name) mean in Ruby?

It's shorthand for tags.map(&:name.to_proc).join(' ')

If foo is an object with a to_proc method, then you can pass it to a method as &foo, which will call foo.to_proc and use that as the method's block.

The Symbol#to_proc method was originally added by ActiveSupport but has been integrated into Ruby 1.8.7. This is its implementation:

class Symbol
  def to_proc
    Proc.new do |obj, *args|
      obj.send self, *args
    end
  end
end

What does ||= (or-equals) mean in Ruby?

This question has been discussed so often on the Ruby mailing-lists and Ruby blogs that there are now even threads on the Ruby mailing-list whose only purpose is to collect links to all the other threads on the Ruby mailing-list that discuss this issue.

Here's one: The definitive list of ||= (OR Equal) threads and pages

If you really want to know what is going on, take a look at Section 11.4.2.3 "Abbreviated assignments" of the Ruby Language Draft Specification.

As a first approximation,

a ||= b

is equivalent to

a || a = b

and not equivalent to

a = a || b

However, that is only a first approximation, especially if a is undefined. The semantics also differ depending on whether it is a simple variable assignment, a method assignment or an indexing assignment:

a    ||= b
a.c  ||= b
a[c] ||= b

are all treated differently.

What does this symbol mean in JavaScript?

See the documentation on MDN about expressions and operators and statements.

Basic keywords and general expressions

`this` keyword:

How does the "this" keyword work?

`var x = function()` vs. `function x()` — Function declaration syntax

var functionName = function() {} vs function functionName() {}

`(function(){`…`})()` — IIFE (Immediately Invoked Function Expression)

What is the purpose?, How is it called?
Why does (function(){…})(); work but function(){…}(); doesn't?
(function(){…})(); vs (function(){…}());
shorter alternatives:
- !function(){…}(); - What does the exclamation mark do before the function?
- +function(){…}(); - JavaScript plus sign in front of function expression
- !function(){ }() vs (function(){ })(), ! vs leading semicolon
(function(window, undefined){…}(window));

`someFunction()()` — Functions which return other functions

Two sets of parentheses after function call

`=>` — Equal sign, greater than: arrow function expression syntax

What's the meaning of "=>" (an arrow formed from equals & greater than) in JavaScript?

`|>` — Pipe, greater than: Pipeline operator

What does the "|>" operator do in JavaScript?

`function`, `yield`, `yield` — Star after `function` or `yield`: generator functions

What is "function*" in JavaScript?
What's the yield keyword in JavaScript?
Delegated yield (yield star, yield *) in generator functions

`[]`, `Array()` — Square brackets: array notation

What’s the difference between "Array()" and "[]" while declaring a JavaScript array?
What is array literal notation in javascript and when should you use it?

If the square brackets appear on the left side of an assignment ([a] = ...), or inside a function's parameters, it's a destructuring assignment.

`{key: value}` — Curly brackets: object literal syntax (not to be confused with blocks)

What do curly braces in JavaScript mean?
Javascript object literal: what exactly is {a, b, c}?
What do square brackets around a property name in an object literal mean?
How does this object method definition work without the "function" keyword? (ES2015 Method definitions)

If the curly brackets appear on the left side of an assignment ({ a } = ...) or inside a function's parameters, it's a destructuring assignment.

`…`${`…`}`…` — Backticks, dollar sign with curly brackets: template literals

What does this `…${…}…` code from the node docs mean?
Usage of the backtick character (`) in JavaScript?
What is the purpose of template literals (backticks) following a function in ES6?

`/`…`/` — Slashes: regular expression literals

Meaning of javascript text between two slashes

`$` — Dollar sign in regex replace patterns: `$$`, `$&`, $`, `$'`, `$n`

JavaScript replace() method dollar signs

`()` — Parentheses: grouping operator

MDN: Grouping operator

Property-related expressions

`obj.prop`, `obj[prop]`, `obj["prop"]` — Square brackets or dot: property accessors

JavaScript property access: dot notation vs. brackets?

`?.`, `?.[]`, `?.()` — Question mark, dot: optional chaining operator

Question mark after parameter
Null-safe property access (and conditional assignment) in ES6/2015
Optional Chaining in JavaScript
Is there a null-coalescing (Elvis) operator or safe navigation operator in javascript?
Is there a "null coalescing" operator in JavaScript?

`::` — Double colon: bind operator

JavaScript double colon (bind operator)

`new` operator

What is the 'new' keyword in JavaScript?
What is "new.target"?

`...iter` — Three dots: spread syntax; rest parameters

(...rest) => {} — What is the meaning of “…args” (three dots) in a function definition?
fn(...args) — What is the meaning of “foo(…arg)” (three dots in a function call)?
[...iter] — javascript es6 array feature […data, 0] “spread operator”
{...props} — Javascript Property with three dots (…), What does the '…rest' stand for in this object destructuring?

Increment and decrement

`++`, `--` — Double plus or minus: pre- / post-increment / -decrement operators

++someVariable vs someVariable++ in Javascript

Unary and binary (arithmetic, logical, bitwise) operators

`delete` operator

What is the purpose of the delete operator in Javascript?

`void` operator

What does `void 0` mean?

`+`, `-` — Plus and minus: addition or concatenation, and subtraction operators; unary sign operators

What does = +_ mean in JavaScript, Single plus operator in javascript
What's the significant use of unary plus and minus operators?
Why is [1,2] + [3,4] = "1,23,4" in JavaScript?
Why does JavaScript handle the plus and minus operators between strings and numbers differently?

`|`, `&`, `^`, `~` — Single pipe, ampersand, circumflex, tilde: bitwise OR, AND, XOR, & NOT operators

What do these JavaScript bitwise operators do?
How to: The ~ operator?
Is there a & logical operator in Javascript
What does the "|" (single pipe) do in JavaScript?
What does the operator |= do in JavaScript?
What does the ^ (caret) symbol do in JavaScript?
Using bitwise OR 0 to floor a number, How does x|0 floor the number in JavaScript?
Why does ~1 equal -2?
What does ~~ ("double tilde") do in Javascript?
How does !!~ (not not tilde/bang bang tilde) alter the result of a 'contains/included' Array method call? (also here and here)

`%` — Percent sign: remainder operator

What does % do in JavaScript?

`&&`, `||`, `!` — Double ampersand, double pipe, exclamation point: logical operators

Logical operators in JavaScript — how do you use them?
Logical operator || in javascript, 0 stands for Boolean false?
What does "var FOO = FOO || {}" (assign a variable or an empty object to that variable) mean in Javascript?, JavaScript OR (||) variable assignment explanation, What does the construct x = x || y mean?
Javascript AND operator within assignment
What is "x && foo()"? (also here and here)
What is the !! (not not) operator in JavaScript?
What is an exclamation point in JavaScript?

`??` — Double question mark: nullish-coalescing operator

How is the nullish coalescing operator (??) different from the logical OR operator (||) in ECMAScript?
Is there a null-coalescing (Elvis) operator or safe navigation operator in javascript?
Is there a "null coalescing" operator in JavaScript?

`**` — Double star: power operator (exponentiation)

x ** 2 is equivalent to Math.pow(x, 2)
Is the double asterisk ** a valid JavaScript operator?
MDN documentation

Equality operators

`==`, `===` — Equal signs: equality operators

Which equals operator (== vs ===) should be used in JavaScript comparisons?
How does JS type coercion work?
In Javascript, <int-value> == "<int-value>" evaluates to true. Why is it so?
[] == ![] evaluates to true
Why does "undefined equals false" return false?
Why does !new Boolean(false) equals false in JavaScript?
Javascript 0 == '0'. Explain this example
Why false == "false" is false?

`!=`, `!==` — Exclamation point and equal signs: inequality operators

!= vs. !==
What is the difference between != and !== operators in JavaScript?

Bit shift operators

`<<`, `>>`, `>>>` — Two or three angle brackets: bit shift operators

What do these JavaScript bitwise operators do?
Double more-than symbol in JavaScript
What is the JavaScript >>> operator and how do you use it?

Conditional operator

…`?`…`:`… — Question mark and colon: conditional (ternary) operator

Question mark and colon in JavaScript
Operator precedence with Javascript Ternary operator
How do you use the ? : (conditional) operator in JavaScript?

Assignment operators

`=` — Equal sign: assignment operator

What is the difference between the `=` and `==` operators and what is `===`? (Single, double, and triple equals)

This symbol is also used for default parameters or default values in a destructuring assignment:

what does (state = {}) => state means
What does ({"key": "value"} = {}) syntax mean inside a JavaScript function

`%=` — Percent equals: remainder assignment

Having Confusion with Modulo operator

`+=` — Plus equals: addition assignment operator

How does += (plus equal) work?

`&&=`, `||=`, `??=` — Double ampersand, pipe, or question mark, followed by equal sign: logical assignments

What purpose do &&=, ||= and ??= serve?
Replace a value if null or undefined in JavaScript
Set a variable if undefined
Ruby’s ||= (or equals) in JavaScript?
Original proposal
Specification

`<<=`, `>>=`, `>>>=`, `&=`, `^=`, `|=` — Double less than, double greater than, triple greater than, ampersand, caret, or pipe followed by equal sign: bitwise assignments

What do these JavaScript bitwise operators do?

Destructuring

of function parameters: Where can I get info on the object parameter syntax for JavaScript functions?
of arrays: Multiple assignment in javascript? What does [a,b,c] = [1, 2, 3]; mean?
of objects/imports: Javascript object bracket notation ({ Navigation } =) on left side of assign

Comma operator

`,` — Comma operator (not to be confused with the comma used in variable declarations)

What does a comma do in JavaScript expressions?
Comma operator returns first value instead of second in argument list?
When is the comma operator useful?

Control flow

`{`…`}` — Curly brackets: blocks (not to be confused with object literal syntax)

JavaScript curly braces with no function or json

Declarations

`var`, `let`, `const` — Declaring variables

What's the difference between using "let" and "var"?
Are there constants in JavaScript?
What is the temporal dead zone?
var a, b; — Comma used in variable declarations (not to be confused with the comma operator): JavaScript variable definition: Commas vs. Semicolons

Label

`label:` — Colon: labels

What does the JavaScript syntax foo: mean?
What does ':' (colon) do in JavaScript?

Other

`123n` — `n` after integer: BigInt

What does character 'n' after numeric literal mean in JavaScript?

`#` — Hash (number sign): Private methods or private fields

What does the # symbol do in JavaScript?

`_` — Underscore: separator in numeric literals

Javascript numeric separators?
Is there a Javascript equivalent to the Ruby syntax using underscores (e.g. 10_000 = 10000) to make larger integers human readable?

what does this syntax mean in Ruby? .. tasks.all?(&:complete?)

& is for passing block to method as a block (also used the other way in parameter list to make implicit block a parameter), it implicitly calls to_proc on passed object.

Symbol#to_proc for :symbol makes a proc{|param| param.symbol }

So your code is equvalent to tasks.all?{|task| task.complete? }

What does :: mean in Ruby syntax?

Ruby :: (double semi colons)

Top level constants are referenced by double colons

class TwelveDaysSong
end

a = TwelveDaysSong.new
#I could wrote it like this too
a = ::TwelveDaysSong.new 

module Twelve
  class TwelveDaysSongs
  end
end

b = Twelve::TwelveDaysSong.new
#b is not equal to 
a = ::TwelveDaysSong.new
#neither
a = TwelveDaysSong.new

Classes are constant too so if you have a constant

HELLOWOLRD = 'hw'

you could call it like this ::HELLOWORLD

What do the &, , * mean in this database.yml file?

The & marks an alias for the node (in your example &default aliases the development node as "default") and the * references the aliased node with the name "default". The <<: inserts the content of that node.

Allow me to quote the YAML spec here:

Repeated nodes (objects) are first identified by an anchor (marked with the ampersand - “&”), and are then aliased (referenced with an asterisk - “*”) thereafter.

So parts of your example

development: &default
  adapter: postgresql
  database: dev_development

test: &test
  <<: *default
  database: test_test

actually expand to

development: &default
  adapter: postgresql
  database: dev_development

test: &test
  adapter: postgresql       # from the "default" alias
  database: test_test       # overridden by the duplicate key

and at the same time make the "test" node as well available under the alias "test".

Have a look at the YAML specification - 2.2 Structures for further details (or if you need even moar docs++: 3.2.2.2. Anchors and Aliases)

what does &: mean in ruby, is it a block mixed with a symbol?

When & used before Proc object in method invocation, it treats the Proc as if it was an ordinary block following the invocation.

When & used before other type of object (symbol :first_name in your case) in method invocation, it tries to call to_proc on this object and if it does not have to_proc method you will get TypeError.

Generally &:first_name is the same as &:first_name.to_proc.

Symbol#to_proc Returns a Proc object which respond to the given method by sym.

:first_name.to_proc will return Proc that looks like this:

proc { |obj, *args, &block| obj.first_name(*args, &block) }

this Proc invokes method specified by original symbol on the object passes as the first parameter and pass all the rest parameters + block as this method arguments.

One more example:

> p = :each.to_proc
=> #<Proc:0x00000001bc28b0>
> p.call([1,2,3]) { |item| puts item+1 }
2
3
4
=> [1, 2, 3]