conset v2.0.3

conset.js

An ordered conditional set (you can provide your own hash) for typescript/javascript

Features

• Provide your own hash function which returns a string. This will be used as the identifier of the item.
• Maintain order.
• Newly added values override existing ones and update order.
• Barebones functional API.
• compute intersection and union

Usage

import * as conset from 'conset'

interface MyItem {
	id:string
	data:any[]
}

function myhash(item:MyItem):string {
	return item['id']
}

let myset = conset.create(myhash)

conset.add(myset, {id: 1, data: ["whatever", "something"]})
conset.add(myset, {id: 2, data: ["something", "whatever"]})
conset.add(myset, {id: 3, data: ["something", "whatever", "balls"]})

conset.getItems(myset)
/* 
[
	{id: 1, data: ["whatever", "something"]}
	{id: 2, data: ["something", "whatever"]}
	{id: 3, data: ["something", "whatever", "balls"]}
] 
*/

conset.contains(myset, {id: '3'}) 
/*
true
*/
conset.remove(myset, {id: 3}) 
conset.getItems(myset)
/* 
[
	{id: 1, data: ["whatever", "something"]}
	{id: 2, data: ["something", "whatever"]}
] 
*/

for(let item of conset.iter(myset)) {
	console.dir(item)
}
/*
{id: 1, data: ["whatever", "something"]}
{id: 2, data: ["something", "whatever"]}
*/

var c = conset.create((item) => {return item['a']}, [{a:1}, {a:2}, {a:7}])
var d = conset.create((item) => {return item['a']}, [{a:1}, {a:2}, {a:3}])
conset.getItems(conset.intersect(c,d))
/*
[ { a: 1 }, { a: 2 } ]
*/
var d = conset.create((item) => {return item['a']}, [{a:1}, {a:2}, {a:3}, {a:9}, {a:10}])
var c = conset.create((item) => {return item['a']}, [{a:1}, {a:2}, {a:7}])
conset.getItems(conset.union(c,d))
/*
[ { a: 3 }, { a: 9 }, { a: 10 }, { a: 1 }, { a: 2 }, { a: 7 } ]
*/
>

API overview TODO use JSDoc for this

declare type HashFunction<T> = (item: T) => string;
interface Conset<T> {
    map: Object;
    order: string[];
    hashFunction: HashFunction<T>;
}
declare const create: <T>(hashFunction: HashFunction<T>, initialItems?: T[]) => Conset<T>;
declare function iter<T>(conset: Conset<T>): IterableIterator<T>;
declare const remove: <T>(conset: Conset<T>, item: T) => Conset<T>;
declare const add: <T>(conset: Conset<T>, item: T) => Conset<T>;
declare const contains: <T>(conset: Conset<T>, item: T) => boolean;
declare const getItems: <T>(conset: Conset<T>) => T[];
declare const size: <T>(conset: Conset<T>) => number;
declare const intersect: <T>(smaller: Conset<T>, larger: Conset<T>) => Conset<T>;
declare const copy: <T>(conset: Conset<T>) => Conset<T>;
declare const union: <T>(smaller: Conset<T>, larger: Conset<T>) => Conset<T>;