functionalscript 0.0.335 → 0.0.338

package/json/tokenizer/index.js

@@ -116,22 +116,19 @@ const letterZ = 0x7a
 
 /** @typedef {number|undefined} CharCodeOrEof */
 
-/** @type {(old: string) => (input: CharCodeOrEof) => string} */
-const appendChar = old => input => input === undefined ? old : operator.concat(charToString(input))(old)
-
-/** @type {(input: CharCodeOrEof) => string} */
-const charToString = input => input === undefined ? '' : String.fromCharCode(input)
+/** @type {(old: string) => (input: number) => string} */
+const appendChar = old => input => `${old}${String.fromCharCode(input)}`
 
 /** @type {(state: InitialState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
 const initialStateOp = initialState => input =>
 {
     if (input >= digit1 && input <= digit9)
     {
-        return [undefined, { kind: 'number', value: charToString(input), numberKind: 'int'}]
+        return [undefined, { kind: 'number', value: String.fromCharCode(input), numberKind: 'int'}]
     }
     if (input >= letterA && input <= letterZ)
     {
-        return [undefined, { kind: 'keyword', value: charToString(input)}]
+        return [undefined, { kind: 'keyword', value: String.fromCharCode(input)}]
     }
     switch(input)
     {
@@ -142,8 +139,8 @@ const initialStateOp = initialState => input =>
         case leftBracket: return [[{kind: '['}], initialState]
         case rightBracket: return [[{kind: ']'}], initialState]
         case quotationMark: return[undefined, {kind: 'string', value: ''}]
-        case digit0: return [undefined, { kind: 'number', value: charToString(input), numberKind: '0'}]
-        case signMinus: return [undefined, { kind: 'number', value: charToString(input), numberKind: '-'}]
+        case digit0: return [undefined, { kind: 'number', value: String.fromCharCode(input), numberKind: '0'}]
+        case signMinus: return [undefined, { kind: 'number', value: String.fromCharCode(input), numberKind: '-'}]
         case horizontalTab:
         case newLine:
         case carriageReturn:
@@ -390,10 +387,12 @@ const tokenizeEofOp = state => {
 /** @type {operator.StateScan<CharCodeOrEof, TokenizerState, list.List<JsonToken>>} */
 const tokenizeOp = state => input => input === undefined ? tokenizeEofOp(state) : tokenizeCharCodeOp(state)(input)
 
-/** @type {(input: list.List<CharCodeOrEof>) => list.List<JsonToken>} */
-const tokenize = input => list.flat(list.stateScan(tokenizeOp)({kind: 'initial'})(input))
+const initial = list.stateScan(tokenizeOp)({ kind: 'initial' })
+
+/** @type {(input: list.List<number>) => list.List<JsonToken>} */
+const tokenize = input => list.flat(initial(list.concat(/** @type {list.List<CharCodeOrEof>} */(input))([undefined])))
 
 module.exports = {
     /** @readonly */
-    tokenize,
+    tokenize
 }

package/json/tokenizer/test.js

@@ -3,23 +3,10 @@ const list = require('../../types/list/index.js')
 const json = require('../index.js')
 const { sort } = require('../../types/object/index.js')
 
-/** @type {(s: string) => list.List<tokenizer.CharCodeOrEof>} */
-const toCharacters = s =>
-{
-    /** @type {list.List<tokenizer.CharCodeOrEof>} */
-    const charCodes = list.toCharCodes(s)
-    return list.concat(charCodes)([undefined])
-}
-
 /** @type {(s: string) => readonly tokenizer.JsonToken[]} */
-const tokenizeString = s =>
-{
-    const characters = toCharacters(s)
-    return list.toArray(tokenizer.tokenize(characters))
-}
+const tokenizeString = s => list.toArray(tokenizer.tokenize(list.toCharCodes(s)))
 
-/** @type {(a: readonly tokenizer.JsonToken[]) => string} */
-const stringify = a => json.stringify(sort)(a)
+const stringify = json.stringify(sort)
 
 {
     const result = tokenizeString('')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.335",
+  "version": "0.0.338",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {

package/test.js

@@ -14,6 +14,7 @@ require('./commonjs/path/test.js')
 require('./types/function/compare/test.js')
 require('./types/stringSet/test.js')
 require('./commonjs/build/test.js')
+require('./types/range/test.js')
 
 /** @type {() => never} */
 const assert = () => { throw 'assert' }

package/types/range/index.js

@@ -0,0 +1,9 @@
+/** @typedef {readonly[number,number]} Range */
+
+/** @type {(range: Range) => (i: number) => boolean} */
+const contains = ([b, e]) => i => b <= i && i <= e
+
+module.exports = {
+    /** @readonly */
+    contains,
+}

package/types/range/test.js

@@ -0,0 +1,9 @@
+const _ = require('./index.js')
+
+{
+    if (!_.contains([0, 5])(1)) { throw 1 }
+    if (!_.contains([0, 5])(0)) { throw 0 }
+    if (!_.contains([0, 5])(5)) { throw 5 }
+    if (_.contains([0, 5])(-1)) { throw -1 }
+    if (_.contains([0, 5])(6)) { throw 6 }
+}