diff --git a/modules/ROOT/content-nav.adoc b/modules/ROOT/content-nav.adoc
index b1bf4a547..223b28d68 100644
--- a/modules/ROOT/content-nav.adoc
+++ b/modules/ROOT/content-nav.adoc
@@ -77,6 +77,7 @@
 ** xref:expressions/string-operators.adoc[]
 ** xref:expressions/temporal-operators.adoc[]
 ** xref:expressions/list-expressions.adoc[]
+** xref:expressions/map-expressions.adoc[]
 ** xref:expressions/conditional-expressions.adoc[]
 
 * xref:functions/index.adoc[]
diff --git a/modules/ROOT/pages/expressions/index.adoc b/modules/ROOT/pages/expressions/index.adoc
index f2b0fc0ec..5a05fe28f 100644
--- a/modules/ROOT/pages/expressions/index.adoc
+++ b/modules/ROOT/pages/expressions/index.adoc
@@ -15,5 +15,6 @@ For details and examples of specific expressions, see the following sections:
 * xref:expressions/string-operators.adoc[]: `+`, `||`
 * xref:expressions/temporal-operators.adoc[]: `+`, `-`, `*`, `/`
 * xref:expressions/list-expressions.adoc[]: information about list concatenation operators (`||`, `+`), list element access, list slicing, and list as well as pattern comprehensions.
+* xref:expressions/map-expressions.adoc[]: information about map operators (`.`, `[]`) and map projection.
 * xref:expressions/conditional-expressions.adoc[]
 
diff --git a/modules/ROOT/pages/expressions/map-expressions.adoc b/modules/ROOT/pages/expressions/map-expressions.adoc
new file mode 100644
index 000000000..c0953eee1
--- /dev/null
+++ b/modules/ROOT/pages/expressions/map-expressions.adoc
@@ -0,0 +1,446 @@
+= Map expressions
+:description: Information about Cypher's map expressions.
+:table-caption!:
+
+Map expressions allow you to manipulate and query xref:values-and-types/maps.adoc[`MAP`] values in Cypher.
+
+[NOTE]
+The xref:functions/list.adoc#functions-keys[`keys()`] function can be used to return a `LIST` of all the keys in a `MAP`.
+
+[[example-graph]]
+== Example graph
+
+The following graph is used for the examples below:
+
+image::values_and_types_maps_graph.svg[width="700",role="middle"]
+
+To recreate the graph, run the following query against an empty Neo4j database:
+
+[source, cypher, role=test-setup]
+----
+CREATE (keanu:Person {name: 'Keanu Reeves', nationality: 'Canadian'}),
+       (carrieAnne:Person {name: 'Carrie-Anne Moss'}),
+       (theMatrixRevolutions:Movie {title: 'The Matrix Revolutions', released: 2003}),
+       (theMatrixReloaded:Movie {title: 'The Matrix Reloaded', released: 2003}),
+       (theMatrix:Movie {title: 'The Matrix', released: 1999}),
+       (theDevilsAdvocate:Movie {title: 'The Devils Advocate', released: 1997}),
+       (theMatrixResurrections:Movie {title: 'The Matrix Resurrections', released: 2021}),
+      
+       (keanu)-[:ACTED_IN]->(theMatrix),
+       (keanu)-[:ACTED_IN]->(theMatrixRevolutions),
+       (keanu)-[:ACTED_IN]->(theMatrixReloaded),
+       (keanu)-[:ACTED_IN]->(theMatrixResurrections),
+       (keanu)-[:ACTED_IN]->(theDevilsAdvocate),
+
+       (carrieAnne)-[:ACTED_IN]->(theMatrix),
+       (carrieAnne)-[:ACTED_IN]->(theMatrixRevolutions),
+       (carrieAnne)-[:ACTED_IN]->(theMatrixReloaded),
+       (carrieAnne)-[:ACTED_IN]->(theMatrixResurrections)
+----
+
+[[map-operators]]
+== Map operators
+
+Cypher contains two map operators:
+
+* Statically access a value by key: dot operator (`.`).
+* Dynamically access a value by key: subscript operator (`[]`).
+
+[[static-map-access]]
+=== Statically access a `MAP` value
+
+`MAP` values can be accessed statically by specifying a key after the `.` operator.
+
+.Static `MAP` value access
+[source, cypher]
+----
+WITH {a: 10, b: 20, c: 30} AS map
+RETURN map.a AS firstValue,
+       map.c AS lastValue
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="2*<m"]
+|===
+| firstValue | lastValue
+
+| 10 | 30
+
+2+d|Rows: 1
+|===
+
+To statically access a value in a nested `MAP`, use chained `.` operators.
+Each `.` operator traverses one level deeper into the nested structure.
+
+.Static access of a nested `MAP` value
+[source, cypher]
+----
+WITH {a: 10, b: 20, c: 30, innerMap: {x: 100, y: 200, z: 300}} AS map
+RETURN map.a AS firstOuterValue,
+       map.innerMap.y AS secondInnerValue
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="2*<m"]
+|===
+| firstOuterValue | secondInnerValue
+
+| 10 | 200
+
+2+d|Rows: 1
+|===
+
+Node and relationship properties are stored as key-value pairs in a `MAP`.
+Properties can, therefore, be statically accessed using the `.` operator.
+
+.Statically access a node property
+[source, cypher]
+----
+MATCH (p:Person)
+RETURN p AS nodePropertyMaps,
+       p.name AS accessedMapValue
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="2*<m"]
+|===
+| nodePropertyMaps | accessedMapValue
+
+| (:Person {nationality: "Canadian", name: "Keanu Reeves"}) | "Keanu Reeves"
+| (:Person {name: "Carrie-Anne Moss"}) | "Carrie-Anne Moss"
+
+2+d|Rows: 2
+|===
+
+
+[[dynamic-map-access]]
+=== Dynamically access a `MAP` value
+
+To dynamically access a `MAP` value, use the subscript operator, `[]`.
+The key can be provided by a variable or a parameter.
+
+.Dynamically access a `MAP` value using a variable
+[source, cypher]
+----
+WITH {a: 10, b: 20, c: 30} AS map,
+     'a' AS dynamicKey
+RETURN map[dynamicKey] AS dynamicValue
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+| dynamicValue
+
+| 10
+
+1+d|Rows: 1
+|===
+
+.Parameters
+[source, parameters]
+----
+{
+  "dynamicKey" : 'a'
+}
+----
+
+.Dynamically access a `MAP` value using a parameter
+[source, cypher]
+----
+WITH {a: 10, b: 20, c: 30} AS map
+RETURN map[$dynamicKey] AS dynamicValue
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+| dynamicValue
+
+| 10
+
+1+d|Rows: 1
+|===
+
+.Dynamically access a nested `MAP` value
+[source, cypher]
+----
+WITH {a: 10, b: 20, c: 30, innerMap: {x: 100, y: 200, z: 300}} AS map,
+     'z' AS dynamicInnerKey
+RETURN map.innerMap[dynamicInnerKey] AS dynamicInnerValue
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+| dynamicInnerValue
+
+| 300
+
+1+d|Rows: 1
+|===
+
+It is possible to dynamically access multiple values from a `MAP` by using xref:expressions/list-expressions.adoc#list-comprehension[list comprehension].
+This query iterates over the `LIST` `dynamicKeys` and retrieves their corresponding values from the `map`.
+
+.Dynamic `MAP` value access and list comprehension
+[source, cypher]
+----
+WITH {a: 10, b: 20, c: 30} AS map,
+     ['a', 'c'] AS dynamicKeys
+RETURN [key IN dynamicKeys | map[key]] AS dynamicValue
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+| dynamicValue
+
+| [10, 30]
+
+1+d|Rows: 1
+|===
+
+.Dynamically access a node property value
+[source, cypher]
+----
+MATCH (p:Person)
+LET dynamicValue = 'name'
+RETURN p[dynamicValue] AS names
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+| names
+
+| "Keanu Reeves"
+| "Carrie-Anne Moss"
+
+1+d|Rows: 2
+|===
+
+Referencing a non-existent key in the `MAP` with the `[]` operator  will return `NULL`.
+
+.Dynamically referencing a non-existent `MAP` key
+[source, cypher]
+----
+WITH {a: 10, b: 20, c: 30} AS map,
+     'z' AS dynamicKey
+RETURN map[dynamicKey] AS dynamicValue
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+| dynamicValue
+
+| NULL
+
+1+d|Rows: 1
+|===
+
+[[map-projection]]
+== Map projection
+
+Cypher supports map projections, which allow the creation of `MAP` values from nodes, relationships, and other `MAP` values.
+
+A map projection begins with the variable bound to the `MAP` to be projected from, and contains a body of comma-separated `MAP` keys, enclosed by curly braces, `{}`.
+Each map element specifies a key-value pair that is included in the resulting map projection.
+
+.Syntax
+[source, syntax]
+----
+mapVariable {mapElement [, ...n]}
+----
+
+`mapElement` can be one of the following:
+
+* An *key selector* that references a key in a `MAP` and pulls the corresponding value.
+* A *literal entry* that uses a custom key-value pair where the key is specified and the value is defined using an expression.
+* A *variable selector* that projects the value of a variable, using the variable name as the key, and the value it references as the value.
+* An *all-map projection* that projects all key-value pairs from `mapVariable`.
+
+[NOTE]
+The key names in a map must be of type `STRING`. +
+If `mapVariable` is `NULL`, the projection evaluates to `NULL`.
+
+.Map projection with a key selector
+=====
+
+Map projections with a key selector are useful when you need to extract specific key-value pairs from a `MAP`.
+
+.Basic example
+[source, cypher]
+----
+WITH {a: 10, b: 20, c: 30} AS map
+RETURN map{.a, .c} AS projectedMap
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+| projectedMap
+
+| {a: 10, c: 30}
+
+1+d|Rows: 1
+|===
+
+In the below query, a map projection with property selectors is used to xref:functions/list.adoc#functions-collect[`collect`] only the `title` and `release` year of each movie. 
+
+.Map projection with a key selector
+[source, cypher]
+----
+MATCH (p:Person)-[:ACTED_IN]->(m:Movie)  
+RETURN p.name AS actor, collect(m{.title, .released}) AS movies  
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="2*<m"]
+|===
+| actor | movies
+
+| "Keanu Reeves" | [{title: "The Matrix Resurrections", released: 2021}, {title: "The Matrix Revolutions", released: 2003}, {title: "The Matrix Reloaded", released: 2003}, {title: "The Matrix", released: 1999}, {title: "The Devils Advocate", released: 1997}]
+| "Carrie-Anne Moss" | [{title: "The Matrix Resurrections", released: 2021}, {title: "The Matrix Revolutions", released: 2003}, {title: "The Matrix Reloaded", released: 2003}, {title: "The Matrix", released: 1999}]
+
+2+d|Rows: 2
+|===
+
+=====
+
+.Map projection with a literal entry
+=====
+
+Map projections with a literal entry are useful when you want to add custom values to a projected `MAP` value without modifying the original data structure.
+
+.Basic example
+[source, cypher]
+----
+WITH {a: 10, b: 20, c: 30} AS map
+RETURN map{a: map.a, valueSum: map.a + map.b + map.c} AS projectedMap
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+| projectedMap
+
+| {a: 10, valueSum: 60}
+
+1+d|Rows: 1
+|===
+
+This query uses a map projection with a literal entry, where the `size(movies)` expression calculates the total number of movies `Keanu Reeves` has acted in. 
+
+.Map projection with a literal entry
+[source, cypher]
+----
+MATCH (keanu:Person {name: 'Keanu Reeves'})-[:ACTED_IN]->(movie:Movie)
+WITH keanu, collect(movie) AS movies
+RETURN keanu {.name, totalMovies: size(movies)} AS keanuDetails
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+| keanuDetails
+
+| {name: "Keanu Reeves", totalMovies: 5}
+
+1+d|Rows: 1
+|===
+
+=====
+
+.Map projection with a variable selector
+=====
+
+Map projection with a variable selector is useful when you want to project values based on a variable name.
+
+.Basic example
+[source, cypher]
+----
+MATCH (keanu:Person {name: 'Keanu Reeves'})  
+LET dob = date('1964-09-02'), birthPlace =  'Beirut, Lebanon'
+RETURN keanu{.name, dob, birthplace} AS projectedKeanu
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+| projectedKeanu
+
+| {name: "Keanu Reeves", birthPlace: "Beirut, Lebanon", dob: 1964-09-02}
+
+1+d|Rows: 1
+|===
+
+The below query finds all `Person` nodes in the graph that have one or more relationships with the type `ACTED_IN` connected to `Movie` nodes. 
+It uses the xref::functions/aggregating.adoc#functions-count[count()] function to count how many `Movie` nodes are connected to each `Person` node in this way, and uses a variable selector to project the value of the count.
+
+.Map projection with a variable selector
+[source, cypher]
+----
+MATCH (actor:Person)-[:ACTED_IN]->(movie:Movie)
+WITH actor, count(movie) AS totalMovies
+RETURN actor{totalMovies, .name} AS nameAndMovies
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+| nameAndMovies
+
+| {name: "Keanu Reeves", totalMovies: 5}
+| {name: "Carrie-Anne Moss", totalMovies: 4}
+
+1+d|Rows: 2
+|===
+
+=====
+
+.Map projection with an all-map projection
+=====
+
+Map projection with an all-map projection is useful when you want to project all key-value pairs from a `MAP` without explicitly listing them. 
+
+.Basic example
+[source, cypher]
+----
+WITH {a: 10, b: 20, c: 30} AS map
+RETURN map{.*} AS projectedMap
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+| projectedMap
+
+| {a: 10, b: 20, c: 30}
+
+1+d|Rows: 1
+|===
+
+The below query returns all properties from the `Keanu Reeves` node.
+An all-map selector is used to project all the node properties.
+
+.Map projection with all-map selector
+[source, cypher]
+----
+MATCH (keanu:Person {name: 'Keanu Reeves'})
+RETURN keanu{.*} AS allKeanuProperties
+----
+
+.Result
+[role="queryresult",options="header,footer",cols="1*<m"]
+|===
+| AllKeanuProperties
+
+| {nationality: "Canadian", name: "Keanu Reeves"}
+
+1+d|Rows: 1
+|===
+
+
+=====
diff --git a/modules/ROOT/pages/syntax/operators.adoc b/modules/ROOT/pages/syntax/operators.adoc
index 3c4195f8e..a58738415 100644
--- a/modules/ROOT/pages/syntax/operators.adoc
+++ b/modules/ROOT/pages/syntax/operators.adoc
@@ -11,10 +11,8 @@ This page contains an overview of the available Cypher operators.
 |===
 | xref::syntax/operators.adoc#query-operators-aggregation[Aggregation operators] | `DISTINCT`
 | xref::syntax/operators.adoc#query-operators-property[Property operators] | `.` for static property access, `[]` for dynamic property access, `=` for replacing all properties, `+=` for mutating specific properties
-| xref::syntax/operators.adoc#query-operators-map[Map operators]       |  `.` for static value access by key, `[]` for dynamic value access by key
 |===
 
-
 [[query-operators-aggregation]]
 == Aggregation operators
 
@@ -185,68 +183,4 @@ The properties on the node are updated as follows by those provided in the map:
 See xref::clauses/set.adoc#set-setting-properties-using-map[Mutate specific properties using a map and `+=`] for more details on using the property mutation operator `+=`.
 
 
-[[query-operators-map]]
-== Map operators
-
-The map operators comprise:
-
-* statically access the value of a map by key using the dot operator: `.`
-* dynamically access the value of a map by key using the subscript operator: `[]`
-
-
-[NOTE]
-====
-The behavior of the `[]` operator with respect to `null` is detailed in the xref::values-and-types/working-with-null.adoc#cypher-null-bracket-operator[working with null] page.
-====
-
-
-[[syntax-accessing-the-value-of-a-nested-map]]
-=== Statically accessing the value of a nested map by key using the `.` operator
-
-.Query
-[source, cypher]
-----
-WITH {person: {name: 'Anne', age: 25}} AS p
-RETURN  p.person.name
-----
-
-.Result
-[role="queryresult",options="header,footer",cols="1*<m"]
-|===
-| +p.person.name+
-| +"Anne"+
-
-1+d|Rows: 1
-|===
-
-
-[[syntax-accessing-dynamic-map-parameter]]
-=== Dynamically accessing the value of a map by key using the `[]` operator and a parameter
-
-A parameter may be used to specify the key of the value to access:
-
-.Parameters
-[source, parameters]
-----
-{
-  "myKey" : "name"
-}
-----
-
-.Query
-[source, cypher]
-----
-WITH {name: 'Anne', age: 25} AS a
-RETURN a[$myKey] AS result
-----
-
-.Result
-[role="queryresult",options="header,footer",cols="1*<m"]
-|===
-| +result+
-| +"Anne"+
-
-1+d|Rows: 1
-|===
 
-More information can be found in the xref::values-and-types/maps.adoc[Maps chapter].
diff --git a/modules/ROOT/pages/values-and-types/lists.adoc b/modules/ROOT/pages/values-and-types/lists.adoc
index f57fc7a84..e24ad30db 100644
--- a/modules/ROOT/pages/values-and-types/lists.adoc
+++ b/modules/ROOT/pages/values-and-types/lists.adoc
@@ -5,7 +5,6 @@ include::https://raw.githubusercontent.com/neo4j-graphacademy/courses/main/ascii
 = Lists
 
 Cypher includes comprehensive support for lists.
-This section first describes lists in general, and then discusses how to use list comprehension and pattern comprehension in lists.
 
 [NOTE]
 For information about the list predicate operator `IN`, which checks for list membership, see xref:expressions/predicates/list-operators.adoc[Expressions -> Predicates -> List operators].
diff --git a/modules/ROOT/pages/values-and-types/maps.adoc b/modules/ROOT/pages/values-and-types/maps.adoc
index a3e005a04..9cd982c7d 100644
--- a/modules/ROOT/pages/values-and-types/maps.adoc
+++ b/modules/ROOT/pages/values-and-types/maps.adoc
@@ -4,12 +4,11 @@
 = Maps
 
 Cypher supports the construction of maps.
-This section first discusses literal maps and then moves on to map projection.
 
 [NOTE]
 ====
-Information regarding property access operators such as `.` and `[]` can be found xref::syntax/operators.adoc#query-operators-map[here].
-The behavior of the `[]` operator with respect to `null` is detailed xref::values-and-types/working-with-null.adoc#cypher-null-bracket-operator[here].
+For information about the property access operators `.` and `[]`, see xref:expressions/map-expressions#map-operators[Map expressions -> Map operators]. +
+For information about how the `[]` operator behaves with respect to `null`, see xref::values-and-types/working-with-null.adoc#cypher-null-bracket-operator[Working with `null` -> The `[\]` operator and `null`].
 ====
 
 
@@ -36,137 +35,3 @@ RETURN {key: 'Value', listKey: [{inner: 'Map1'}, {inner: 'Map2'}]} AS map
 |===
 
 
-[[cypher-map-projection]]
-== Map projection
-
-Cypher supports map projections, which allows for the construction of map projections from nodes, relationships, and other map values.
-
-A map projection begins with the variable bound to the graph entity to be projected from, and contains a body of comma-separated map elements, enclosed by `{` and  `}`.
-
-.Map projection 
-[source, syntax]
-----
-map_variable {map_element, [, ...n]}
-----
-
-A map element projects one or more key-value pairs to the map projection.
-There exist four different types of map projection elements:
-
-* Property selector - Projects the property name as the key, and the value from the `map_variable` as the value for the projection.
-* Literal entry - This is a key-value pair, with the value being an arbitrary expression `key: <expression>`.
-* Variable selector - Projects a variable, with the variable name as the key, and the value the variable is pointing to as the value of the projection. 
-Its syntax is just the variable.
-* All-properties selector - projects all key-value pairs from the `map_variable` value.
-
-The following conditions apply:
-
-* If the `map_variable` points to a `null` value, the whole map projection will evaluate to `null`.
-* The key names in a map must be of type `STRING`.
-
-
-[[cypher-map-projection-examples]]
-=== Example graph
-
-The following graph is used for the examples below:
-
-image::values_and_types_maps_graph.svg[]
-
-To recreate the graph, run the following query against an empty Neo4j database:
-
-[source, cypher, role=test-setup]
-----
-CREATE
-  (keanu:Person {name: 'Keanu Reeves', nationality: 'Canadian'}),
-  (carrieAnne:Person {name: 'Carrie-Anne Moss'}),
-  (theMatrixRevolutions:Movie {title: 'The Matrix Revolutions', released: 2003}),
-  (theMatrixReloaded:Movie {title: 'The Matrix Reloaded', released: 2003}),
-  (theMatrix:Movie {title: 'The Matrix', released: 1999}),
-  (theDevilsAdvocate:Movie {title: 'The Devils Advocate', released: 1997}),
-  (theMatrixResurrections:Movie {title: 'The Matrix Resurrections', released: 2021}),
-  (keanu)-[:ACTED_IN]->(theMatrix),
-  (keanu)-[:ACTED_IN]->(theMatrixRevolutions),
-  (keanu)-[:ACTED_IN]->(theMatrixReloaded),
-  (keanu)-[:ACTED_IN]->(theMatrixResurrections),
-  (keanu)-[:ACTED_IN]->(theDevilsAdvocate),
-  (carrieAnne)-[:ACTED_IN]->(theMatrix),
-  (carrieAnne)-[:ACTED_IN]->(theMatrixRevolutions),
-  (carrieAnne)-[:ACTED_IN]->(theMatrixReloaded),
-  (carrieAnne)-[:ACTED_IN]->(theMatrixResurrections)
-----
-
-=== Examples
-
-The below query finds the `Keanu Reeves` node and the movies he has acted in. 
-It is an example of a map projection with a literal entry, which in turn also uses map projection inside the aggregating xref:functions/aggregating.adoc#functions-collect[collect()] function.
-
-.Query
-[source, cypher, indent=0]
-----
-MATCH (keanu:Person {name: 'Keanu Reeves'})-[:ACTED_IN]->(movie:Movie)
-WITH keanu, collect(movie{.title, .released}) AS movies
-RETURN keanu{.name, movies: movies}
-----
-
-.Result
-[role="queryresult",options="header,footer",cols="1*<m"]
-|===
-| +keanu+
-| +{movies: [{title: "The Devils Advocate", released: 1997}, {title: "The Matrix Revolutions", released: 2003}, {title: "The Matrix Resurrections", released: 2021}, {title: "The Matrix Reloaded", released: 2003}, {title: "The Matrix", released: 1999}], name: "Keanu Reeves"}+
-1+d|Rows: 1
-|===
-
-The below query finds all `Person` nodes in the graph that have one or more relationships with the type `ACTED_IN` connected to `Movie` nodes. 
-It uses the xref::functions/aggregating.adoc#functions-count[count()] function to count how many `Movie` nodes are connected to each `Person` node in this way, and uses a variable selector to project the value of the count.
-
-.Query
-[source, cypher]
-----
-MATCH (actor:Person)-[:ACTED_IN]->(movie:Movie)
-WITH actor, count(movie) AS numberOfMovies
-RETURN actor{.name, numberOfMovies}
-----
-
-.Result
-[role="queryresult",options="header,footer",cols="1*<m"]
-|===
-| +actor+
-| +{numberOfMovies: 5, name: "Keanu Reeves"}+
-| +{numberOfMovies: 4, name: "Carrie-Anne Moss"}+
-1+d|Rows: 2
-|===
-
-The below query returns all properties from the `Keanu Reeves` node.
-An all-properties selector is used to project all the node properties, and additionally, explicitly project the property `age`.
-Since this property does not exist on the node `Keanu Reeves`, a `null` value is projected instead.
-
-.Query
-[source, cypher]
-----
-MATCH (keanu:Person {name: 'Keanu Reeves'})
-RETURN keanu{.*, .age}
-----
-
-.Result
-[role="queryresult",options="header,footer",cols="1*<m"]
-|===
-| +keanu+
-| +{nationality: "Canadian", name: "Keanu Reeves", age: null}+
-1+d|Rows: 1
-|===
-
-The below query is an example of statically accessing individual map members using the `.` operator:
-
-.Query
-[source, cypher]
-----
-WITH {age: 58, profession: 'Actor'} as keanuStats
-RETURN keanuStats.profession AS profession
-----
-
-.Result
-[role="queryresult",options="header,footer",cols="1*<m"]
-|===
-| +profession+
-| +"Actor"+
-1+d|Rows: 1
-|===