Just like pattern matching, where `@`

allows to name part of a matched expression, I propose to use `@`

for naming part of an expression instead of having to write a separate line for it.

Example:

```
trait Connectable[T] {
def apply(t : T) : Graph
}
implicit val graphConnectable : Connectable[Graph] = g => g
implicit val nodeConnectable : Connectable[Node] = n => Graph(n)
final case class Node(value : Int) {
def ==> [T](t : T)(implicit c : Connectable[T]) : Graph = Graph(this) ==> c(t)
}
final case class Graph(edges : Map[Node, Node], firstNode : Option[Node], lastNode : Option[Node]) {
def ==> [T](t : T)(implicit c : Connectable[T]) : Graph = {
val g = c(t)
val connectingEdge = (lastNode, g.firstNode) match {
case (Some(l), Some(r)) => Some(l -> r)
case _ => None
}
Graph(edges ++ g.edges ++ connectingEdge, firstNode, g.lastNode)
}
def WITH (g : Graph) : Graph = Graph(edges ++ g.edges, firstNode, g.lastNode)
}
object Graph {
def apply(node : Node) : Graph = Graph(Map(), Some(node), Some(node))
}
```

```
val myGraph =
g1To3 @ (n1 @ Node(1) ==> n2 @ Node(2) ==> n3 @ Node(3)) WITH
n2 ==> n1 WITH
g4To6 @ (n4 @ Node(4) ==> n5 @ Node(5) ==> n6 @ Node(6)) WITH
n6 ==> n4 WITH
n5 ==> n1
val graph1To6 = g1To3 ==> g4To6
```

Another example can be seen in the def `==>`

where could have written:

```
def ==> [T](t : T)(implicit c : Connectable[T]) : Graph = {
val connectingEdge = (lastNode, (g @ c(t)).firstNode) match {
case (Some(l), Some(r)) => Some(l -> r)
case _ => None
}
Graph(edges ++ g.edges ++ connectingEdge, firstNode, g.lastNode)
}
```