+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| src | +
+
+ |
+ 76.92% | +10/13 | +100% | +2/2 | +57.14% | +4/7 | +75% | +9/12 | +
| src/partialPersistence | +
+
+ |
+ 29.05% | +43/148 | +18% | +9/50 | +18.91% | +7/37 | +29.45% | +43/146 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ ++ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 | + + + | import List, { isPartiallyPersistentList } from './partialPersistence/PartiallyPersistentList'
+
+export { List as default, isPartiallyPersistentList }
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 | + + + +4x +4x +4x +4x +4x + + + +3x + + + + + + + +12x + + + + + + + + + + + + + + + + + +4x + +3x + + + | import { v4 as uuidv4 } from 'uuid'
+
+class PersistentNode {
+ constructor(val) {
+ this.val = val
+ this.next = undefined
+ this.prev = undefined
+ this.length = val.length
+ this.id = uuidv4()
+ }
+
+ toString(isRoot) {
+ return this.next === undefined ? `[${this.val}]` : `[${this.val}] -> \n`
+ }
+
+ toJS() {
+ return this.val
+ }
+
+ equals(node) {
+ return this.id === node.id
+ }
+
+ // I think this is unreachable code because of the this.next declaration above
+ prev() {
+ return this.prev
+ }
+
+ inspect() {
+ return `PersistentNode(
+ id: ${this.id}
+ val: ${this.val}
+ prev: ${this.prev}
+ next: ${this.next}
+ )`
+ }
+}
+
+const persistentNode = (initialVal) => new PersistentNode(initialVal)
+
+module.exports = {
+ persistentNode,
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 | + + + +1x +1x +1x +1x +1x +1x +1x +1x + + + +1x + + + + +1x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +2x + + + + + + + + + + + +2x +2x +2x + +2x +1x +1x + +1x +1x + + +1x + + + +1x +1x + +1x + + +2x +1x + +2x +2x + +2x +2x + + + +1x + +1x + + +1x + +1x +1x +1x +1x + +1x +1x + + + + + + + + + + + + + + + + + + + +13x +13x +5x + +13x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +1x + | import { persistentNode } from '../nodes'
+
+class PartiallyPersistentList {
+ constructor(initialList) {
+ this.rootNode = persistentNode(initialList || [])
+ this._present = this.rootNode
+ this.mods = ['(root)']
+ this.index = 0
+ this.lastVal = this._lastNode().val
+ this.val = this._present.val
+ this._isPartiallyPersistentList = true
+ this.timetraveling = false
+ }
+
+ add(addVal) {
+ Iif (!this._present.equals(this._lastNode())) {
+ throw new Exception(
+ 'can only add a node to the end of a PartiallyPersistent list, please set "present" to the end of the list before adding',
+ )
+ }
+ return this._appendNode(addVal, `add(${addVal})`)
+ }
+
+ // hello it's not mutable, it's just appending another mod
+ remove(idx) {
+ if (this._lastNode().val.length === 0) {
+ throw 'Attempted to remove from empty list'
+ }
+
+ const lastVal = this._lastNode().val
+ lastVal.delete(idx) // <= FIGURE OUT THIS
+ this._lastNode().next = persistentNode(lastVal)
+ return this
+ }
+
+ // last node value's equality test
+ equals(otherList) {
+ let thisVal = this._lastNode().val
+ let otherVal = otherList._lastNode().val
+ return JSON.stringify(thisVal) === JSON.stringify(otherVal)
+ }
+
+ // temporal equality test, i.e. whether one list's timeline is equivalent to another's
+ tequals(otherList) {
+ let currNode = this.rootNode
+ let otherNode = otherList.rootNode
+
+ while (Boolean(currNode)) {
+ if (JSON.stringify(currNode.val) !== JSON.stringify(otherNode.val)) {
+ return false
+ }
+ currNode = currNode.next
+ otherNode = otherNode.next
+ }
+ if (currNode === otherNode) {
+ return true
+ }
+ return false
+ }
+
+ collect() {
+ let flattenedCollection = []
+ let node = this.rootNode
+ flattenedCollection.push(node.val)
+ while (node.next !== undefined) {
+ node = node.next
+ flattenedCollection.push(node.val)
+ }
+ return flattenedCollection
+ }
+
+ concat(value) {
+ if (!isPartiallyPersistentList(value) && !Array.isArray(value)) {
+ throw 'Only able to concat a PartiallyPersistentList to another PartiallyPersistentList or an Array'
+ }
+
+ // console.log('lastVal: ', this.lastVal)
+ this._appendNode(value, `concat(${value})`)
+ // console.log('lastVal: ', this.lastVal)
+ // console.log(this)
+ return this
+ }
+
+ // Temporal Methods involving the 'present' pointer within the list of nodes
+ get present() {
+ return this._present
+ }
+
+ set present(node) {
+ this._present = node
+ }
+
+ length() {
+ return this._present.length
+ }
+
+ prev() {
+ if (this._present.prev !== null) {
+ this._present = this._present.prev
+ } else {
+ throw new Exception(`Cannot access data prior to the dawn of time`)
+ }
+ this.timetraveling = true
+ return this
+ }
+
+ next() {
+ if (this._present.next !== null) {
+ this._present = this._present.next
+ } else {
+ throw new Exception('Cannot access data past the end of time')
+ }
+ this.timetraveling = true
+ return this
+ }
+
+ resetPresent() {
+ this.timetraveling = false
+ this.present = this._lastNode()
+ }
+
+ back(numPositions) {
+ if (numPositions < 0) {
+ throw 'back(numPositions) must be a positive number'
+ }
+ for (let i = 0; i < numPositions; i++) {}
+ }
+
+ forward(numPositions) {
+ if (numPositions < 0) {
+ throw 'forward(numPositions) must be a positive number'
+ }
+ for (let i = 0; i < numPositions; i++) {}
+ }
+
+ // Inspection Methods
+ toJS() {
+ return this._present.val
+ }
+ toString() {
+ return `Temporal.PartiallyPersistentList(
+ ${this._timeline()}
+ )`
+ }
+ inspect() {
+ return `Temporal.PartiallyPersistentList(
+ ${this._timeline()}
+ )`
+ }
+
+ // Private Methods
+ _timeline() {
+ let retString = ''
+ let currNode = this.rootNode
+ let i = 0
+
+ while (!currNode.equals(this._lastNode())) {
+ const isRoot = this.rootNode.equals(currNode)
+ const isPresent = currNode.equals(this._present)
+
+ Eif (isRoot) {
+ retString += ' '
+ }
+
+ Iif (isPresent) {
+ retString += '(present) '
+ }
+
+ retString += currNode.toString(isRoot)
+ retString += ` ${this.mods[i]} -> `
+
+ currNode = currNode.next
+ }
+
+ if (this._lastNode().equals(this.rootNode)) {
+ retString += ' '
+ }
+ Eif (this._lastNode().equals(this._present)) {
+ retString += '(present) '
+ }
+ retString += this._lastNode().toString()
+ return retString
+ }
+
+ _appendNode(newValue, modValue) {
+ const oldLastNode = this._lastNode()
+ let newNode
+ Iif (Array.isArray(newValue)) {
+ newNode = persistentNode(this._lastNode().val.concat(newValue))
+ } else {
+ newNode = persistentNode(this._lastNode().val.concat([newValue]))
+ }
+ newNode.prev = oldLastNode
+ oldLastNode.next = newNode
+ Eif (!this.timetraveling) {
+ this._present = newNode
+ }
+ this.mods.push(modValue)
+ return this
+ }
+
+ // itertor implementation
+ [Symbol.iterator]() {
+ return {
+ next: () => {
+ if (this.index < this.lastVal.length) {
+ return { value: this.lastVal[this.index++], done: false }
+ } else {
+ this.index = 0
+ return { done: true }
+ }
+ },
+ }
+ }
+
+ // fucking fix this, walking the entire linked list to find the last node is O(n)
+ // just keep a fucking pointer to the last node
+ _lastNode() {
+ let node = this.rootNode
+ while (node.next !== undefined) {
+ node = node.next
+ }
+ return node
+ }
+
+ // Nice to haves
+ head() {
+ if (!this._present.equals(this._lastNode())) {
+ throw new Exception(
+ 'please set "present" to the end of the list before calling head()',
+ )
+ }
+ const oldLastNode = this._lastNode()
+ const newNode = this._lastNode().val[0]
+ ? persistentNode([this._lastNode().val[0]])
+ : persistentNode([])
+ newNode.prev = oldLastNode
+ oldLastNode.next = newNode
+ this._present = newNode
+ this.mods.push(`head()`)
+ return this
+ }
+
+ tail() {
+ if (!this._present.equals(this._lastNode())) {
+ throw new Exception(
+ 'please set "present" to the end of the list before calling tail()',
+ )
+ }
+ const oldLastNode = this._lastNode()
+ const newNode =
+ this._lastNode().val.length > 1
+ ? persistentNode(this._lastNode().val.slice(1))
+ : persistentNode([])
+ newNode.prev = oldLastNode
+ oldLastNode.next = newNode
+ this._present = newNode
+ this.mods.push(`tail()`)
+ return this
+ }
+
+ // Sequence algorithms
+ map(f) {
+ const nextVal = this.lastVal.map(f)
+ this._appendNode(nextVal, `map(${f})`)
+ return this
+ }
+
+ // arr.filter(callback(element[, index, [array]])[, thisArg])
+ /**
+ *
+ * @param {callback} f
+ * @param {type} String | Optional ['timeline', 'mods'] defaults to 'collection'
+ */
+ filter(f, type) {
+ if (type === 'timeline') {
+ return this
+ } else if (type === 'mods') {
+ return this
+ } else {
+ const nextVal = this.lastVal.filter(f)
+ this._appendNode(nextVal, `filter(${f})`)
+ return this
+ }
+ }
+
+ reduce(f, init) {
+ return this.lastVal.reduce(f, init)
+ }
+
+ indexOf(x) {}
+
+ // stretch goals
+ slice() {}
+ shift() {}
+ unshift() {}
+ splice() {}
+ tInspect() {
+ let node = rootNode
+ let out = ''
+ while (node !== undefined) {
+ out += node.toString()
+ node = node.next
+ }
+ return out
+ }
+ tLength() {
+ let node = rootNode
+ length = 0
+ while (node.next !== undefined) {
+ node = node.next
+ length++
+ }
+ return length
+ }
+}
+
+// identity methods
+export function isPartiallyPersistentList(value) {
+ return value._isPartiallyPersistentList || false
+}
+
+export default (initialList) => new PartiallyPersistentList(initialList)
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| PartiallyPersistentList.js | +
+
+ |
+ 29.05% | +43/148 | +18% | +9/50 | +18.91% | +7/37 | +29.45% | +43/146 | +