/g,\"\"))\n .getOrThrow(\"globals.arrangeBy failed!\");\n\n // start preparing the new contents for the indexContent\n let newIndexContent = `${helpers.indent(5)}`;\n\n const allKnownElements = CATEGORIES\n .map(c=>c[1])\n .flatMap(x=>x)\n .transform(HashSet.ofIterable);\n\n const missingElements = liRows.keySet().diff(allKnownElements);\n if (!missingElements.isEmpty()) {\n throw \"Missing the following elements: \" + missingElements;\n }\n\n CATEGORIES.forEach(([name,elements]) => {\n newIndexContent += getSectionHeader(name);\n const rows = elements.map(elt => liRows.get(elt).getOrThrow(\"can't find row for \" + elt));\n newIndexContent += rows.mkString(\"\\n\");\n newIndexContent += getSectionFooter();\n });\n\n // conclude the new contents for the indexContent\n newIndexContent += `${helpers.indent(5)}
\\n`; // close tsd-index-content\n\n // overwrite globals.html -- first the text before the indexContent,\n // then the modified indexContent, then the rest.\n writeFileSync(\n 'apidoc/globals.html',\n helpers.linesByIndentStr(beforeIndexContent) +\n newIndexContent +\n helpers.linesByIndentStr(afterIndexContent));\n}\n"
},
{
"path": "scripts/make_doc_extra/helpers.ts",
"content": "import { Stream } from \"../../src/Stream\";\nimport { Vector } from \"../../src/Vector\";\nimport { readFileSync } from \"fs\";\n\nexport function requireNotNull(x:T|null): T {\n if (x === null) {\n throw \"requireNotNull got null!\";\n }\n return x;\n}\n\nexport function indent(count: number): string {\n return \"\\n\" + Stream.continually(()=>\"\\t\")\n .take(count).mkString(\"\");\n}\n\nexport type LineByIndent = {contents:string,indent:number};\nexport type LinesByIndent = Vector;\n\nexport function fileGetLinesByIndent(fname: string): LinesByIndent {\n const contents = readFileSync(fname).toString();\n return Vector.ofIterable(contents.split(\"\\n\"))\n .map(l => ({indent: l.length-l.trim().length, contents: l}));\n}\n\n/**\n * extract a tag from the linesbyindent. You tell me the tag name,\n * how to match the start tag, I return to you the rows before, the rows within that\n * tag (depth>=tagDepth) and the rows after.\n * returns [before, atTag, after]\n */\nexport function linesByIndentGetTagContents(\n lines: LinesByIndent,\n tagName: string, \n startPredicate: (line:string)=>boolean): [LinesByIndent, LinesByIndent, LinesByIndent] {\n // split the parts before & after using string the predicate & indentation.\n const [before, atTag] = lines.span(l => !startPredicate(l.contents));\n const indentAtTag = atTag.head().getOrThrow().indent;\n const [tagContents,after] =\n atTag.span(l => (l.indent > indentAtTag) ||\n (l.indent <= indentAtTag && l.contents.indexOf(\" l.contents).mkString(\"\\n\");\n}\n"
},
{
"path": "scripts/make_doc_extra/make_doc_extra.ts",
"content": "import { groupGlobalsByCategory } from \"./globals\";\nimport { putClassStaticMethodsOnTop } from \"./classes\";\n\nconsole.log(\"groupGlobalsByCategory\");\ngroupGlobalsByCategory();\nconsole.log(\"putClassStaticMethodsOnTop\");\nputClassStaticMethodsOnTop();\nconsole.log(\"make extra: done!\");\n"
},
{
"path": "scripts/make_doc_extra/make_doc_preprocess.ts",
"content": "import { readFileSync, writeFileSync } from \"fs\";\n\ndeclare global {\n interface String {\n startsWith(other:string): boolean\n }\n}\n\nfunction makeModule(moduleName:string, filename:string): void {\n const contents = readFileSync(filename).toString();\n const moduleStart = \"export module \" + moduleName+ \" { \";\n const contentsWithModuleHeader = contents.trim().startsWith(\"/**\") ?\n // add the module header at the end of the apidoc comment\n // so the comment apidoc covers the module\n contents.replace(/\\*\\//, \"*/ \" + moduleStart) :\n // add the module header straight at the top of the file\n moduleStart + contents;\n\n // in any case close at the end of the file\n writeFileSync(filename, contentsWithModuleHeader + \"\\n}\\n\");\n}\n\n// list of files for which to trick typedoc\n// to think they're external modules\nmakeModule(\"Comparison\", \"src/Comparison.ts\");\nmakeModule(\"Contract\", \"src/Contract.ts\");\nmakeModule(\"Option\", \"src/Option.ts\");\nmakeModule(\"Either\", \"src/Either.ts\");\nmakeModule(\"LinkedList\", \"src/LinkedList.ts\");\nmakeModule(\"Stream\", \"src/Stream.ts\");\nmakeModule(\"Function\", \"src/Function.ts\");\nmakeModule(\"Predicate\", \"src/Predicate.ts\");\n\n"
},
{
"path": "scripts/prepublish.sh",
"content": "#!/usr/bin/env bash\nset -e\n\nnode_modules/typescript/bin/tsc -p tsconfig.prepublish.json\nnode ./node_modules/browserify/bin/cmd.js -s prelude_ts dist/src/index.js -o /tmp/prelude_ts_pre.js\nscripts/with_header.sh /tmp/prelude_ts_pre.js > dist/src/prelude_ts.js\nnode ./node_modules/browserify/bin/cmd.js -s prelude_ts_object_formatters dist/src/ChromeDevToolFormatters.js -o dist/src/chrome_dev_tools_formatters.js\n./node_modules/uglify-js/bin/uglifyjs --compress --mangle --output /tmp/prelude_ts_premin.js -- /tmp/prelude_ts_pre.js\nscripts/with_header.sh /tmp/prelude_ts_premin.js > dist/src/prelude_ts.min.js\nrm /tmp/prelude_ts_pre.js /tmp/prelude_ts_premin.js\n"
},
{
"path": "scripts/with_header.sh",
"content": "#!/usr/bin/env bash\nset -e\n\ncat < [\"li\",{},\n [\"span\",{\"style\":\"color: rgb(136, 19, 145);\"},idx+\": \"],\n [\"object\", {\"object\":x}]])];\n}\n\nclass VectorHandler implements ElementHandler {\n isElement(object:any): boolean {\n return object.hashCode && object.equals &&\n object.replace && object.sortOn && object._list;\n }\n getHeader(object:any): any {\n return [\"span\", {}, \"Vector(\" + object.length() + \")\"];\n }\n hasBody(elt:any): boolean {\n return !elt.isEmpty();\n }\n getBody = getWithToArrayBody\n}\n\n// not going to behave well with infinite streams...\nclass StreamHandler implements ElementHandler {\n isElement(object:any): boolean {\n return object.hashCode && object.equals && object.sortBy && object.cycle && object.toVector;\n }\n getHeader(object:any): any {\n // not displaying the length for streams in case\n // of infinite streams. the user can expand if needed.\n return [\"span\", {}, \"Stream(?)\"];\n }\n hasBody(elt:any): boolean {\n return !elt.isEmpty();\n }\n getBody = getWithToArrayBody\n}\n\nclass ListHandler implements ElementHandler {\n isElement(object:any): boolean {\n return object.hashCode && object.equals && object.sortBy && object.toVector;\n }\n getHeader(object:any): any {\n // not displaying the length for streams in case\n // of infinite streams. the user can expand if needed.\n return [\"span\", {}, \"List(\" + object.length() + \")\"];\n }\n hasBody(elt:any): boolean {\n return !elt.isEmpty();\n }\n getBody = getWithToArrayBody\n}\n\nclass HashSetHandler implements ElementHandler {\n isElement(object:any): boolean {\n return object.hashCode && object.equals && object.hamt && object.intersect;\n }\n getHeader(object:any): any {\n return [\"span\", {}, \"HashSet(\" + object.length() + \")\"];\n }\n hasBody(elt:any): boolean {\n return !elt.isEmpty();\n }\n getBody = getWithToArrayBody\n}\n\nclass HashMapHandler implements ElementHandler {\n isElement(object:any): boolean {\n return object.hashCode && object.equals && object.hamt && object.valueIterable;\n }\n getHeader(object:any): any {\n return [\"span\", {}, \"HashMap(\" + object.length() + \")\"];\n }\n hasBody(elt:any): boolean {\n return !elt.isEmpty();\n }\n getBody(elt:any): any {\n return [\"ol\",\n {\"style\":olStyle},\n ...elt.toArray().map((kv:any,idx:number) => {\n // using object.create to avoid the __proto__ in the GUI\n const obj = Object.create(null);\n obj.key = kv[0];\n obj.value = kv[1];\n return [\"li\",{},\n [\"span\",{\"style\":\"color: rgb(136, 19, 145);\"},idx+\": \"],\n [\"object\", {\"object\":obj}]];\n })];\n }\n}\n\nconst handlers = [new VectorHandler(),\n new StreamHandler(),\n new ListHandler(),\n new HashSetHandler(),\n new HashMapHandler()];\n\nfunction getHandler(object: any): ElementHandler|undefined {\n return handlers.find(h => h.isElement(object));\n}\n\nconst formatter = {\n header: (object: any, config: any): any => {\n const handler = getHandler(object);\n return handler ? handler.getHeader(object) : null;\n },\n hasBody: (object: any, config: any): boolean => {\n const handler = getHandler(object);\n return handler ? handler.hasBody(object) : false;\n },\n body: (object: any, config:any): any => {\n const handler = getHandler(object);\n return handler ? handler.getBody(object) : null;\n }\n};\nif (!(window).devtoolsFormatters) {\n (window).devtoolsFormatters = [];\n}\n(window).devtoolsFormatters.push(formatter);\n"
},
{
"path": "src/Collection.ts",
"content": "import { WithEquality, Ordering, ToOrderable } from \"./Comparison\";\nimport { Value } from \"./Value\";\nimport { Option } from \"./Option\";\nimport { HashMap } from \"./HashMap\";\nimport { Foldable } from \"./Foldable\";\n\nexport interface Collection extends Value, Iterable, Foldable {\n\n /**\n * Get the length of the collection.\n */\n length(): number;\n\n /**\n * true if the collection is empty, false otherwise.\n */\n isEmpty(): boolean;\n\n /**\n * Convert to array.\n */\n toArray(): Array;\n\n /**\n * Call a predicate for each element in the collection,\n * build a new collection holding only the elements\n * for which the predicate returned true.\n */\n filter(fn:(v:T)=>v is U): Collection;\n filter(predicate:(v:T)=>boolean): Collection;\n\n /**\n * Returns a pair of two collections; the first one\n * will only contain the items from this collection for\n * which the predicate you give returns true, the second\n * will only contain the items from this collection where\n * the predicate returns false.\n *\n * Vector.of(1,2,3,4).partition(x => x%2===0)\n * => [Vector.of(2,4), Vector.of(1,3)]\n */\n partition(predicate:(v:T)=>v is U): [Collection,Collection>];\n partition(predicate:(x:T)=>boolean): [Collection,Collection];\n\n /**\n * Returns true if the item is in the collection,\n * false otherwise.\n */\n contains(v:T&WithEquality): boolean;\n\n /**\n * Returns true if the predicate returns true for all the\n * elements in the collection.\n */\n allMatch(predicate:(v:T)=>v is U): this is Collection;\n allMatch(predicate:(v:T)=>boolean): boolean;\n\n /**\n * Returns true if there the predicate returns true for any\n * element in the collection.\n */\n anyMatch(predicate:(v:T)=>boolean): boolean;\n\n /**\n * If the collection contains a single element,\n * return Some of its value, otherwise return None.\n */\n single(): Option;\n\n /**\n * Group elements in the collection using a classifier function.\n * Elements are then organized in a map. The key is the value of\n * the classifier, and in value we get the list of elements\n * matching that value.\n *\n * also see [[Collection.arrangeBy]]\n */\n groupBy(classifier: (v:T)=>C&WithEquality): HashMap>;\n\n /**\n * Matches each element with a unique key that you extract from it.\n * If the same key is present twice, the function will return None.\n *\n * also see [[Collection.groupBy]]\n */\n arrangeBy(getKey: (v:T)=>K&WithEquality): Option>;\n\n /**\n * Compare values in the collection and return the smallest element.\n * Returns Option.none if the collection is empty.\n *\n * also see [[Collection.minOn]]\n */\n minBy(compare: (v1:T,v2:T)=>Ordering): Option;\n\n /**\n * Call the function you give for each value in the collection\n * and return the element for which the result was the smallest.\n * Returns Option.none if the collection is empty.\n *\n * Vector.of({name:\"Joe\", age:12}, {name:\"Paula\", age:6}).minOn(x=>x.age)\n * => Option.of({name:\"Paula\", age:6})\n *\n * also see [[Collection.minBy]]\n */\n minOn(getNumber: ToOrderable): Option;\n\n /**\n * Compare values in the collection and return the largest element.\n * Returns Option.none if the collection is empty.\n *\n * also see [[Collection.maxOn]]\n */\n maxBy(compare: (v1:T,v2:T)=>Ordering): Option;\n\n /**\n * Call the function you give for each value in the collection\n * and return the element for which the result was the largest.\n * Returns Option.none if the collection is empty.\n *\n * Vector.of({name:\"Joe\", age:12}, {name:\"Paula\", age:6}).maxOn(x=>x.age)\n * => Option.of({name:\"Joe\", age:12})\n *\n * also see [[Collection.maxBy]]\n */\n maxOn(getSortable: ToOrderable): Option;\n\n /**\n * Call the function you give for each element in the collection\n * and sum all the numbers, return that sum.\n * Will return 0 if the collection is empty.\n *\n * Vector.of(1,2,3).sumOn(x=>x)\n * => 6\n */\n sumOn(getNumber: (v:T)=>number): number;\n}\n"
},
{
"path": "src/Comparison.ts",
"content": "import { Option } from \"./Option\";\n\n/**\n * Sorting function for type T: function\n * to convert this type to a type which is natively\n * sortable in javascript, that is string, number or boolean.\n * `((v:T)=>number) | ((v:T)=>string) | ((v:T)=>boolean`\n */\nexport type ToOrderable = ((v:T)=>number) | ((v:T)=>string) | ((v:T)=>boolean);\n\n/**\n * List of types which provide equality semantics:\n * some builtin JS types, for which === provides\n * proper semantics, and then types providing HasEquals.\n * The reason I use all over the place T&WithEquality\n * instead of saying earlier\n * in the declaration is: https://stackoverflow.com/a/45903143/516188\n */\nexport type WithEquality\n = string\n | number\n | boolean\n | null\n | HasEquals;\n\n/**\n * A type with semantic equality relationships\n */\nexport type HasEquals = {equals(other: any): boolean; hashCode(): number;};\n\n/**\n * Type guard for HasEquals: find out for a type with\n * semantic equality, whether you should call .equals\n * or ===\n */\nexport function hasEquals(v: WithEquality): v is HasEquals {\n // there is a reason why we check only for equals, not for hashCode.\n // we want to decide which codepath to take: === or equals/hashcode.\n // if there is a equals function then we don't want ===, regardless of\n // whether there is a hashCode method or not. If there is a equals\n // and not hashCode, we want to go on the equals/hashCode codepath,\n // which will blow a little later at runtime if the hashCode is missing.\n return ((v).equals !== undefined);\n}\n\n/**\n * Helper function for your objects so you can compute\n * a hashcode. You can pass to this function all the fields\n * of your object that should be taken into account for the\n * hash, and the function will return a reasonable hash code.\n *\n * @param fields the fields of your object to take\n * into account for the hashcode\n */\nexport function fieldsHashCode(...fields: any[]): number {\n // https://stackoverflow.com/a/113600/516188\n // https://stackoverflow.com/a/18066516/516188\n let result = 1;\n for (const value of fields) {\n result = 37*result + getHashCode(value);\n }\n return result;\n}\n\n/**\n * Helper function to compute a reasonable hashcode for strings.\n */\nexport function stringHashCode(str: string): number {\n // https://stackoverflow.com/a/7616484/516188\n var hash = 0, i, chr;\n if (str.length === 0) return hash;\n for (i = 0; i < str.length; i++) {\n chr = str.charCodeAt(i);\n hash = ((hash << 5) - hash) + chr;\n hash |= 0; // Convert to 32bit integer\n }\n return hash;\n}\n\n/**\n * Equality function which tries semantic equality (using .equals())\n * if possible, degrades to === if not available, and is also null-safe.\n */\nexport function areEqual(obj: any|null, obj2: any|null): boolean {\n if ((obj === null) != (obj2 === null)) {\n return false;\n }\n if (obj === null || obj2 === null) {\n return true;\n }\n if (hasEquals(obj)) {\n return obj.equals(obj2);\n }\n return obj === obj2;\n}\n\n/**\n * Hashing function which tries to call hashCode()\n * and uses the object itself for numbers, then degrades\n * for stringHashCode of the string representation if\n * not available.\n */\nexport function getHashCode(obj: any|null): number {\n if (!obj) {\n return 0;\n }\n if (hasEquals(obj)) {\n return obj.hashCode();\n }\n if (typeof obj === 'number') {\n // this is the hashcode implementation for numbers from immutablejs\n if (obj !== obj || obj === Infinity) {\n return 0;\n }\n let h = obj | 0;\n if (h !== obj) {\n h ^= obj * 0xffffffff;\n }\n while (obj > 0xffffffff) {\n obj /= 0xffffffff;\n h ^= obj;\n }\n return smi(h);\n }\n const val = obj+\"\";\n return val.length > STRING_HASH_CACHE_MIN_STRLEN ?\n cachedHashString(val) :\n stringHashCode(val);\n}\n\nfunction cachedHashString(string: string) {\n let hashed = stringHashCache[string];\n if (hashed === undefined) {\n hashed = stringHashCode(string);\n if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {\n STRING_HASH_CACHE_SIZE = 0;\n stringHashCache = {};\n }\n STRING_HASH_CACHE_SIZE++;\n stringHashCache[string] = hashed;\n }\n return hashed;\n}\n\n// v8 has an optimization for storing 31-bit signed numbers.\n// Values which have either 00 or 11 as the high order bits qualify.\n// This function drops the highest order bit in a signed number, maintaining\n// the sign bit. (taken from immutablejs)\nfunction smi(i32: number): number {\n return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff);\n}\n\nconst STRING_HASH_CACHE_MIN_STRLEN = 16;\nconst STRING_HASH_CACHE_MAX_SIZE = 255;\nlet STRING_HASH_CACHE_SIZE = 0;\nlet stringHashCache: {[key:string]:number} = {};\n\n/**\n * @hidden\n */\nexport function hasTrueEquality(val: any): Option {\n if (!val) {\n return Option.none();\n }\n if (val.equals) {\n return Option.of(true);\n }\n switch (val.constructor) {\n case String:\n case Number:\n case Boolean:\n return Option.of(true);\n }\n return Option.of(false);\n}\n\n/**\n * Enumeration used to express ordering relationships.\n * it's a const enum, is replaced by integers in the source.\n */\nexport const enum Ordering {\n /**\n * Lower Than\n */\n LT=-1,\n /**\n * EQuals\n */\n EQ=0,\n /**\n * Greater Than\n */\n GT=1\n};\n\n/**\n * Typescript doesn't infer typeguards for lambdas; it only sees\n * predicates. This type allows you to cast a predicate to a type\n * guard in a handy manner.\n *\n * It comes in handy for discriminated unions with a 'kind' discriminator,\n * for instance:\n *\n * .`filter(>(p => p.kind === \"in_board\"))`\n *\n * Also see [[typeGuard]], [[instanceOf]] and [[typeOf]].\n */\nexport type TypeGuard = (x: T) => x is U;\n\n/**\n * Typescript doesn't infer typeguards for lambdas; it only sees\n * predicates. This type allows you to cast a predicate to a type\n * guard in a handy manner.\n *\n * It comes in handy for discriminated unions with a 'kind' discriminator,\n * for instance:\n *\n * `.filter(typeGuard(p => p.kind === \"in_board\", {} as InBoard))`\n *\n * Normally you'd have to give both type parameters, but you can use\n * the type witness parameter as shown in that example to skip\n * the first type parameter.\n *\n * Also see [[typeGuard]], [[instanceOf]] and [[typeOf]].\n */\nexport function typeGuard(predicate:(x:T)=>boolean,\n typeWitness?: U): TypeGuard {\n return >predicate;\n}\n\n/**\n * Curried function returning a type guard telling us if a value\n * is of a specific instance.\n * Can be used when filtering to filter for the type and at the\n * same time change the type of the generics on the container.\n *\n * Vector.of(\"bad\", new Date('04 Dec 1995 00:12:00 GMT')).filter(instanceOf(Date))\n * => Vector.of(new Date('04 Dec 1995 00:12:00 GMT'))\n *\n * Option.of(\"test\").filter(instanceOf(Date))\n * => Option.none()\n *\n * Option.of(new Date('04 Dec 1995 00:12:00 GMT')).filter(instanceOf(Date))\n * => Option.of(new Date('04 Dec 1995 00:12:00 GMT'))\n *\n * Also see [[typeGuard]] and [[typeOf]].\n */\nexport function instanceOf(ctor: new(...args: any[]) => T): TypeGuard {\n // https://github.com/Microsoft/TypeScript/issues/5101#issuecomment-145693151\n return >(x => x instanceof ctor);\n}\n\n/**\n * Curried function returning a type guard telling us if a value\n * is of a specific type.\n * Can be used when filtering to filter for the type and at the\n * same time change the type of the generics on the container.\n *\n * Vector.of(1,\"a\",2,3,\"b\").filter(typeOf(\"number\"))\n * => Vector.of(1,2,3)\n *\n * Option.of(1).filter(typeOf(\"string\"))\n * => Option.none()\n *\n * Option.of(\"str\").filter(typeOf(\"string\"))\n * => Option.of(\"str\")\n *\n * Also see [[instanceOf]] and [[typeGuard]].\n */\nexport function typeOf(typ: \"string\"): TypeGuard;\nexport function typeOf(typ: \"number\"): TypeGuard;\nexport function typeOf(typ: \"boolean\"): TypeGuard;\nexport function typeOf(typ: \"symbol\"): TypeGuard;\nexport function typeOf(typ: string): TypeGuard {\n return ((x:any) => typeof x === typ);\n}\n"
},
{
"path": "src/Contract.ts",
"content": "import { hasTrueEquality } from \"./Comparison\";\nimport { toStringHelper } from \"./SeqHelpers\";\n\nlet preludeTsContractViolationCb = (msg:string):void => { throw new Error(msg); };\n\n/**\n * Some programmatic errors are only detectable at runtime\n * (for instance trying to setup a HashSet of Option<number[]>: you\n * can't reliably compare a number[] therefore you can't compare\n * an Option<number[]>.. but we can't detect this error at compile-time\n * in typescript). So when we detect them at runtime, prelude-ts throws\n * an exception by default.\n * This function allows you to change that default action\n * (for instance, you could display an error message in the console,\n * or log the error)\n *\n * You can reproduce the issue easily by running for instance:\n *\n * HashSet.of(Option.of([1]))\n * => throws\n */\nexport function setContractViolationAction(action: (msg:string)=>void) {\n preludeTsContractViolationCb = action;\n}\n\n/**\n * @hidden\n */\nexport function reportContractViolation(msg: string): void {\n preludeTsContractViolationCb(msg);\n}\n\n/**\n * @hidden\n */\nexport function contractTrueEquality(context: string, ...vals: Array) {\n for (const val of vals) {\n if (val) {\n if (val.hasTrueEquality && (!val.hasTrueEquality())) {\n reportContractViolation(\n context + \": element doesn't support true equality: \" + toStringHelper(val));\n }\n if (!hasTrueEquality(val).getOrThrow()) {\n reportContractViolation(\n context + \": element doesn't support equality: \" + toStringHelper(val));\n }\n // the first element i find is looking good, aborting\n return;\n }\n }\n}\n"
},
{
"path": "src/Either.ts",
"content": "/**\n * The [[Either]] type represents an alternative between two value types.\n * A \"left\" value which is also conceptually tied to a failure,\n * or a \"right\" value which is conceptually tied to success.\n *\n * The code is organized through the class [[Left]], the class [[Right]],\n * and the type alias [[Either]] (Left or Right).\n *\n * Finally, \"static\" functions on Option are arranged in the class\n * [[EitherStatic]] and are accessed through the global constant Either.\n *\n * Examples:\n *\n * Either.right(5);\n * Either.left(2);\n * Either.right(5).map(x => x*2);\n *\n * Left has the extra [[Left.getLeft]] method that [[Right]] doesn't have.\n * Right has the extra [[Right.get]] method that [[Left]] doesn't have.\n */\n\nimport { Value, inspect } from \"./Value\";\nimport { Option } from \"./Option\";\nimport { LinkedList } from \"./LinkedList\";\nimport { Vector } from \"./Vector\";\nimport { WithEquality, areEqual,\n hasTrueEquality, getHashCode } from \"./Comparison\";\nimport { contractTrueEquality} from \"./Contract\";\n\n/**\n * Holds the \"static methods\" for [[Either]]\n */\nexport class EitherStatic {\n /**\n * Constructs an Either containing a left value which you give.\n */\n left(val: L): Either {\n return new Left(val);\n }\n\n /**\n * Constructs an Either containing a right value which you give.\n */\n right(val: R): Either {\n return new Right(val);\n }\n\n /**\n * Curried type guard for Either\n * Sometimes needed also due to https://github.com/Microsoft/TypeScript/issues/20218\n *\n * Vector.of(Either.right(2), Either.left(1))\n * .filter(Either.isLeft)\n * .map(o => o.getLeft())\n * => Vector.of(1)\n */\n isLeft(e: Either): e is Left {\n return e.isLeft();\n }\n\n /**\n * Curried type guard for Either\n * Sometimes needed also due to https://github.com/Microsoft/TypeScript/issues/20218\n *\n * Vector.of(Either.right(2), Either.left(1))\n * .filter(Either.isRight)\n * .map(o => o.get())\n * => Vector.of(2)\n */\n isRight(e: Either): e is Right {\n return e.isRight();\n }\n\n /**\n * Turns a list of eithers in an either containing a list of items.\n * Useful in many contexts.\n *\n * Either.sequence(Vector.of(\n * Either.right(1),\n * Either.right(2)));\n * => Either.right(Vector.of(1,2))\n *\n * But if a single element is Left, everything is discarded:\n *\n * Either.sequence(Vector.of(\n * Either.right(1),\n * Either.left(2),\n * Either.left(3)));\n * => Either.left(2)\n *\n * Also see [[EitherStatic.traverse]]\n */\n sequence(elts:Iterable>): Either> {\n return Either.traverse(elts, x=>x);\n }\n\n /**\n * Takes a list, a function that can transform list elements\n * to eithers, then return an either containing a list of\n * the transformed elements.\n *\n * const getUserById: (x:number)=>Either = x => x > 0 ?\n * Either.right(\"user\" + x.toString()) : Either.left(\"invalid id!\");\n * Either.traverse([4, 3, 2], getUserById);\n * => Either.right(Vector.of(\"user4\", \"user3\", \"user2\"))\n *\n * But if a single element results in Left, everything is discarded:\n *\n * const getUserById: (x:number)=>Either = x => x > 0 ?\n * Either.right(\"user\" + x.toString()) : Either.left(\"invalid id!\");\n * Either.traverse([4, -3, 2], getUserById);\n * => Either.left(\"invalid id!\")\n *\n * Also see [[EitherStatic.sequence]]\n */\n traverse(elts:Iterable, fn: (x:T)=>Either): Either> {\n let r = Vector.empty();\n const iterator = elts[Symbol.iterator]();\n let curItem = iterator.next();\n while (!curItem.done) {\n const v = fn(curItem.value);\n if (v.isLeft()) {\n return v;\n }\n r = r.append(v.get());\n curItem = iterator.next();\n }\n return Either.right>(r);\n }\n\n /**\n * Turns a list of eithers in an either containing a list of items.\n * Compared to [[EitherStatic.sequence]], sequenceAcc 'accumulates'\n * the errors, instead of short-circuiting on the first error.\n *\n * Either.sequenceAcc(Vector.of(\n * Either.right(1),\n * Either.right(2)));\n * => Either.right(Vector.of(1,2))\n *\n * But if a single element is Left, you get all the lefts:\n *\n * Either.sequenceAcc(Vector.of(\n * Either.right(1),\n * Either.left(2),\n * Either.left(3)));\n * => Either.left(Vector.of(2,3))\n */\n sequenceAcc(elts:Iterable>): Either,Vector> {\n const [lefts,rights] = Vector.ofIterable(elts).partition(Either.isLeft);\n if (lefts.isEmpty()) {\n return Either.right,Vector>(rights.map(r => r.getOrThrow()));\n }\n return Either.left,Vector>(lefts.map(l => l.getLeft()));\n }\n\n /**\n * Applicative lifting for Either.\n * Takes a function which operates on basic values, and turns it\n * in a function that operates on eithers of these values ('lifts'\n * the function). The 2 is because it works on functions taking two\n * parameters.\n *\n * const lifted = Either.liftA2(\n * (x:number,y:number) => x+y, {} as string);\n * lifted(\n * Either.right(5),\n * Either.right(6));\n * => Either.right(11)\n *\n * const lifted = Either.liftA2(\n * (x:number,y:number) => x+y, {} as string);\n * lifted(\n * Either.right(5),\n * Either.left(\"bad\"));\n * => Either.left(\"bad\")\n *\n * @param R1 the first right type\n * @param R2 the second right type\n * @param L the left type\n * @param V the new right type as returned by the combining function.\n */\n liftA2(fn:(v1:R1,v2:R2)=>V, leftWitness?: L) : (p1:Either, p2:Either) => Either {\n return (p1,p2) => p1.flatMap(a1 => p2.map(a2 => fn(a1,a2)));\n }\n\n /**\n * Applicative lifting for Either. 'p' stands for 'properties'.\n *\n * Takes a function which operates on a simple JS object, and turns it\n * in a function that operates on the same JS object type except which each field\n * wrapped in an Either ('lifts' the function).\n * It's an alternative to [[EitherStatic.liftA2]] when the number of parameters\n * is not two.\n *\n * const fn = (x:{a:number,b:number,c:number}) => x.a+x.b+x.c;\n * const lifted = Either.liftAp(fn, {} as number);\n * lifted({\n * a: Either.right(5),\n * b: Either.right(6),\n * c: Either.right(3)});\n * => Either.right(14)\n *\n * const lifted = Either.liftAp(\n * x => x.a+x.b);\n * lifted({\n * a: Either.right(5),\n * b: Either.left(2)});\n * => Either.left(2)\n *\n * @param L the left type\n * @param A the object property type specifying the parameters for your function\n * @param B the type returned by your function, returned wrapped in an either by liftAp.\n */\n liftAp(fn:(x:A)=>B, leftWitness?: L): (x: {[K in keyof A]: Either;}) => Either {\n return x => {\n const copy:A = {};\n for (let p in x) {\n if (x[p].isLeft()) {\n return >x[p];\n }\n copy[p] = x[p].getOrThrow();\n }\n return Either.right(fn(copy));\n }\n }\n\n /**\n * Applicative lifting for Either. 'p' stands for 'properties'.\n * Compared to [[EitherStatic.liftAp]], liftApAcc 'accumulates'\n * the errors, instead of short-circuiting on the first error.\n *\n * Takes a function which operates on a simple JS object, and turns it\n * in a function that operates on the same JS object type except which each field\n * wrapped in an Either ('lifts' the function).\n * It's an alternative to [[EitherStatic.liftA2]] when the number of parameters\n * is not two.\n *\n * const fn = (x:{a:number,b:number,c:number}) => x.a+x.b+x.c;\n * const lifted = Either.liftApAcc(fn, {} as number);\n * lifted({\n * a: Either.right(5),\n * b: Either.right(6),\n * c:Either.right(3)});\n * => Either.right(14)\n *\n * const fn = (x:{a:number,b:number,c:number}) => x.a+x.b+x.c;\n * const lifted = Either.liftApAcc(fn, {} as number);\n * lifted({\n * a: Either.right(5),\n * b: Either.left(2),\n * c: Either.left(6)});\n * => Either.left(Vector.of(2, 6))\n *\n * @param L the left type\n * @param A the object property type specifying the parameters for your function\n * @param B the type returned by your function, returned wrapped in an either by liftAp.\n */\n liftApAcc(fn:(x:A)=>B, leftWitness?: L): (x: {[K in keyof A]: Either;}) => Either,B> {\n const leftErrs: L[] = [];\n return x => {\n const copy:A = {};\n for (let p in x) {\n const field = x[p];\n if (field.isLeft()) {\n leftErrs.push(field.getLeft());\n } else {\n copy[p] = x[p].getOrThrow();\n }\n }\n if (leftErrs.length === 0) {\n return Either.right,B>(fn(copy));\n } else {\n return Either.left,B>(Vector.ofIterable(leftErrs));\n }\n }\n }\n\n /**\n * Take a partial function (may return undefined or throw),\n * and lift it to return an [[Either]] instead.\n *\n * Note that unlike the [[OptionStatic.lift]] version, if\n * the function returns undefined, the Either.lift version will throw\n * (the Option.lift version returns None()): if you want to do\n * pure side-effects which may throw, you're better off just using\n * javascript try blocks.\n *\n * When using typescript, to help the compiler infer the left type,\n * you can either pass a second parameter like `{} as `, or\n * call with `lift(...)`.\n *\n * const add = Either.lift((x:number,y:number) => x+y, {} as string);\n * add(1,2);\n * => Either.right(3)\n *\n * const undef = Either.lift((x:number,y:number,z:number) => undefined);\n * undef(1,2,3);\n * => throws\n *\n * const throws = Either.lift(() => {throw \"x\"});\n * throws();\n * => Either.left(\"x\")\n */\n lift(fn: (...args: T)=>U, witness?: L): (...args:T)=>Either {\n return (...args:T) => {\n try {\n const r = fn(...args);\n if (r !== undefined) {\n return Either.right(r);\n }\n } catch (err) {\n return Either.left(err);\n }\n throw new Error(\"liftEither got undefined!\");\n };\n }\n\n /**\n * Take a no-parameter partial function (may return undefined or throw),\n * call it, and return an [[Either]] instead.\n *\n * Note that unlike the [[OptionStatic.try_]] version, if\n * the function returns undefined, this function will throw\n * (the Option.try_ version returns None()): if you want to do\n * pure side-effects which may throw, you're better off just using\n * javascript try blocks.\n *\n * When using typescript, to help the compiler infer the left type,\n * you can either pass a second parameter like `{} as `, or\n * call with `try_(...)`.\n *\n * Either.try_(Math.random, {} as string);\n * => Either.right(0.49884723907769635)\n *\n * Either.try_(() => undefined);\n * => throws\n *\n * Either.try_(() => {throw \"x\"});\n * => Either.left(\"x\")\n *\n * Also see [[EitherStatic.lift]], [[OptionStatic.try_]],\n * [[OptionStatic.tryNullable]]\n */\n try_(fn:()=>T, witness?: L): Either {\n return Either.lift<[],L,T>(fn)();\n }\n}\n\n/**\n * The Either constant allows to call the either \"static\" methods\n */\nexport const Either = new EitherStatic();\n\n/**\n * Either represents an alternative between two value types.\n * A \"left\" value which is also conceptually tied to a failure,\n * or a \"right\" value which is conceptually tied to success.\n * \"static methods\" available through [[EitherStatic]]\n */\nexport type Either = Left | Right;\n\n/**\n * Represents an [[Either]] containing a left value,\n * conceptually tied to a failure.\n * \"static methods\" available through [[EitherStatic]]\n * @param L the \"left\" item type 'failure'\n * @param R the \"right\" item type 'success'\n */\nexport class Left implements Value {\n constructor(private value: L) {}\n\n /**\n * @hidden\n */\n readonly className: \"Left\" = undefined; // https://stackoverflow.com/a/47841595/516188\n\n /**\n * Returns true since this is a Left\n */\n isLeft(): this is Left {\n return true;\n }\n\n /**\n * Returns false since this is a Left\n */\n isRight(): this is Right {\n return false;\n }\n\n /**\n * Returns true if this is either is a right and contains the value you give.\n */\n contains(val: R&WithEquality): boolean {\n return false;\n }\n\n /**\n * If this either is a right, applies the function you give\n * to its contents and build a new right either, otherwise return this.\n */\n map(fn: (x:R)=>U): Either {\n return this;\n }\n\n /**\n * If this either is a right, call the function you give with\n * the contents, and return what the function returns, else\n * returns this.\n * This is the monadic bind.\n */\n flatMap(fn: (x:R)=>Either): Either {\n return this;\n }\n\n /**\n * If this either is a left, call the function you give with\n * the left value and return a new either left with the result\n * of the function, else return this.\n */\n mapLeft(fn: (x:L)=>U): Either {\n return new Left(fn(this.value));\n }\n\n /**\n * Map the either: you give a function to apply to the value,\n * a function in case it's a left, a function in case it's a right.\n */\n bimap(fnL: (x:L)=>S,fnR: (x:R)=>T): Either {\n return new Left(fnL(this.value));\n }\n\n /**\n * \"filter\" the either. If it was a Left, it stays a Left.\n * If it was a Right and the predicate you pass returns\n * true for its value, return the either unchanged.\n * But if it was a left and the predicate returns false,\n * return a Left with the value returned by the function\n * passed as second parameter.\n *\n * Either.right(-3)\n * .filter(x => x >= 0, v => \"got negative value: \" + v);\n * => Either.left(\"got negative value: -3\")\n */\n filter(p: (x:R)=>boolean, filterVal: (x:R)=>L): Either {\n return this;\n }\n\n /**\n * Combines two eithers. If this either is a right, returns it.\n * If it's a left, returns the other one.\n */\n orElse(other: Either): Either {\n return other;\n }\n\n /**\n * Has no effect if this Either is a right. If it's a left however,\n * the function you give will be called, receiving as parameter\n * the left contents, and an Either equivalent to the one your\n * function returns will be returned.\n */\n recoverWith(recoveryFn: (left:L)=>Either): Either {\n return recoveryFn(this.value);\n }\n\n /**\n * Execute a side-effecting function if the either\n * is a right; returns the either.\n */\n ifRight(fn: (x:R)=>void): Either {\n return this;\n }\n\n /**\n * Execute a side-effecting function if the either\n * is a left; returns the either.\n */\n ifLeft(fn: (x:L)=>void): Either {\n fn(this.value);\n return this;\n }\n\n /**\n * Handle both branches of the either and return a value\n * (can also be used for side-effects).\n * This is the catamorphism for either.\n *\n * Either.right(5).match({\n * Left: x => \"left \" + x,\n * Right: x => \"right \" + x\n * });\n * => \"right 5\"\n */\n match(cases: {Left: (v:L)=>U, Right: (v:R)=>U}): U {\n return cases.Left(this.value);\n }\n\n /**\n * If this either is a right, return its value, else throw\n * an exception.\n * You can optionally pass a message that'll be used as the\n * exception message, or an Error object.\n */\n getOrThrow(errorInfo?: Error|string): R {\n if (typeof errorInfo === 'string') {\n throw new Error(errorInfo || \"Left.getOrThrow called!\");\n }\n throw errorInfo || new Error(\"Left.getOrThrow called!\");\n }\n\n /**\n * If this either is a right, return its value, else return\n * the value you give.\n */\n getOrElse(other: R): R {\n return other;\n }\n\n /**\n * Get the value contained in this left.\n * NOTE: we know it's there, since this method\n * belongs to Left, not Either.\n */\n getLeft(): L {\n return this.value;\n }\n\n /**\n * If this either is a left, return its value, else throw\n * an exception.\n * You can optionally pass a message that'll be used as the\n * exception message.\n */\n getLeftOrThrow(message?: string): L {\n return this.value;\n }\n\n /**\n * If this either is a left, return its value, else return\n * the value you give.\n */\n getLeftOrElse(other: L): L {\n return this.value;\n }\n\n /**\n * Convert this either to an option, conceptually dropping\n * the left (failing) value.\n */\n toOption(): Option {\n return Option.none();\n }\n\n /**\n * Convert to a vector. If it's a left, it's the empty\n * vector, if it's a right, it's a one-element vector with\n * the contents of the either.\n */\n toVector(): Vector {\n return Vector.empty();\n }\n\n /**\n * Convert to a list. If it's a left, it's the empty\n * list, if it's a right, it's a one-element list with\n * the contents of the either.\n */\n toLinkedList(): LinkedList {\n return LinkedList.empty();\n }\n\n /**\n * Transform this value to another value type.\n * Enables fluent-style programming by chaining calls.\n */\n transform(converter:(x:Either)=>U): U {\n return converter(this);\n }\n\n hasTrueEquality(): boolean {\n return (this.value && (this.value).hasTrueEquality) ?\n (this.value).hasTrueEquality() :\n hasTrueEquality(this.value);\n }\n\n /**\n * Get a number for that object. Two different values\n * may get the same number, but one value must always get\n * the same number. The formula can impact performance.\n */\n hashCode(): number {\n return getHashCode(this.value);\n }\n\n /**\n * Two objects are equal if they represent the same value,\n * regardless of whether they are the same object physically\n * in memory.\n */\n equals(other: Either): boolean {\n if (other === this) {\n return true;\n }\n if ((!other) || (!other.isRight) || other.isRight()) {\n return false;\n }\n const leftOther = >other;\n contractTrueEquality(\"Either.equals\", this, leftOther);\n return areEqual(this.value, leftOther.value);\n }\n\n /**\n * Get a human-friendly string representation of that value.\n */\n toString(): string {\n return \"Left(\" + this.value + \")\";\n }\n\n /**\n * Used by the node REPL to display values.\n */\n [inspect](): string {\n return this.toString();\n }\n}\n\n/**\n * Represents an [[Either]] containing a success value,\n * conceptually tied to a success.\n * \"static methods\" available through [[EitherStatic]]\n * @param L the \"left\" item type 'failure'\n * @param R the \"right\" item type 'success'\n */\nexport class Right implements Value {\n constructor(private value: R) {}\n\n /**\n * @hidden\n */\n readonly className: \"Right\" = undefined; // https://stackoverflow.com/a/47841595/516188\n\n /**\n * Returns false since this is a Right\n */\n isLeft(): this is Left {\n return false;\n }\n\n /**\n * Returns true since this is a Right\n */\n isRight(): this is Right {\n return true;\n }\n\n /**\n * Returns true if this is either is a right and contains the value you give.\n */\n contains(val: R&WithEquality): boolean {\n return areEqual(this.value, val);\n }\n\n /**\n * If this either is a right, applies the function you give\n * to its contents and build a new right either, otherwise return this.\n */\n map(fn: (x:R)=>U): Either {\n return new Right(fn(this.value));\n }\n\n /**\n * If this either is a right, call the function you give with\n * the contents, and return what the function returns, else\n * returns this.\n * This is the monadic bind.\n */\n flatMap(fn: (x:R)=>Either): Either {\n return fn(this.value);\n }\n\n /**\n * If this either is a left, call the function you give with\n * the left value and return a new either left with the result\n * of the function, else return this.\n */\n mapLeft(fn: (x:L)=>U): Either {\n return this;\n }\n\n /**\n * Map the either: you give a function to apply to the value,\n * a function in case it's a left, a function in case it's a right.\n */\n bimap