functionalscript 0.0.475 → 0.0.477

package/com/README.md

@@ -1,3 +1,3 @@
 # COM (Component Object Model)
 
-Basic Types: `f32`, `f64`, `u8`, `i8`, `u16`, `i16`, `u32`, `i32`, `u64`, `i64`, `usize`, `isize`, `bool`, ``.
+Basic Types: `f32`, `f64`, `u8`, `i8`, `u16`, `i16`, `u32`, `i32`, `u64`, `i64`, `usize`, `isize`, `bool`, ``.

package/com/proposals.md

@@ -0,0 +1,28 @@
+# Proposals For NanoCOM
+
+## Pointer Types
+
+- By ownership
+  - direct reference/pointer. `&I`
+  - cloneable wrapper. For example, `ref<I>`.
+- By nullability
+  - non-nullable, a reference. For example, `ref<I>`.
+  - nullable, a pointer. For example, `ptr<I>`.
+- By mutability
+  - immutable. Multithreaded, with an atomic counter. The object can be mutable with synchronization mechanisms.
+  - mutable. Single-threaded. With a simple counter and mutable.
+- By value
+  - interface. All functions are virtual. For example add_ref/release
+  - implementation. Functions can be called directly, including add_ref/release.
+  ```rust
+  trait IUnknown {
+    fn add_ref(self);
+    fn release(self);
+    fn query_interface<I>(self) -> ptr<I>;
+  }
+  // examples
+  impl IUnknown for &IImmutableInterface { ... }
+  impl IUnknown for &mut IMutableInterface { ... }
+  impl IUnknown for &IImmutableInterfaceImplementation { ... }
+  impl IUnknown for &mut IMutableInterfaceImplementation { ... }
+  ```

package/fsc/module.f.cjs

@@ -0,0 +1,4 @@
+const ascii = require('../text/ascii/module.f.cjs')
+
+module.exports = {
+}

package/fsc/test.f.cjs

@@ -0,0 +1,6 @@
+const _ = require('./module.f.cjs')
+
+module.exports = {
+    a: () => {
+    }
+}

package/fsm/module.f.cjs

@@ -85,11 +85,10 @@ const initialStateStringify = stringifyIdentity(initialState)
 /** @type {(grammar: Grammar) => Dfa} */
 const dfa = grammar => addEntry(grammar)(initialState)({})
 
+const get = rangeMap.get(emptyStateStringify)
+
 /** @type {(dfa: Dfa) => operator.Fold<number, string>} */
-const runOp = dfa => input => s => {
-    const state = rangeMap.get(input)(dfa[s])
-    return state === undefined ? emptyStateStringify : state
-}
+const runOp = dfa => input => s => get(input)(dfa[s])
 
 /** @type {(dfa: Dfa) => (input: list.List<number>) => list.List<string>} */
 const run = dfa => input => foldScan(runOp(dfa))(initialStateStringify)(input)

package/html/README.md

@@ -0,0 +1,7 @@
+# HTML
+
+|HTML                                        |FunctionalScript DSL                             |
+|--------------------------------------------|-------------------------------------------------|
+|`<br>`                                      |`['br']`                                         |
+|`<img src="https://example.com/image.jpg">` |`['img',{src:'https://example.com/image.jpg'}]`  |
+|`<a href="https://example.com/">Example</a>`|`['a',{href:'https://example.com/'},['Example']]`|

package/json/html/README.md

@@ -0,0 +1,49 @@
+# JSON to HTML
+
+```json
+{
+    "a": 34.5,
+    "b": true,
+    "c": [null]
+}
+```
+
+```js
+['pre',
+    [
+        '\n',
+        ['span',{class:'symbol'},['{']],
+        '\n    ',
+        ['span',{class:'string'},['"a"']],
+        ['span',{class:'symbol'},[':']],
+        ' ',
+        ['span',{class:'number'},['34.5']],
+        ['span',{class:'symbol'},[',']],
+        '\n    ',
+        ['span',{class:'string'},['"b"']],
+        ['span',{class:'symbol'},[':']],
+        ' ',
+        ['span',{class:'bool'},['true']],
+        ['span',{class:'symbol'},[',']],
+        '\n    ',
+        ['span',{class:'string'},['"c"']],
+        ['span',{class:'symbol'},[':']],
+        ' ',
+        ['span',{class:'symbol'},['[']],
+        ['span',{class:'null'},['null']],
+        ['span',{class:'symbol'},[']']],
+        '\n    ',
+        ['span',{class:'symbol'},['}']],
+        '\n'
+    ]
+]
+```
+
+```html
+<pre>
+<span class="symbol">{</span>
+    <span class="string">"a"<span><span class="symbol">:</span> <span class="number">34.5</span><span class="symbol">,<span>
+    <span class="string">"b"<span><span class="symbol">:</span> <span class="bool">true</span><span class="symbol">,<span>
+    <span class="string">"c"<span><span class="symbol">:</span> <span class="symbol">[</span><span class="null">null</span><span class="symbol">]</span>
+</pre>
+```

package/json/tokenizer/module.f.cjs

@@ -1,9 +1,49 @@
 const operator = require('../../types/function/operator/module.f.cjs')
 const list = require('../../types/list/module.f.cjs')
-const range = require('../../types/range/module.f.cjs')
-const { stateScan, flat, concat } = list
-const { contains } = range
+const { contains } = require('../../types/range/module.f.cjs')
+const { stateScan, flat } = list
 const { fromCharCode } = String
+const {
+    range,
+    //
+    backspace,
+    ht,
+    lf,
+    ff,
+    cr,
+    //
+    space,
+    quotationMark,
+    plusSign,
+    comma,
+    hyphenMinus,
+    fullStop,
+    solidus,
+    //
+    digitRange,
+    digit0,
+    colon,
+    //
+    latinCapitalLetterA,
+    latinCapitalLetterE,
+    //
+    leftSquareBracket,
+    reverseSolidus,
+    rightSquareBracket,
+    //
+    latinSmallLetterRange,
+    latinSmallLetterA,
+    latinSmallLetterB,
+    latinSmallLetterE,
+    latinSmallLetterF,
+    latinSmallLetterN,
+    latinSmallLetterR,
+    latinSmallLetterT,
+    latinSmallLetterU,
+    //
+    leftCurlyBracket,
+    rightCurlyBracket
+} = require('../../text/ascii/module.f.cjs')
 
 /**
  * @typedef {{
@@ -32,50 +72,11 @@ const { fromCharCode } = String
  * } JsonToken
  */
 
-const leftBrace = 0x7b
-const rightBrace = 0x7d
-const colon = 0x3a
-const comma = 0x2c
-const leftBracket = 0x5b
-const rightBracket = 0x5d
-
-const quotationMark = 0x22
-const digit0 = 0x30
-const digit1 = 0x31
-const digit9 = 0x39
-const signPlus = 0x2b
-const signMinus = 0x2d
-const decimalPoint = 0x2e
-
-const horizontalTab = 0x09
-const newLine = 0x0a
-const carriageReturn = 0x0d
-const space = 0x20
-
-const backslash = 0x5c
-const slash = 0x2f
-const backspace = 0x08
-const formfeed = 0x0c
-
-const capitalLetterA = 0x41
-const capitalLetterE = 0x45
-const capitalLetterF = 0x46
-
-const letterA = 0x61
-const letterB = 0x62
-const letterE = 0x65
-const letterF = 0x66
-const letterN = 0x6e
-const letterR = 0x72
-const letterT = 0x74
-const letterU = 0x75
-const letterZ = 0x7a
-
-const containsDigit = contains([digit0, digit9])
-const containsDigitOneNine = contains([digit1, digit9])
-const containsSmallAF = contains([letterA, letterF])
-const containsCapitalAF = contains([capitalLetterA, capitalLetterF])
-const containsSmallLetter = contains([letterA, letterZ])
+const containsDigit = contains(digitRange)
+const containsDigitOneNine = contains(range('19'))
+const containsSmallAF = contains(range('af'))
+const containsCapitalAF = contains(range('AF'))
+const containsSmallLetter = contains(latinSmallLetterRange)
 
 /**
  * @typedef {|
@@ -141,22 +142,22 @@ const initialStateOp = initialState => input => {
         return [undefined, initialState]
     }
     switch (input) {
-        case leftBrace: return [[{ kind: '{' }], initialState]
-        case rightBrace: return [[{ kind: '}' }], initialState]
+        case leftCurlyBracket: return [[{ kind: '{' }], initialState]
+        case rightCurlyBracket: return [[{ kind: '}' }], initialState]
         case colon: return [[{ kind: ':' }], initialState]
         case comma: return [[{ kind: ',' }], initialState]
-        case leftBracket: return [[{ kind: '[' }], initialState]
-        case rightBracket: return [[{ kind: ']' }], initialState]
+        case leftSquareBracket: return [[{ kind: '[' }], initialState]
+        case rightSquareBracket: return [[{ kind: ']' }], initialState]
         case quotationMark: return [undefined, { kind: 'string', value: '' }]
         case digit0: return [undefined, { kind: 'number', value: fromCharCode(input), numberKind: '0' }]
-        case signMinus: return [undefined, { kind: 'number', value: fromCharCode(input), numberKind: '-' }]
+        case hyphenMinus: return [undefined, { kind: 'number', value: fromCharCode(input), numberKind: '-' }]
         default: return [[{ kind: 'error', message: 'unexpected character' }], initialState]
     }
 }
 
 /** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
 const parseNumberStateOp = state => input => {
-    if (input === decimalPoint) {
+    if (input === fullStop) {
         switch (state.numberKind) {
             case '0':
             case 'int': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: '.' }]
@@ -185,7 +186,7 @@ const parseNumberStateOp = state => input => {
             default: return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: state.numberKind }]
         }
     }
-    if (input === letterE || input === capitalLetterE) {
+    if (input === latinSmallLetterE || input === latinCapitalLetterE) {
         switch (state.numberKind) {
             case '0':
             case 'int':
@@ -193,13 +194,13 @@ const parseNumberStateOp = state => input => {
             default: return tokenizeOp({ kind: 'invalidNumber' })(input)
         }
     }
-    if (input === signMinus) {
+    if (input === hyphenMinus) {
         switch (state.numberKind) {
             case 'e': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e-' }]
             default: return tokenizeOp({ kind: 'invalidNumber' })(input)
         }
     }
-    if (input === signPlus) {
+    if (input === plusSign) {
         switch (state.numberKind) {
             case 'e': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e+' }]
             default: return tokenizeOp({ kind: 'invalidNumber' })(input)
@@ -234,10 +235,10 @@ const isTerminalForNumber = char => {
     switch (char) {
         case quotationMark:
         case comma:
-        case leftBrace:
-        case rightBrace:
-        case leftBracket:
-        case rightBracket:
+        case leftCurlyBracket:
+        case rightCurlyBracket:
+        case leftSquareBracket:
+        case rightSquareBracket:
         case colon: return true
         default: return false
     }
@@ -246,16 +247,16 @@ const isTerminalForNumber = char => {
 /** @type {(char: number) => boolean} */
 const isWhiteSpace = char => {
     switch (char) {
-        case horizontalTab:
-        case newLine:
-        case carriageReturn:
+        case ht:
+        case lf:
+        case cr:
         case space: return true
         default: return false
     }
 }
 
 /** @type {(state: InvalidNumberState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const invalidNumberStateOp = state => input => {
+const invalidNumberStateOp = () => input => {
     if (isTerminalForNumber(input)) {
         const next = tokenizeOp({ kind: 'initial' })(input)
         return [{ first: { kind: 'error', message: 'invalid number' }, tail: next[0] }, next[1]]
@@ -267,7 +268,7 @@ const invalidNumberStateOp = state => input => {
 const parseStringStateOp = state => input => {
     switch (input) {
         case quotationMark: return [[{ kind: 'string', value: state.value }], { kind: 'initial' }]
-        case backslash: return [undefined, { kind: 'escapeChar', value: state.value }]
+        case reverseSolidus: return [undefined, { kind: 'escapeChar', value: state.value }]
         default: return [undefined, { kind: 'string', value: appendChar(state.value)(input) }]
     }
 }
@@ -276,14 +277,14 @@ const parseStringStateOp = state => input => {
 const parseEscapeCharStateOp = state => input => {
     switch (input) {
         case quotationMark:
-        case backslash:
-        case slash: return [undefined, { kind: 'string', value: appendChar(state.value)(input) }]
-        case letterB: return [undefined, { kind: 'string', value: appendChar(state.value)(backspace) }]
-        case letterF: return [undefined, { kind: 'string', value: appendChar(state.value)(formfeed) }]
-        case letterN: return [undefined, { kind: 'string', value: appendChar(state.value)(newLine) }]
-        case letterR: return [undefined, { kind: 'string', value: appendChar(state.value)(carriageReturn) }]
-        case letterT: return [undefined, { kind: 'string', value: appendChar(state.value)(horizontalTab) }]
-        case letterU: return [undefined, { kind: 'unicodeChar', value: state.value, unicode: 0, hexIndex: 0 }]
+        case reverseSolidus:
+        case solidus: return [undefined, { kind: 'string', value: appendChar(state.value)(input) }]
+        case latinSmallLetterB: return [undefined, { kind: 'string', value: appendChar(state.value)(backspace) }]
+        case latinSmallLetterF: return [undefined, { kind: 'string', value: appendChar(state.value)(ff) }]
+        case latinSmallLetterN: return [undefined, { kind: 'string', value: appendChar(state.value)(lf) }]
+        case latinSmallLetterR: return [undefined, { kind: 'string', value: appendChar(state.value)(cr) }]
+        case latinSmallLetterT: return [undefined, { kind: 'string', value: appendChar(state.value)(ht) }]
+        case latinSmallLetterU: return [undefined, { kind: 'unicodeChar', value: state.value, unicode: 0, hexIndex: 0 }]
         default: {
             const next = tokenizeOp({ kind: 'string', value: state.value })(input)
             return [{ first: { kind: 'error', message: 'unescaped character' }, tail: next[0] }, next[1]]
@@ -294,8 +295,8 @@ const parseEscapeCharStateOp = state => input => {
 /** @type {(hex: number) => number|undefined} */
 const hexDigitToNumber = hex => {
     if (containsDigit(hex)) { return hex - digit0 }
-    if (containsCapitalAF(hex)) { return hex - capitalLetterA + 10 }
-    if (containsSmallAF(hex)) { return hex - letterA + 10 }
+    if (containsCapitalAF(hex)) { return hex - latinCapitalLetterA + 10 }
+    if (containsSmallAF(hex)) { return hex - latinSmallLetterA + 10 }
 }
 
 /** @type {(state: ParseUnicodeCharState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.475",
+  "version": "0.0.477",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {

package/text/ascii/module.f.cjs

@@ -0,0 +1,222 @@
+const _range = require('../../types/range/module.f.cjs')
+
+/** @type {(s: string) => (i: number) => number} */
+const at = s => i => {
+    const r = s.codePointAt(i)
+    if (r === undefined) { throw s }
+    return r
+}
+
+/** @type {(s: string) => number} */
+const one = s => at(s)(0)
+
+/** @type {(s: string) => _range.Range} */
+const range = s => {
+    const f = at(s)
+    return [f(0), f(1)]
+}
+
+module.exports = {
+    /** @readonly */
+    one,
+    /** @readonly */
+    range,
+
+    // 0x00..
+
+    /** @readonly 0x08 */
+    backspace: one('\b'),
+
+    /** @readonly 0x09 */
+    ht: one('\t'),
+
+    /** @readonly 0x0A */
+    lf: one('\n'),
+
+    /** @readonly 0x0C */
+    ff: one('\f'),
+    /** @readonly 0x0D */
+    cr: one('\r'),
+
+    // 0x20..
+
+    /** @readonly 0x20 */
+    space: one(' '),
+
+    /** @readonly 0x21 */
+    exclamationMark: one('!'),
+
+    /** @readonly 0x22 */
+    quotationMark: one('"'),
+
+    /** @readonly 0x23 */
+    numberSign: one('#'),
+
+    /** @readonly 0x24 */
+    dollarSign: one('$'),
+
+    /** @readonly 0x25 */
+    percentSign: one('%'),
+
+    /** @readonly 0x26 */
+    ampersand: one('&'),
+
+    /** @readonly 0x27 */
+    apostrophe: one("'"),
+
+    /** @readonly 0x28 */
+    leftParenthesis: one('('),
+
+    /** @readonly 0x29 */
+    rightParenthesis: one(')'),
+
+    /** @readonly 0x2A */
+    asterisk: one('*'),
+
+    /** @readonly 0x2B */
+    plusSign: one('+'),
+
+    /** @readonly 0x2C */
+    comma: one(','),
+
+    /** @readonly 0x2D */
+    hyphenMinus: one('-'),
+
+    /** @readonly 0x2E */
+    fullStop: one('.'),
+
+    /** @readonly 0x2F */
+    solidus: one('/'),
+
+    // 0x30..
+
+    /** @readonly 0x30..0x39 */
+    digitRange: range('09'),
+
+    /** @readonly 0x30 */
+    digit0: one('0'),
+
+    /** @readonly 0x31 */
+    digit1: one('1'),
+
+    /** @readonly 0x32 */
+    digit2: one('2'),
+
+    /** @readonly 0x33 */
+    digit3: one('3'),
+
+    /** @readonly 0x34 */
+    digit4: one('4'),
+
+    /** @readonly 0x35 */
+    digit5: one('5'),
+
+    /** @readonly 0x36 */
+    digit6: one('6'),
+
+    /** @readonly 0x37 */
+    digit7: one('7'),
+
+    /** @readonly 0x38 */
+    digit8: one('8'),
+
+    /** @readonly 0x39 */
+    digit9: one('9'),
+
+    /** @readonly 0x3A */
+    colon: one(':'),
+
+    /** @readonly 0x3B */
+    semicolon: one(';'),
+
+    /** @readonly 0x3C */
+    lessThanSign: one('<'),
+
+    /** @readonly 0x3D */
+    equalsSign: one('='),
+
+    /** @readonly 0x3E */
+    greaterThanSign: one('>'),
+
+    /** @readonly 0x3F */
+    questionMark: one('?'),
+
+    // 0x40..
+
+    /** @readonly 0x40 */
+    commercialAt: one('@'),
+
+    /** @readonly 0x41..0x5A */
+    latinCapitalLetterRange: range('AZ'),
+
+    /** @readonly 0x41 */
+    latinCapitalLetterA: one('A'),
+
+    /** @readonly 0x45 */
+    latinCapitalLetterE: one('E'),
+
+    /** @readonly 0x46 */
+    latinCapitalLetterF: one('F'),
+
+    /** @readonly 0x5B */
+    leftSquareBracket: one('['),
+
+    /** @readonly 0x5C */
+    reverseSolidus: one('\\'),
+
+    /** @readonly 0x5D */
+    rightSquareBracket: one(']'),
+
+    /** @readonly 0x5E */
+    circumflexAccent: one('^'),
+
+    /** @readonly 0x5F */
+    lowLine: one('_'),
+
+    // 0x60..
+
+    /** @readonly 0x60 */
+    graveAccent: one('`'),
+
+    /** @readonly 0x61..0x7A */
+    latinSmallLetterRange: range('az'),
+
+    /** @readonly 0x61 */
+    latinSmallLetterA: one('a'),
+
+    /** @readonly 0x62 */
+    latinSmallLetterB: one('b'),
+
+    /** @readonly 0x65 */
+    latinSmallLetterE: one('e'),
+
+    /** @readonly 0x66 */
+    latinSmallLetterF: one('f'),
+
+    /** @readonly 0x6E */
+    latinSmallLetterN: one('n'),
+
+    /** @readonly 0x72 */
+    latinSmallLetterR: one('r'),
+
+    /** @readonly 0x74 */
+    latinSmallLetterT: one('t'),
+
+    /** @readonly 0x75 */
+    latinSmallLetterU: one('u'),
+
+    /** @readonly 0x7A */
+    latinSmallLetterZ: one('z'),
+
+    /** @readonly 0x7B */
+    leftCurlyBracket: one('{'),
+
+    /** @readonly 0x7C */
+    verticalLine: one('|'),
+
+    /** @readonly 0x7D */
+    rightCurlyBracket: one('}'),
+
+    /** @readonly 0x7E */
+    tilde: one('~'),
+}

package/types/range_map/module.f.cjs

@@ -5,6 +5,7 @@ const { next } = list
 const option = require("../option/module.f.cjs")
 const { cmp } = require('../number/module.f.cjs')
 const operator = require("../function/operator/module.f.cjs")
+const _range = require('../range/module.f.cjs')
 
 /**
  * @template T
@@ -60,32 +61,31 @@ const tailReduce = equal => state => tail => {
  /** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
 const merge = ({union, equal}) => genericMerge({reduceOp: reduceOp(union)(equal), tailReduce: tailReduce(equal)})(undefined)
 
-/** @type {<T>(value: number) => (rm: RangeMapArray<T>) =>  T|undefined} */
-const get = value => rm => {
+/** @type {<T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T} */
+const get = def => value => rm => {
+  const len = rm.length
   let b = 0
-  let e = rm.length - 1
+  let e = len - 1
   while (true) {
-    if (b >= rm.length) return undefined
-    if (e - b < 0) return rm[b][0]
+    if (b >= len) { return def }
+    if (e - b < 0) { return rm[b][0] }
     const mid = b + (e - b >> 1)
-    const sign = cmp(value)(rm[mid][1])
-    switch(sign) {
-      case -1: {
-        e = mid - 1
-        break
-      }
-      case 0: { return rm[mid][0] }
-      case 1: {
-        b = mid + 1
-        break
-      }
+    if (value <= rm[mid][1]) {
+      e = mid - 1
+    } else {
+      b = mid + 1
     }
   }
 }
 
+/** @type {<T>(def: T) => (r: _range.Range) => (value: T) => RangeMapArray<T>} */
+const fromRange = def => ([a, b]) => v => [[def, a - 1], [v, b]]
+
 module.exports = {
     /** @readonly */
     merge,
     /** @readonly */
-    get
+    get,
+    /** @readonly */
+    fromRange,
 }

package/types/range_map/test.f.cjs

@@ -78,54 +78,85 @@ module.exports = {
             if (result !== '[[["a"],1],[["a","b"],2],[["a"],5]]') { throw result }
         }
     ],
-    get: [
-        () => {
-            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-            const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
-            const result = stringify(_.get(5)(rm))
-            if (result !== '["a"]') { throw result }
-        },
-        () => {
-            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-            const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
-            const result = stringify(_.get(10)(rm))
-            if (result !== '["a"]') { throw result }
-        },
-        () => {
-            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-            const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
-            const result = stringify(_.get(15)(rm))
-            if (result !== '["b"]') { throw result }
-        },
-        () => {
-            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-            const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
-            const result = stringify(_.get(20)(rm))
-            if (result !== '["b"]') { throw result }
-        },
-        () => {
-            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-            const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
-            const result = stringify(_.get(25)(rm))
-            if (result !== '["c"]') { throw result }
-        },
-        () => {
-            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-            const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
-            const result = stringify(_.get(30)(rm))
-            if (result !== '["c"]') { throw result }
-        },
-        () => {
-            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-            const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
-            const result = _.get(35)(rm)
-            if (result !== undefined) { throw result }
-        },
-        () => {
-            /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-            const rm = []
-            const result = _.get(10)(rm)
-            if (result !== undefined) { throw result }
-        }
-    ]
-}
+    get: () => {
+        /** @type {sortedSet.SortedSet<string>} */
+        const sortedSetEmpty = []
+        const get = _.get(sortedSetEmpty)
+        return [
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const result = stringify(get(5)(rm))
+                if (result !== '["a"]') { throw result }
+            },
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const result = stringify(get(10)(rm))
+                if (result !== '["a"]') { throw result }
+            },
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const result = stringify(get(15)(rm))
+                if (result !== '["b"]') { throw result }
+            },
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const result = stringify(get(20)(rm))
+                if (result !== '["b"]') { throw result }
+            },
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const result = stringify(get(25)(rm))
+                if (result !== '["c"]') { throw result }
+            },
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const result = stringify(get(30)(rm))
+                if (result !== '["c"]') { throw result }
+            },
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const result = stringify(get(35)(rm))
+                if (result !== '[]') { throw result }
+            },
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = []
+                const result = stringify(get(10)(rm))
+                if (result !== '[]') { throw result }
+            }
+        ]
+    },
+    fromRange: () => {
+        const def = -1
+        const rm = _.fromRange(def)([1, 7])(42)
+        return [
+            () => {
+                const result = _.get(def)(0)(rm)
+                if (result !== -1) { throw result }
+            },
+            () => {
+                const result = _.get(def)(1)(rm)
+                if (result !== 42) { throw result }
+            },
+            () => {
+                const result = _.get(def)(3)(rm)
+                if (result !== 42) { throw result }
+            },
+            () => {
+                const result = _.get(def)(7)(rm)
+                if (result !== 42) { throw result }
+            },
+            () => {
+                const result = _.get(def)(9)(rm)
+                if (result !== -1) { throw result }
+            },
+        ]
+    }
+}