1432

pending completion

Build # 1432

Build Type

Pull #361

travis-ci-com

Committed by

web-flow

Commit Message

Merge c7c5506eb into 80249e761

Pull Request Pull Request #361: Entity inheritance changes cherry-picked from CSQA branch

Run Details

4510 of 6311 branches covered (71.46%)

Branch coverage included in aggregate %.

68 of 70 new or added lines in 4 files covered. (97.14%)

74 existing lines in 3 files now uncovered.

10291 of 12730 relevant lines covered (80.84%)

49115.43 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.73

/lib/utils/list.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of ThingTalk
//
// Copyright 2019-2020 The Board of Trustees of the Leland Stanford Junior University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>

// A lazy functional list with O(1) concatenation
export default abstract class List<T> {
    static Nil : List<never>;

    static concat<T>(...lists : Array<T|List<T>>) : List<T> {
        let result : List<T> = List.Nil;
        for (let i = lists.length-1; i >= 0; i--) {
            if (lists[i] instanceof List && result === List.Nil)
                result = lists[i] as List<T>;
            else if (lists[i] instanceof List)
                result = new Concat<T>(lists[i] as List<T>, result);
            else
                result = new Cons<T>(lists[i] as T, result);
        }
        return result;
    }

    static join<T>(lists : Array<List<T>>, joiner : T) : List<T> {
        let result : List<T> = List.Nil;
        let first = true;
        for (const list of lists) {
            if (first)
                first = false;
            else
                result = new Snoc<T>(result, joiner);
            result = new Concat<T>(result, list);
        }
        return result;
    }

    static singleton<T>(el : T) : List<T> {
        return new Cons<T>(el, List.Nil);
    }

    static append<T>(list : List<T>, el : T) : List<T> {
        return new Snoc(list, el);
    }

    flatten(into : T[] = []) : T[] {
        this.traverse((el) => into.push(el));
        return into;
    }

    [Symbol.iterator]() : Iterator<T> {
        return new ListIterator(this);
    }

    abstract traverse(cb : (x : T) => void) : void;
    abstract getFirst() : T;
}

class NilClass extends List<never> {
    traverse(cb : (x : never) => void) : void {
    }

    getFirst() : never {
        throw new Error('getFirst on an empty list');
    }
}
List.Nil = new NilClass();

class Cons<T> extends List<T> {
    constructor(public head : T,
                public tail : List<T>) {
        super();
    }

    traverse(cb : (x : T) => void) : void {
        cb(this.head);
        this.tail.traverse(cb);
    }

    getFirst() : T {
        return this.head;
    }
}

class Snoc<T> extends List<T> {
    constructor(public head : List<T>,
                public tail : T) {
        super();
    }

    traverse(cb : (x : T) => void) : void {
        this.head.traverse(cb);
        cb(this.tail);
    }

    getFirst() : T {
        return this.head.getFirst();
    }
}

class Concat<T> extends List<T> {
    constructor(public first : List<T>,
                public second : List<T>) {
        super();
        this.first = first;
        this.second = second;
    }

    traverse(cb : (x : T) => void) : void {
        this.first.traverse(cb);
        this.second.traverse(cb);
    }

    getFirst() : T {
        return this.first.getFirst();
    }
}

class ListIterator<T> implements Iterator<T> {
    private _stack : Array<T|List<T>>;

    constructor(list : List<T>) {
        this._stack = [list];
    }

    next() : IteratorResult<T, void> {
        while (this._stack.length > 0) {
            const x = this._stack.pop()!;
            if (x instanceof List) {
                if (x instanceof Cons || x instanceof Snoc)
                    this._stack.push(x.tail, x.head);
                else if (x instanceof Concat)
                    this._stack.push(x.second, x.first);
            } else { 
                return { done: false, value: x };
            }
        }
        return { done: true, value: undefined };
    }
}

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of ThingTalk
4	//
5	// Copyright 2019-2020 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
20
21	// A lazy functional list with O(1) concatenation
22	export default abstract class List<T> {	2✔
23	static Nil : List<never>;
24
25	static concat<T>(...lists : Array<T\|List<T>>) : List<T> {
26	let result : List<T> = List.Nil;	61,290✔
27	for (let i = lists.length-1; i >= 0; i--) {	61,290✔
28	if (lists[i] instanceof List && result === List.Nil)	214,602✔
29	result = lists[i] as List<T>;	27,916✔
30	else if (lists[i] instanceof List)	186,686✔
31	result = new Concat<T>(lists[i] as List<T>, result);	64,224✔
32	else
33	result = new Cons<T>(lists[i] as T, result);	122,462✔
34	}
35	return result;	61,290✔
36	}
37
38	static join<T>(lists : Array<List<T>>, joiner : T) : List<T> {
39	let result : List<T> = List.Nil;	16,876✔
40	let first = true;	16,876✔
41	for (const list of lists) {	16,876✔
42	if (first)	15,472✔
43	first = false;	12,522✔
44	else
45	result = new Snoc<T>(result, joiner);	2,950✔
46	result = new Concat<T>(result, list);	15,472✔
47	}
48	return result;	16,876✔
49	}
50
51	static singleton<T>(el : T) : List<T> {
52	return new Cons<T>(el, List.Nil);	19,274✔
53	}
54
55	static append<T>(list : List<T>, el : T) : List<T> {
56	return new Snoc(list, el);	×
57	}
58
59	flatten(into : T[] = []) : T[] {	×
60	this.traverse((el) => into.push(el));	5,860✔
61	return into;	444✔
62	}
63
64	[Symbol.iterator]() : Iterator<T> {
65	return new ListIterator(this);	4,462✔
66	}
67
68	abstract traverse(cb : (x : T) => void) : void;
69	abstract getFirst() : T;
70	}
71
72	class NilClass extends List<never> {
73	traverse(cb : (x : never) => void) : void {
74	}
75
76	getFirst() : never {
UNCOV 77	throw new Error('getFirst on an empty list');	×
78	}
79	}
80	List.Nil = new NilClass();	2✔
81
82	class Cons<T> extends List<T> {
83	constructor(public head : T,	141,736✔
84	public tail : List<T>) {	141,736✔
85	super();	141,736✔
86	}
87
88	traverse(cb : (x : T) => void) : void {
89	cb(this.head);	6,540✔
90	this.tail.traverse(cb);	6,540✔
91	}
92
93	getFirst() : T {
94	return this.head;	×
95	}
96	}
97
98	class Snoc<T> extends List<T> {
99	constructor(public head : List<T>,	2,950✔
100	public tail : T) {	2,950✔
101	super();	2,950✔
102	}
103
104	traverse(cb : (x : T) => void) : void {
UNCOV 105	this.head.traverse(cb);	×
UNCOV 106	cb(this.tail);	×
107	}
108
109	getFirst() : T {
110	return this.head.getFirst();	×
111	}
112	}
113
114	class Concat<T> extends List<T> {
115	constructor(public first : List<T>,	79,696✔
116	public second : List<T>) {	79,696✔
117	super();	79,696✔
118	this.first = first;	79,696✔
119	this.second = second;	79,696✔
120	}
121
122	traverse(cb : (x : T) => void) : void {
123	this.first.traverse(cb);	1,716✔
124	this.second.traverse(cb);	1,716✔
125	}
126
127	getFirst() : T {
UNCOV 128	return this.first.getFirst();	×
129	}
130	}
131
132	class ListIterator<T> implements Iterator<T> {
133	private _stack : Array<T\|List<T>>;
134
135	constructor(list : List<T>) {
136	this._stack = [list];	4,462✔
137	}
138
139	next() : IteratorResult<T, void> {
140	while (this._stack.length > 0) {	139,522✔
141	const x = this._stack.pop()!;	429,346✔
142	if (x instanceof List) {	429,346✔
143	if (x instanceof Cons \|\| x instanceof Snoc)	293,556✔
144	this._stack.push(x.tail, x.head);	135,854✔
145	else if (x instanceof Concat)	157,702✔
146	this._stack.push(x.second, x.first);	77,256✔
147	} else {
148	return { done: false, value: x };	135,790✔
149	}
150	}
151	return { done: true, value: undefined };	3,732✔
152	}
153	}

stanford-oval / thingtalk / 1432

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous