functionalscript 0.0.499 → 0.0.500

package/json/parser/module.f.cjs

@@ -1,16 +1,18 @@
 const result = require('../../types/result/module.f.cjs')
 const list = require('../../types/list/module.f.cjs')
-const { fold, isEmpty, first, drop, toArray } = list
+const { fold, first, drop, toArray } = list
 const operator = require('../../types/function/operator/module.f.cjs')
 const tokenizer = require('../tokenizer/module.f.cjs')
 const map = require('../../types/map/module.f.cjs')
-const { entries, setReplace } = map
+const { setReplace } = map
+const json = require('../module.f.cjs')
+const { fromMap } = require('../../types/object/module.f.cjs')
 
 
 /**
  * @typedef {{
 * readonly kind: 'object'
-* readonly values: map.Map<any>
+* readonly values: map.Map<json.Unknown>
 * readonly key: string
 * }} JsonObject
 * */
@@ -18,7 +20,7 @@ const { entries, setReplace } = map
 /**
  * @typedef {{
 * readonly kind: 'array'
-* readonly values: list.List<any>
+* readonly values: list.List<json.Unknown>
 * }} JsonArray
 * */
 
@@ -42,7 +44,7 @@ const { entries, setReplace } = map
 /**
  * @typedef {{
 *  readonly status: 'result'
-*  readonly value: any
+*  readonly value: json.Unknown
 * }} StateResult
 */
 
@@ -64,10 +66,10 @@ const { entries, setReplace } = map
 /** @type {(obj: JsonObject) => (key: string) => JsonObject} */
 const addKeyToObject = obj => key => ({ kind: 'object', values: obj.values, key: key })
 
-/** @type {(obj: JsonObject) => (value: any) => JsonObject} */
+/** @type {(obj: JsonObject) => (value: json.Unknown) => JsonObject} */
 const addValueToObject = obj => value => ({ kind: 'object', values: setReplace(obj.key)(value)(obj.values), key: '' })
 
-/** @type {(array: JsonArray) => (value: any) => JsonArray} */
+/** @type {(array: JsonArray) => (value: json.Unknown) => JsonArray} */
 const addToArray = array => value => ({ kind: 'array', values: list.concat(array.values)([value]) })
 
 /** @type {(state: StateParse) => (key: string) => JsonState} */
@@ -76,9 +78,9 @@ const pushKey = state => value => {
     return { status: 'error', message: 'error' }
 }
 
-/** @type {(state: StateParse) => (value: any) => JsonState} */
+/** @type {(state: StateParse) => (value: json.Unknown) => JsonState} */
 const pushValue = state => value => {
-    if (state.top === null) { return { status: 'result', value: value }}
+    if (state.top === null) { return { status: 'result', value: value } }
     if (state.top.kind === 'array') { return { status: '[v', top: addToArray(state.top)(value), stack: state.stack } }
     return { status: '{v', top: addValueToObject(state.top)(value), stack: state.stack }
 }
@@ -103,30 +105,21 @@ const startObject = state => {
     return { status: '{', top: { kind: 'object', values: null, key: '' }, stack: newStack }
 }
 
-/** @type {operator.Fold<map.Entry<any>, any>} */
-const foldToObjectOp = ([k, v]) => obj => { return { ...obj, [k] : v } }
-
-/** @type {(m: map.Map<any>) => any} */
-const toObject = m => {
-    const e = entries(m)
-    return fold(foldToObjectOp)({})(e)
-}
-
 /** @type {(state: StateParse) => JsonState} */
 const endObject = state => {
-    const obj = state.top?.kind === 'object' ? toObject(state.top.values) : null
+    const obj = state.top?.kind === 'object' ? fromMap(state.top.values) : null
     /** @type {StateParse} */
     const newState = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) }
     return pushValue(newState)(obj)
 }
 
-/** @type {(token: tokenizer.JsonToken) => any} */
+/** @type {(token: tokenizer.JsonToken) => json.Unknown} */
 const tokenToValue = token => {
-    switch(token.kind) {
+    switch (token.kind) {
         case 'null': return null
         case 'false': return false
         case 'true': return true
-        case 'number': return Number(token.value)
+        case 'number': return parseFloat(token.value)
         case 'string': return token.value
         default: return null
     }
@@ -134,7 +127,7 @@ const tokenToValue = token => {
 
 /** @type {(token: tokenizer.JsonToken) => boolean} */
 const isValueToken = token => {
-    switch(token.kind) {
+    switch (token.kind) {
         case 'null':
         case 'false':
         case 'true':
@@ -204,25 +197,25 @@ const parseObjectCommaOp = token => state => {
 
 /** @type {operator.Fold<tokenizer.JsonToken, JsonState>} */
 const foldOp = token => state => {
-    switch(state.status) {
+    switch (state.status) {
         case 'result': return { status: 'error', message: 'unexpected token' }
         case 'error': return { status: 'error', message: state.message }
         case '': return parseValueOp(token)(state)
         case '[': return parseArrayStartOp(token)(state)
         case '[v': return parseArrayValueOp(token)(state)
         case '[,': return parseValueOp(token)(state)
-        case '{' : return parseObjectStartOp(token)(state)
-        case '{k' : return parseObjectKeyOp(token)(state)
-        case '{:' : return parseObjectColonOp(token)(state)
-        case '{v' : return parseObjectNextOp(token)(state)
-        case '{,' : return parseObjectCommaOp(token)(state)
+        case '{': return parseObjectStartOp(token)(state)
+        case '{k': return parseObjectKeyOp(token)(state)
+        case '{:': return parseObjectColonOp(token)(state)
+        case '{v': return parseObjectNextOp(token)(state)
+        case '{,': return parseObjectCommaOp(token)(state)
     }
 }
 
-/** @type {(tokenList: list.List<tokenizer.JsonToken>) => result.Result<any, string>} */
+/** @type {(tokenList: list.List<tokenizer.JsonToken>) => result.Result<json.Unknown, string>} */
 const parse = tokenList => {
     const state = fold(foldOp)({ status: '', top: null, stack: null })(tokenList)
-    switch(state.status) {
+    switch (state.status) {
         case 'result': return result.ok(state.value)
         case 'error': return result.error(state.message)
         default: return result.error('unexpected end')

package/json/tokenizer/module.f.cjs

@@ -238,7 +238,7 @@ const initialStateOp = create(state => () => [[{ kind: 'error', message: 'unexpe
     rangeFunc(one(hyphenMinus))(() => input => [empty, { kind: 'number', value: fromCharCode(input), numberKind: '-' }])
 ])
 
-/** @type {(state: any) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
+/** @type {() => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
 const invalidNumberToToken = () => input => tokenizeOp({ kind: 'invalidNumber' })(input)
 
 /** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */

package/package.json

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

package/types/number/test.f.cjs

@@ -22,5 +22,20 @@ module.exports = {
     cmp: () => {
         const result = cmp(4)(5)
         if (result !== -1) { throw result }
+    },
+    standard: () => {
+        /** @type {(v: bigint) => void} */
+        const eq = v => {
+            if (BigInt(Number(v)) != v) { throw v }
+        }
+
+        // 0x35 bits.
+        //        3                   2                   1                   0
+        //   4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210
+        eq(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n)
+        eq(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0001n)
+        eq(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0010n)
+        eq(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0011n)
+        eq(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0100n)
     }
 }