github/semantic
1
1
Fork 0
mirror of https://github.com/github/semantic.git synced 2024-12-27 00:44:57 +03:00
Code Issues Projects Releases Wiki Activity

Rename down to into.

Browse Source
This commit is contained in:
Rob Rix 2015-11-05 12:05:28 -05:00
parent 47a1e8eb0c
commit 9151d02655
2 changed files with 15 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
prototype/Doubt/Location.swift
View File

@ -22,7 +22,7 @@ public struct Location<A>: SequenceType {
/// The node currently in focus. /// The node currently in focus.
public let it: A public let it: A
public var down: Location? { return _down(it) } public var into: Location? { return _down(it) }
public var up: Location? { return _up(it) } public var up: Location? { return _up(it) }
@ -38,7 +38,7 @@ public struct Location<A>: SequenceType {
/// Returns the logically next `Location` after the receiver in a pre-order depth-first traversal. /// Returns the logically next `Location` after the receiver in a pre-order depth-first traversal.
public var next: Location? { public var next: Location? {
return down ?? nextAfter return into ?? nextAfter
} }
/// Returns the logically next `Location` after the receiver and its children in a pre-order depth-first traversal. /// Returns the logically next `Location` after the receiver and its children in a pre-order depth-first traversal.

26
prototype/DoubtTests/LocationTests.swift
View File

@ -13,35 +13,35 @@ final class LocationTests: XCTestCase {
} }
func testCannotMoveDownwardsFromLeaves() { func testCannotMoveDownwardsFromLeaves() {
assert(leafA.explore().down?.it, ==, nil) assert(leafA.explore().into?.it, ==, nil)
} }
func testCanMoveDownwardsIntoBranches() { func testCanMoveDownwardsIntoBranches() {
assert(term.explore().down?.it, ==, leafA) assert(term.explore().into?.it, ==, leafA)
} }
func testCanMoveBackUpwards() { func testCanMoveBackUpwards() {
assert(term.explore().down?.up?.it, ==, term) assert(term.explore().into?.up?.it, ==, term)
} }
func testCannotMoveLeftwardsFromFirstChildOfBranch() { func testCannotMoveLeftwardsFromFirstChildOfBranch() {
assert(term.explore().down?.left?.it, ==, nil) assert(term.explore().into?.left?.it, ==, nil)
} }
func testCanMoveRightwardsFromLeftmostChildOfLongBranch() { func testCanMoveRightwardsFromLeftmostChildOfLongBranch() {
assert(term.explore().down?.right?.it, ==, leafB) assert(term.explore().into?.right?.it, ==, leafB)
} }
func testCanExploreBranchesDeeply() { func testCanExploreBranchesDeeply() {
assert(term.explore().down?.right?.right?.down?.it, ==, innerLeafB) assert(term.explore().into?.right?.right?.into?.it, ==, innerLeafB)
} }
func testCanMoveBackUpwardsFromDeepExplorations() { func testCanMoveBackUpwardsFromDeepExplorations() {
assert(term.explore().down?.right?.right?.down?.right?.up?.up?.it, ==, term) assert(term.explore().into?.right?.right?.into?.right?.up?.up?.it, ==, term)
} }
func testCanReturnToStartOfExplorationFromArbitrarilyDeepNodes() { func testCanReturnToStartOfExplorationFromArbitrarilyDeepNodes() {
assert(term.explore().down?.right?.right?.down?.right?.root.it, ==, term) assert(term.explore().into?.right?.right?.into?.right?.root.it, ==, term)
} }
func testSequenceIsPreOrderDepthFirstTraversal() { func testSequenceIsPreOrderDepthFirstTraversal() {
@ -49,23 +49,23 @@ final class LocationTests: XCTestCase {
} }
func testModifyReplacesSubtrees() { func testModifyReplacesSubtrees() {
assert(term.explore().down?.modify(const(leafB)).right?.up?.it, ==, Cofree(0, .Indexed([ leafB, leafB, keyed ]))) assert(term.explore().into?.modify(const(leafB)).right?.up?.it, ==, Cofree(0, .Indexed([ leafB, leafB, keyed ])))
} }
func testMultipleModificationsReplaceMultipleSubtrees() { func testMultipleModificationsReplaceMultipleSubtrees() {
assert(term.explore().down?.modify(const(leafB)).right?.modify(const(leafA)).up?.it, ==, Cofree(0, .Indexed([ leafB, leafA, keyed ]))) assert(term.explore().into?.modify(const(leafB)).right?.modify(const(leafA)).up?.it, ==, Cofree(0, .Indexed([ leafB, leafA, keyed ])))
} }
func testModificationsPreserveKeys() { func testModificationsPreserveKeys() {
assert(keyed.explore().down?.modify(const(leafA)).root.it, ==, Cofree(3, .Keyed([ "a": innerLeafA, "b": leafA ]))) assert(keyed.explore().into?.modify(const(leafA)).root.it, ==, Cofree(3, .Keyed([ "a": innerLeafA, "b": leafA ])))
} }
func testDeepModificationsReplaceDeepSubtrees() { func testDeepModificationsReplaceDeepSubtrees() {
assert(term.explore().down?.modify(const(leafB)).right?.modify(const(leafA)).right?.down?.modify(const(innerLeafA)).right?.modify(const(innerLeafB)).root.it, ==, Cofree(0, .Indexed([ leafB, leafA, Cofree(3, .Keyed([ "a": innerLeafB, "b": innerLeafA ])) ]))) assert(term.explore().into?.modify(const(leafB)).right?.modify(const(leafA)).right?.into?.modify(const(innerLeafA)).right?.modify(const(innerLeafB)).root.it, ==, Cofree(0, .Indexed([ leafB, leafA, Cofree(3, .Keyed([ "a": innerLeafB, "b": innerLeafA ])) ])))
} }
func testModificationsCanRefineDiffs() { func testModificationsCanRefineDiffs() {
assert(diff.explore().down?.right?.modify(const(refined)).root.it, ==, Free.Roll(0, .Indexed([ Free.Roll(1, .Leaf("a string")), refined ]))) assert(diff.explore().into?.right?.modify(const(refined)).root.it, ==, Free.Roll(0, .Indexed([ Free.Roll(1, .Leaf("a string")), refined ])))
} }
} }