Stop giving "reverse" method overrides special treatment

Only one sequence was overriding "reverse" and I was running into problems trying to make sure it wasn't going to be a source of lots of unexpected bugs, so I removed the override and all the places that treated it specially
pineapplemachine · Aug 22, 2017 · f099844 · f099844
1 parent 4cebb46
commit f099844
Show file tree

Hide file tree

Showing 6 changed files with 7 additions and 178 deletions.
diff --git a/src/core/expecting.js b/src/core/expecting.js
@@ -534,22 +534,6 @@ export const expecting = {
             return sequence;
         },
     }),
-    reversibleSequence: Expecting({
-        type: "sequence",
-        article: "a",
-        singular: "reversible sequence",
-        plural: "reversible sequences",
-        adjective: "reversible",
-        short: "sequence",
-        sequence: true,
-        transforms: true,
-        validate: value => {
-            const sequence = asSequence(value);
-            if(!sequence) throw new Error();
-            if(!sequence.back && !sequence.overrides.reverse) throw new Error();
-            return sequence;
-        },
-    }),
     exactly: option => Expecting({
         article: "exactly",
         singular: String(option),

diff --git a/src/functions/flatten.js b/src/functions/flatten.js
@@ -2,41 +2,28 @@ import {defineSequence} from "../core/defineSequence";
 import {asSequence, validAsSequence} from "../core/asSequence";
 import {wrap} from "../core/wrap";
 
-// TODO: These sequences probably need to implement collapseBreak methods
-export const ForwardFlattenSequence = defineSequence({
+export const FlattenSequence = defineSequence({
     summary: "Enumerate in series the elements of a sequence's subsequences.",
     collapseOutOfPlace: true,
-    overrides: {
-        reverse: {none: true},
-    },
     docs: process.env.NODE_ENV !== "development" ? undefined : {
         introduced: "higher@1.0.0",
         expects: (`
             The constructor expects a single sequence as input.
         `),
     },
-    tests: process.env.NODE_ENV !== "development" ? undefined : {
-        "reverseOverride": hi => {
-            const seq = new hi.sequence.ForwardFlattenSequence(hi([[1, 2], [3, 4]]));
-            hi.assertEqual(seq.reverse(), [4, 3, 2, 1]);
-        },
-    },
-    constructor: function ForwardFlattenSequence(
+    constructor: function FlattenSequence(
         source, frontSource = undefined
     ){
         this.source = source;
         this.frontSource = frontSource;
     },
-    reverse: function(){
-        return new BackwardFlattenSequence(this.source);
-    },
     initializeFront: function(){
         while((!this.frontSource || this.frontSource.done()) && !this.source.done()){
             this.frontSource = asSequence(this.source.nextFront());
         }
     },
     bounded: () => false,
-    unbounded: () => {
+    unbounded: function(){
         return this.source.unbounded();
     },
     done: function(){
@@ -60,63 +47,6 @@ export const ForwardFlattenSequence = defineSequence({
     },
 });
 
-export const BackwardFlattenSequence = defineSequence({
-    summary: "Enumerate in series the elements of a sequence's subsequences, in reverse.",
-    collapseOutOfPlace: true,
-    overrides: {
-        reverse: {none: true},
-    },
-    docs: process.env.NODE_ENV !== "development" ? undefined : {
-        introduced: "higher@1.0.0",
-        expects: (`
-            The constructor expects a single sequence as input.
-        `),
-    },
-    tests: process.env.NODE_ENV !== "development" ? undefined : {
-        "reverseOverride": hi => {
-            const seq = new hi.sequence.BackwardFlattenSequence(hi([[1, 2], [3, 4]]));
-            hi.assertEqual(seq.reverse(), [1, 2, 3, 4]);
-        },
-    },
-    constructor: function BackwardFlattenSequence(
-        source, frontSource = undefined
-    ){
-        this.source = source;
-        this.frontSource = frontSource;
-    },
-    reverse: function(){
-        return new ForwardFlattenSequence(this.source);
-    },
-    initializeFront: function(){
-        while((!this.frontSource || this.frontSource.done()) && !this.source.done()){
-            this.frontSource = asSequence(this.source.nextBack());
-        }
-    },
-    bounded: () => false,
-    unbounded: () => {
-        return this.source.unbounded();
-    },
-    done: function(){
-        if(!this.frontSource) this.initializeFront();
-        return !this.frontSource || this.frontSource.done();
-    },
-    front: function(){
-        if(!this.frontSource) this.initializeFront();
-        return this.frontSource.back();
-    },
-    popFront: function(){
-        if(!this.frontSource) this.initializeFront();
-        this.frontSource.popBack();
-        while((!this.frontSource || this.frontSource.done()) && !this.source.done()){
-            this.frontSource = asSequence(this.source.nextBack());
-        }
-    },
-    rebase: function(source){
-        this.source = source;
-        return this;
-    },
-});
-
 // Flatten a single level deep.
 export const flatten = wrap({
     name: "flatten",

diff --git a/src/functions/last.js b/src/functions/last.js
@@ -98,7 +98,7 @@ export const last = wrap({
             functions: {optional: wrap.expecting.predicate},
             sequences: {one: wrap.expecting.either(
                 wrap.expecting.boundedSequence,
-                wrap.expecting.reversibleSequence
+                wrap.expecting.bidirectionalSequence
             )},
         }
     },
@@ -111,8 +111,6 @@ export const last = wrap({
                 return new FilterSequence(predicate, source);
             }else if(source.back){
                 return BidirectionalOnDemandLastSequence(count, predicate, source);
-            }else if(source.overrides.reverse){
-                return ReversibleOnDemandLastSequence(count, predicate, source);
             }else{ // Argument validation implies that source.bounded()
                 return UnidirectionalOnDemandLastSequence(count, predicate, source);
             }
@@ -126,8 +124,6 @@ export const last = wrap({
             return source;
         }else if(source.back){
             return BidirectionalOnDemandTailSequence(count, source);
-        }else if(source.overrides.reverse){
-            return ReversibleOnDemandTailSequence(count, source);
         }else{ // Argument validation implies that source.bounded()
             return UnidirectionalOnDemandTailSequence(count, source);
         }
@@ -237,18 +233,6 @@ export const last = wrap({
             hi.assertEmpty(hi.range(10).last(i => false));
             hi.assertEmpty(hi("hello").last(i => false));
         },
-        "boundedReverseOverrideInput": hi => {
-            const seq = () => hi.repeat(4, [[1, 2, 3], [4, 5]]).flatten();
-            const even = i => i % 2 === 0;
-            hi.assertEqual(seq().last(7), [4, 5, 1, 2, 3, 4, 5]);
-            hi.assertEqual(seq().last(5, even), [4, 2, 4, 2, 4]);
-        },
-        "unboundedReverseOverrideInput": hi => {
-            const seq = () => hi.repeat([[1, 2, 3], [4, 5]]).flatten();
-            const even = i => i % 2 === 0;
-            hi.assertEqual(seq().last(7), [4, 5, 1, 2, 3, 4, 5]);
-            hi.assertEqual(seq().last(5, even), [4, 2, 4, 2, 4]);
-        },
     },
 });
 

diff --git a/src/functions/lastElement.js b/src/functions/lastElement.js
@@ -39,7 +39,7 @@ export const lastElement = wrap({
             functions: {optional: wrap.expecting.predicate},
             sequences: {one: wrap.expecting.either(
                 wrap.expecting.boundedSequence,
-                wrap.expecting.reversibleSequence
+                wrap.expecting.bidirectionalSequence
             )},
         },
     },
@@ -56,19 +56,6 @@ export const lastElement = wrap({
             }else{
                 return undefined;
             }
-        }else if(source.overrides.reverse){
-            const reversed = source.reverse();
-            if(predicate){
-                while(!reversed.done()){
-                    const element = reversed.nextFront();
-                    if(predicate(element)) return element;
-                }
-                return undefined;
-            }else if(!reversed.done()){
-                return reversed.front();
-            }else{
-                return undefined;
-            }
         }else if(predicate){ // Arguments validation implies that source.bounded()
             let lastElement = undefined;
             for(const element of source){
@@ -106,13 +93,6 @@ export const lastElement = wrap({
             hi.assert(seq().lastElement(even) === 6);
             hi.assertUndefined(seq().lastElement(i => false));
         },
-        "reversibleInput": hi => {
-            const seq = () => hi.flatten([[1, 2, 3], [4, 5]]);
-            const even = i => i % 2 === 0;
-            hi.assert(seq().lastElement() === 5);
-            hi.assert(seq().lastElement(even) === 4);
-            hi.assertUndefined(seq().lastElement(i => false));
-        },
         "unboundedBidirectionalInput": hi => {
             hi.assert(hi.counter().lastElement() === Infinity);
             hi.assert(hi.counter().lastElement(i => true) === Infinity);

diff --git a/src/functions/lastElementElse.js b/src/functions/lastElementElse.js
@@ -44,7 +44,7 @@ export const lastElementElse = wrap({
             },
             sequences: {one: wrap.expecting.either(
                 wrap.expecting.boundedSequence,
-                wrap.expecting.reversibleSequence
+                wrap.expecting.bidirectionalSequence
             )},
         },
     },
@@ -63,19 +63,6 @@ export const lastElementElse = wrap({
             }else{
                 return callback();
             }
-        }else if(source.overrides.reverse){
-            const reversed = source.reverse();
-            if(predicate){
-                while(!reversed.done()){
-                    const element = reversed.nextFront();
-                    if(predicate(element)) return element;
-                }
-                return callback();
-            }else if(!reversed.done()){
-                return reversed.front();
-            }else{
-                return callback();
-            }
         }else if(predicate){ // Arguments validation implies that source.bounded()
             let lastElement = undefined;
             let anyElement = false;
@@ -125,13 +112,6 @@ export const lastElementElse = wrap({
             hi.assert(seq().lastElementElse(bang, even) === 6);
             hi.assert(seq().lastElementElse(bang, i => false) === "!");
         },
-        "reversibleInput": hi => {
-            const seq = () => hi.flatten([[1, 2, 3], [4, 5]]);
-            const even = i => i % 2 === 0;
-            hi.assert(seq().lastElementElse(() => "!") === 5);
-            hi.assert(seq().lastElementElse(() => "!", even) === 4);
-            hi.assert(seq().lastElementElse(() => "!", i => false) === "!");
-        },
         "unboundedBidirectionalInput": hi => {
             hi.assert(hi.counter().lastElementElse(() => 0) === Infinity);
             hi.assert(hi.counter().lastElementElse(() => 0, i => true) === Infinity);

diff --git a/src/functions/tail.js b/src/functions/tail.js
@@ -26,23 +26,6 @@ export const BidirectionalOnDemandTailSequence = (count, source) => {
     });
 };
 
-// Get an on-demand sequence for retrieving the tail of a reversible sequence.
-export const ReversibleOnDemandTailSequence = (count, source) => {
-    const reversed = source.reverse();
-    return new OnDemandSequence(ReverseSequence.appliedTo(ArraySequence), {
-        bounded: () => true,
-        unbounded: () => false,
-        done: () => reversed.done(),
-        dump: () => {
-            const array = [];
-            while(array.length < count && !reversed.done()){
-                array.push(reversed.nextFront());
-            }
-            return new ReverseSequence(new ArraySequence(array));
-        },
-    });
-};
-
 // Get an on-demand sequence for retrieving the tail of a unidirectional 
 // but known-bounded sequence.
 export const UnidirectionalOnDemandTailSequence = (count, source) => {
@@ -95,7 +78,7 @@ export const tail = wrap({
             numbers: 1,
             sequences: {one: wrap.expecting.either(
                 wrap.expecting.boundedSequence,
-                wrap.expecting.reversibleSequence
+                wrap.expecting.bidirectionalSequence
             )},
         }
     },
@@ -113,8 +96,6 @@ export const tail = wrap({
             return source;
         }else if(source.back){
             return BidirectionalOnDemandTailSequence(count, source);
-        }else if(source.overrides.reverse){
-            return ReversibleOnDemandTailSequence(count, source);
         }else{ // Argument validation implies source.bounded()
             return UnidirectionalOnDemandTailSequence(count, source);
         }
@@ -170,16 +151,6 @@ export const tail = wrap({
         "unboundedUnidirectionalInput": hi => {
             hi.assertFail(() => hi.recur(i => i + 1).seed(0).tail(10));
         },
-        "boundedReverseOverrideInput": hi => {
-            const seq = () => hi.repeat(4, [[1, 2, 3], [4, 5]]).flatten();
-            const even = i => i % 2 === 0;
-            hi.assertEqual(seq().tail(7), [4, 5, 1, 2, 3, 4, 5]);
-        },
-        "unboundedReverseOverrideInput": hi => {
-            const seq = () => hi.repeat([[1, 2, 3], [4, 5]]).flatten();
-            const even = i => i % 2 === 0;
-            hi.assertEqual(seq().tail(7), [4, 5, 1, 2, 3, 4, 5]);
-        },
     },
 });