functionalscript 0.1.607 → 0.1.609

package/djs/parser/module.f.mjs

@@ -2,156 +2,291 @@
 
 import result, * as Result from '../../types/result/module.f.mjs'
 import list, * as List from '../../types/list/module.f.mjs'
-const { fold, first, drop, toArray } = list
+const { fold, first, drop, toArray, map: listMap, length } = list
 import * as Operator from '../../types/function/operator/module.f.mjs'
 import * as tokenizerT from '../tokenizer/module.f.mjs'
 import map, * as Map from '../../types/map/module.f.mjs'
-const { setReplace } = map
-import * as Djs from '../module.f.mjs'
-import o from '../../types/object/module.f.mjs'
+const { setReplace, at } = map
+import o, * as O from '../../types/object/module.f.mjs'
 const { fromMap } = o
 
+/** @typedef {[readonly string[], readonly DjsConst[]] } DjsModule */
+
+/** @typedef {boolean|string|number|null|bigint|DjsModuleRef|DjsArray|DjsObject} DjsConst */
+
+/** @typedef {['aref' | 'cref', number]} DjsModuleRef */
+
+/** @typedef {['array', readonly DjsConst[]]} DjsArray */
+
 /**
  * @typedef {{
-* readonly kind: 'object'
-* readonly values: Map.Map<Djs.Unknown>
-* readonly key: string
-* }} JsonObject
-* */
+*  readonly [k in string]: DjsConst
+* }} DjsObject
+*/
+
+/** @typedef {['array', List.List<DjsConst>]} DjsStackArray */
+
+/** @typedef {['object', Map.Map<DjsConst>, string]} DjsStackObject */
+
+
+/**
+ * @typedef {|
+* DjsStackArray |
+* DjsStackObject
+* } DjsStackElement
+*/
+
+/** @typedef {List.List<DjsStackElement>} DjsStack */
+
+/** @typedef {InitialState | NewLineRequiredState | ImportState | ConstState | ExportState | ParseValueState | ResultState | ErrorState} ParserState */
 
 /**
  * @typedef {{
-* readonly kind: 'array'
-* readonly values: List.List<Djs.Unknown>
-* }} JsonArray
-* */
+*  readonly refs: Map.Map<DjsModuleRef>
+*  readonly modules: List.List<string>
+*  readonly consts: List.List<DjsConst>
+* }} ModuleState
+*/
 
 /**
- * @typedef {|
-* JsonObject |
-* JsonArray
-* } JsonStackElement
+ * @typedef {{
+*  readonly state: ''
+*  readonly module: ModuleState
+* }} InitialState
 */
 
-/** @typedef {List.List<JsonStackElement>} JsonStack */
+/**
+ * @typedef {{
+*  readonly state: 'nl'
+*  readonly module: ModuleState
+* }} NewLineRequiredState
+*/
 
 /**
  * @typedef {{
-*  readonly status: 'module'
-*  readonly stage: 'module' | '.' | 'exports' | '='
-* }} StateModule
+*  readonly state: 'import' | 'import+name' | 'import+from'
+*  readonly module: ModuleState
+* }} ImportState
 */
 
 /**
  * @typedef {{
-*  readonly status: '' | '[' | '[v' | '[,' | '{' | '{k' | '{:' | '{v' | '{,'
-*  readonly top: JsonStackElement | null
-*  readonly stack: JsonStack
-* }} StateParse
+*  readonly state: 'const' | 'const+name'
+*  readonly module: ModuleState
+* }} ConstState
 */
 
 /**
  * @typedef {{
-*  readonly status: 'result'
-*  readonly value: Djs.Unknown
-* }} StateResult
+*  readonly state: 'export'
+*  readonly module: ModuleState
+* }} ExportState
 */
 
 /**
  * @typedef {{
-*  readonly status: 'error'
-*  readonly message: string
-* }} StateError
+*  readonly state: 'constValue' | 'exportValue'
+*  readonly module: ModuleState
+*  readonly valueState: '' | '[' | '[v' | '[,' | '{' | '{k' | '{:' | '{v' | '{,'
+*  readonly top: DjsStackElement | null
+*  readonly stack: DjsStack
+* }} ParseValueState
 */
 
 /**
- * @typedef {|
-* StateModule |
-* StateParse |
-* StateResult |
-* StateError
-* } DjsState
+ * @typedef {{
+*  readonly state: 'result'
+*  readonly module: ModuleState
+* }} ResultState
+*/
+
+/**
+ * @typedef {{
+*  readonly state: 'error'
+*  readonly message: string
+* }} ErrorState
 */
 
-/** @type {(token: tokenizerT.DjsToken) => (state: StateModule) => DjsState}} */
-const parseModuleOp = token => state => {
-    switch(state.stage)
+
+/** @type {(token: tokenizerT.DjsToken) => (state: InitialState) => ParserState}} */
+const parseInitialOp = token => state => {
+    switch (token.kind)
     {
-        case 'module':
-        {
-            if (token.kind === 'id' && token.value === 'module') return { status: 'module', stage: '.' }
-            break;
+        case 'ws':
+        case 'nl': return state
+        case 'id': {
+            switch (token.value) {
+                case 'import': return { ... state, state: 'import' }
+                case 'const': return { ... state, state: 'const' }
+                case 'export': return { ... state, state: 'export' }
+            }
         }
-        case '.':
-        {
-            if (token.kind === '.') return { status: 'module', stage: 'exports' }
-            break;
+    }
+    return { state: 'error', message: 'unexpected token' }
+}
+
+/** @type {(token: tokenizerT.DjsToken) => (state: NewLineRequiredState) => ParserState}} */
+const parseNewLineRequiredOp = token => state => {
+    switch (token.kind) {
+        case 'ws': return state
+        case 'nl': return { ... state, state: '' }
+        default: return { state: 'error', message: 'unexpected token' }
+    }
+}
+
+/** @type {(token: tokenizerT.DjsToken) => (state: ExportState) => ParserState}} */
+const parseExportOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl': return state
+        case 'id': {
+            if (token.value === 'default') return { ... state, state: 'exportValue', valueState: '', top: null, stack: null }
         }
-        case 'exports':
-        {
-            if (token.kind === 'id' && token.value === 'exports') return { status: 'module', stage: '=' }
-            break;
+    }
+    return { state: 'error', message: 'unexpected token' }
+}
+
+/** @type {(token: tokenizerT.DjsToken) => (state: ConstState) => ParserState}} */
+const parseConstOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl': return state
+        case 'id': {
+            if (map.at(token.value)(state.module.refs) !== null)
+                return { state: 'error', message: 'duplicate id' }      
+            /** @type {DjsModuleRef} */
+            let cref = ['cref', length(state.module.consts)]
+            let refs = map.setReplace(token.value)(cref)(state.module.refs)
+            return { ... state, state: 'const+name', module: { ...state.module, refs: refs } }
         }
-        case '=':
-        {
-            if (token.kind === '=') return { status: '', top: null, stack: null }
-            if (token.kind === 'ws') return state
+        default: return { state: 'error', message: 'unexpected token' }
+    }
+}
+
+/** @type {(token: tokenizerT.DjsToken) => (state: ConstState) => ParserState}} */
+const parseConstNameOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl': return state
+        case '=': return { ... state, state: 'constValue', valueState: '', top: null, stack: null }
+        default: return { state: 'error', message: 'unexpected token' }
+    }
+}
+
+/** @type {(token: tokenizerT.DjsToken) => (state: ImportState) => ParserState}} */
+const parseImportOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl': return state
+        case 'id': {
+            if (map.at(token.value)(state.module.refs) !== null)
+                return { state: 'error', message: 'duplicate id' }
+            /** @type {DjsModuleRef} */
+            let aref = ['aref', length(state.module.modules)]
+            let refs = map.setReplace(token.value)(aref)(state.module.refs)
+            return { ... state, state: 'import+name', module: { ...state.module, refs: refs } }
+        }
+        default: return { state: 'error', message: 'unexpected token' }
+    }
+}
+
+/** @type {(token: tokenizerT.DjsToken) => (state: ImportState) => ParserState}} */
+const parseImportNameOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl': return state
+        case 'id': {
+            if (token.value === 'from') return { ... state, state: 'import+from' }
         }
     }
-    return { status: 'error', message: 'unexpected token' }
+    return { state: 'error', message: 'unexpected token' }
 }
 
-/** @type {(obj: JsonObject) => (key: string) => JsonObject} */
-const addKeyToObject = obj => key => ({ kind: 'object', values: obj.values, key: key })
+/** @type {(token: tokenizerT.DjsToken) => (state: ImportState) => ParserState}} */
+const parseImportFromOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl': return state
+        case 'string': {
+            const modules = list.concat(state.module.modules)([token.value])
+            return { ... state, state: 'nl', module: { ...state.module, modules: modules } }
+        }
+        default: return { state: 'error', message: 'unexpected token' }
+    }
+}
 
-/** @type {(obj: JsonObject) => (value: Djs.Unknown) => JsonObject} */
-const addValueToObject = obj => value => ({ kind: 'object', values: setReplace(obj.key)(value)(obj.values), key: '' })
+/** @type {(obj: DjsStackObject) => (key: string) => DjsStackObject} */
+const addKeyToObject = obj => key => ([ 'object', obj[1], key])
 
-/** @type {(array: JsonArray) => (value: Djs.Unknown) => JsonArray} */
-const addToArray = array => value => ({ kind: 'array', values: list.concat(array.values)([value]) })
+/** @type {(obj: DjsStackObject) => (value: DjsConst) => DjsStackObject} */
+const addValueToObject = obj => value => ([ 'object', setReplace(obj[2])(value)(obj[1]), '' ])
 
-/** @type {(state: StateParse) => (key: string) => DjsState} */
-const pushKey = state => value => {
-    if (state.top?.kind === 'object') { return { status: '{k', top: addKeyToObject(state.top)(value), stack: state.stack } }
-    return { status: 'error', message: 'error' }
+/** @type {(array: DjsStackArray) => (value: DjsConst) => DjsStackArray} */
+const addToArray = array => value => ([ 'array', list.concat(array[1])([value]) ])
+
+/** @type {(state: ParseValueState) => (key: string) => ParserState} */
+const pushKey = state => key => {
+    if (state.top?.[0] === 'object') { return { ... state, valueState: '{k', top: addKeyToObject(state.top)(key), stack: state.stack } }
+    return { state: 'error', message: 'error' }
 }
 
-/** @type {(state: StateParse) => (value: Djs.Unknown) => DjsState} */
+/** @type {(state: ParseValueState) => (value: DjsConst) => ParserState} */
 const pushValue = state => 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 }
+    if (state.top === null) { 
+        let consts = list.concat(state.module.consts)([value])
+        switch(state.state)
+        {
+            case 'exportValue': return { ... state, state: 'result', module: { ...state.module, consts: consts }}
+            case 'constValue': return { ... state, state: 'nl', module: { ...state.module, consts: consts }}
+        }
+    }
+    if (state.top?.[0] === 'array') { return { ... state, valueState: '[v', top: addToArray(state.top)(value), stack: state.stack } }
+    return { ... state, valueState: '{v', top: addValueToObject(state.top)(value), stack: state.stack }
 }
 
-/** @type {(state: StateParse) => DjsState} */
+/** @type {(state: ParseValueState) => (name: string) => ParserState} */
+const pushRef = state => name => {
+    const ref = at(name)(state.module.refs)
+    if (ref === null)
+        return { state: 'error', message: 'const not found' }
+    return pushValue(state)(ref)
+}
+
+/** @type {(state: ParseValueState) => ParserState} */
 const startArray = state => {
     const newStack = state.top === null ? null : { first: state.top, tail: state.stack }
-    return { status: '[', top: { kind: 'array', values: null }, stack: newStack }
+    return { ... state, valueState: '[', top: ['array', null ], stack: newStack }
 }
 
-/** @type {(state: StateParse) => DjsState} */
+/** @type {(state: ParseValueState) => ParserState} */
 const endArray = state => {
-    const array = state.top !== null ? toArray(state.top.values) : null
-    /** @type {StateParse} */
-    const newState = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) }
-    return pushValue(newState)(array)
+    const top = state.top;
+    /** @type {ParseValueState} */
+    const newState = { ... state, valueState: '', top: first(null)(state.stack), stack: drop(1)(state.stack) }    
+    if (top !== null && top[0] === 'array')
+    {
+        /** @type {DjsArray} */
+        const array =  ['array', toArray(top[1])];
+        return pushValue(newState)(array)
+    }
+    return pushValue(newState)(null)
 }
 
-/** @type {(state: StateParse) => DjsState} */
+/** @type {(state: ParseValueState) => ParserState} */
 const startObject = state => {
     const newStack = state.top === null ? null : { first: state.top, tail: state.stack }
-    return { status: '{', top: { kind: 'object', values: null, key: '' }, stack: newStack }
+    return { ... state, valueState: '{', top: ['object', null, ''], stack: newStack }
 }
 
-/** @type {(state: StateParse) => DjsState} */
+/** @type {(state: ParseValueState) => ParserState} */
 const endObject = state => {
-    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) }
+    const obj = state?.top !== null && state?.top[0] === 'object' ? fromMap(state.top[1]) : null;
+    /** @type {ParseValueState} */
+    const newState = { ... state, valueState: '', top: first(null)(state.stack), stack: drop(1)(state.stack) }
     return pushValue(newState)(obj)
 }
 
-/** @type {(token: tokenizerT.DjsToken) => Djs.Unknown} */
+/** @type {(token: tokenizerT.DjsToken) => DjsConst} */
 const tokenToValue = token => {
     switch (token.kind) {
         case 'null': return null
@@ -177,100 +312,118 @@ const isValueToken = token => {
     }
 }
 
-/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseValueOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
+    if (token.kind === 'id') { return pushRef(state)(token.value) }
     if (token.kind === '[') { return startArray(state) }
     if (token.kind === '{') { return startObject(state) }
     if (token.kind === 'ws') { return state }
-    return { status: 'error', message: 'unexpected token' }
+    return { state: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseArrayStartOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
+    if (token.kind === 'id') { return pushRef(state)(token.value) }
     if (token.kind === '[') { return startArray(state) }
     if (token.kind === ']') { return endArray(state) }
     if (token.kind === '{') { return startObject(state) }
     if (token.kind === 'ws') { return state }
-    return { status: 'error', message: 'unexpected token' }
+    return { state: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseArrayValueOp = token => state => {
     if (token.kind === ']') { return endArray(state) }
-    if (token.kind === ',') { return { status: '[,', top: state.top, stack: state.stack } }
+    if (token.kind === ',') { return { ... state, valueState: '[,', top: state.top, stack: state.stack } }
     if (token.kind === 'ws') { return state }
-    return { status: 'error', message: 'unexpected token' }
+    return { state: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseObjectStartOp = token => state => {
     if (token.kind === 'string') { return pushKey(state)(token.value) }
     if (token.kind === '}') { return endObject(state) }
     if (token.kind === 'ws') { return state }
-    return { status: 'error', message: 'unexpected token' }
+    return { state: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseObjectKeyOp = token => state => {
-    if (token.kind === ':') { return { status: '{:', top: state.top, stack: state.stack } }
+    if (token.kind === ':') { return { ... state, valueState: '{:', top: state.top, stack: state.stack } }
     if (token.kind === 'ws') { return state }
-    return { status: 'error', message: 'unexpected token' }
+    return { state: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseObjectColonOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
+    if (token.kind === 'id') { return pushRef(state)(token.value) }
     if (token.kind === '[') { return startArray(state) }
     if (token.kind === '{') { return startObject(state) }
     if (token.kind === 'ws') { return state }
-    return { status: 'error', message: 'unexpected token' }
+    return { state: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseObjectNextOp = token => state => {
     if (token.kind === '}') { return endObject(state) }
-    if (token.kind === ',') { return { status: '{,', top: state.top, stack: state.stack } }
+    if (token.kind === ',') { return { ... state, valueState: '{,', top: state.top, stack: state.stack } }
     if (token.kind === 'ws') { return state }
-    return { status: 'error', message: 'unexpected token' }
+    return { state: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseObjectCommaOp = token => state => {
     if (token.kind === 'string') { return pushKey(state)(token.value) }
     if (token.kind === 'ws') { return state }
-    return { status: 'error', message: 'unexpected token' }
+    return { state: 'error', message: 'unexpected token' }
 }
 
-/** @type {Operator.Fold<tokenizerT.DjsToken, DjsState>} */
+/** @type {Operator.Fold<tokenizerT.DjsToken, ParserState>} */
 const foldOp = token => state => {
-    switch (state.status) {
-        case 'module': return parseModuleOp(token)(state)
-        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)
+    switch (state.state) {
+        case '': return parseInitialOp(token)(state)
+        case 'nl': return parseNewLineRequiredOp(token)(state)
+        case 'import': return parseImportOp(token)(state)
+        case 'import+name': return parseImportNameOp(token)(state)
+        case 'import+from': return parseImportFromOp(token)(state)
+        case 'const': return parseConstOp(token)(state)
+        case 'const+name': return parseConstNameOp(token)(state)
+        case 'export': return parseExportOp(token)(state)        
+        case 'result': return { state: 'error', message: 'unexpected token' }
+        case 'error': return { state: 'error', message: state.message }
+        case 'constValue':
+        case 'exportValue': 
+        {
+            switch (state.valueState) 
+            {
+                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)
+            }
+        }
     }
 }
 
-/** @type {(tokenList: List.List<tokenizerT.DjsToken>) => Result.Result<Djs.Unknown, string>} */
+/** @type {(tokenList: List.List<tokenizerT.DjsToken>) => Result.Result<DjsModule, string>} */
 const parse = tokenList => {
-    const state = fold(foldOp)({ status: 'module', stage: 'module' })(tokenList)
-    switch (state.status) {
-        case 'result': return result.ok(state.value)
+    const state = fold(foldOp)({ state: '', module: { refs: null, modules: null, consts: null }})(tokenList)
+    switch (state.state) {
+        case 'result': return result.ok([ toArray(state.module.modules), toArray(state.module.consts) ])
         case 'error': return result.error(state.message)
         default: return result.error('unexpected end')
     }
 }
 
+
 export default {
     /** @readonly */
     parse

package/djs/parser/test.f.d.mts

@@ -4,5 +4,9 @@ declare namespace _default {
     let validWhiteSpaces: (() => void)[];
     let validModule: (() => void)[];
     let invalidModule: (() => void)[];
+    let validWithConst: (() => void)[];
+    let invalidWithConst: (() => void)[];
+    let validWithArgs: (() => void)[];
+    let invalidWithArgs: (() => void)[];
 }
 export default _default;