functionalscript 0.3.4 → 0.3.6

package/com/test/rust/src/lib.rs

@@ -1,56 +0,0 @@
-mod _result;
-
-use _result::IMy;
-use nanocom::CObjectEx;
-
-use crate::_result::IMy::ClassEx;
-
-struct My {}
-
-impl nanocom::Class for My {
-    type Interface = _result::IMy::Interface;
-    fn static_vmt() -> &'static _result::IMy::Vmt {
-        static VMT: _result::IMy::Vmt = My::VMT;
-        &VMT
-    }
-}
-
-impl _result::IMy::Ex for nanocom::CObject<My> {
-    fn GetSlice(&self) -> _result::Slice {
-        todo!()
-    }
-
-    fn SetSlice(&self, slice: _result::Slice) {
-        println!("SetSlice: {:?}, {:?}", slice.Start, slice.Size);
-    }
-
-    fn GetUnsafe(&self) -> *const bool {
-        todo!()
-    }
-
-    fn SetUnsafe(&self, _p: *const _result::Slice, _size: u32) {
-        todo!()
-    }
-
-    fn Some(&self, _p: &_result::IMy::Object) -> bool {
-        todo!()
-    }
-
-    fn GetIMy(&self, _a: u16, _b: i16) -> _result::IMy::Ref {
-        todo!()
-    }
-
-    fn SetManagedStruct(&self, _a: _result::ManagedStruct) {
-        todo!()
-    }
-}
-
-#[no_mangle]
-pub extern "C" fn get() -> i32 {
-    42
-}
-
-#[no_mangle]
-pub extern "C" fn rust_my_create() -> IMy::Ref {
-    My {}.to_cobject()
-}

package/com/types/module.f.ts

@@ -1,62 +0,0 @@
-import * as O from '../../types/object/module.f.ts'
-import * as list from '../../types/list/module.f.ts'
-import * as f from '../../types/function/module.f.ts'
-const { compose } = f
-const { filter } = list
-const { entries } = Object
-
-export type Library = {readonly[k in string]: Definition}
-
-export type Definition = Struct|Interface
-
-export type Struct = {
-    readonly struct: FieldArray
-}
-
-export type FieldArray = {readonly[k in string]: Type}
-
-export type Field = O.Entry<Type>
-
-export type Interface = {
-    readonly interface: MethodArray
-    readonly guid: string
-}
-
-type MethodArray = {readonly[k in string]: FieldArray}
-
-export type Method = O.Entry<FieldArray>
-
-export type Type = BaseType|Id|Pointer
-
-type Id = readonly[string]
-
-export type BaseType = |
-   'u8'|
-   'i8'|
-   'u16'|
-   'i16'|
-   'u32'|
-   'i32'|
-   'u64'|
-   'i64'|
-   'usize'|
-   'isize'|
-   'f32'|
-   'f64'|
-   'bool'
-
-type Pointer = readonly['*', Type]
-
-const isParam
-    : (kv: O.Entry<Type>) => boolean
-    = ([name]) => name !== '_'
-
-const filterParam = filter(isParam)
-
-export const paramList
-    : (fa: FieldArray) => list.List<Field>
-    = compose(entries)(filterParam)
-
-export const result
-    : <T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T
-    = v => f => fa => '_' in fa ? f(fa._) : v

package/commonjs/README.md

@@ -1,94 +0,0 @@
-# Common.js
-
-## Package
-
-[package/main.f.js](package/main.f.js)
-
-```ts
-// A dictionary of packages.
-//
-// A package contains a dictionary of dependencies and a dictionary of files.
-//
-// `packageId` examples:
-//   - Node.js:
-//     - normalized: `./node_modules/functionalscript`
-//   - fs modules:
-//     - normalized: `github:functionalscript/functionalscript:bf4f3ed9ad1d3c19ee7bea3e76000dec77d01b4f`
-// - `localPackageId` examples:
-//   - `functionalscript`
-
-type PackageGet = (packageId: string) => Package | null
-
-// A local file id is
-
-type Package = {
-    // returns a global package id.
-    readonly dependency: (localPackageId: string) => string | null
-    // returns source of the file.
-    readonly file: (localFileId: string) => string | null
-}
-```
-
-## Module
-
-[module/main.f.js](module/main.f.js)
-
-```ts
-// A module map is a dictionary of modules.
-//
-// A module is a compiled and initialized source file.
-
-type ModuleGet = (moduleId: string) => ModuleState | null
-
-type ModuleMapInterface<M> = {
-    readonly get: (moduleMap: M) => ModuleGet
-    readonly insert: (moduleMap: M) => (moduleId: string) => (moduleState: ModuleState) => M
-}
-
-type ModuleState = readonly['ok', Module] | readonly['error', ModuleError]
-
-type Module = {
-    // Exports is a result of module initialization.
-    readonly exports: unknown
-    // A dictionary of required modules.
-    // For example, `require('functionalscript/types/list')` may produce the dictionary entry
-    // `['functionalscript/types/list', './node_modules/functionalscript/types/list/index.js']`
-    readonly requireMap: object.Map<string>
-}
-
-type ModuleError = 'file not found' | 'compile error' | 'runtime error' | 'circular reference'
-
-// A module id is a global module id. It contains a package id and file id. For example
-// - `./node_modules/functionalscript/types/list/index.js`
-// - `github:functionalscript/functionalscript:bf4f3ed9ad1d3c19ee7bea3e76000dec77d01b4f/types/list/index.js`
-
-type ModuleId = {
-    readonly packageId: string,
-    readonly path: readonly string[],
-}
-
-const moduleIdToString: (moduleId: ModuleId) => string;
-```
-
-## Build
-
-[build/index.js](build/index.js)
-
-```ts
-type BuildConfig<M> = {
-    readonly packageGet: PackageGet
-    readonly moduleMapInterface: ModuleMapInterface<M>
-    readonly moduleId: ModuleId
-    readonly moduleMap: M // mutable
-}
-
-type BuildState<M> = {
-    readonly packageGet: PackageGet
-    readonly moduleMapInterface: ModuleMapInterface<M>
-    readonly moduleId: ModuleId
-    readonly moduleMap: M // mutable
-    readonly ModuleRequireMap: map.Map<string> // mutable
-}
-
-const getOrBuild: <M>(buildConfig: BuildConfig<M>) => readonly[ModuleState, M];
-```

package/commonjs/build/module.f.ts

@@ -1,100 +0,0 @@
-import * as package_ from '../package/module.f.ts'
-import * as module from '../module/module.f.ts'
-const { idToString, dir } = module
-import * as function_ from '../module/function/module.f.ts'
-import * as map from '../../types/map/module.f.ts'
-const { empty: mapEmpty, setReplace } = map
-import * as object from '../../types/object/module.f.ts'
-const { fromMap } = object
-import * as path from '../path/module.f.ts'
-const { parseAndFind } = path
-import * as stringSet from '../../types/string_set/module.f.ts'
-const { set: setSet, contains: setContains, empty: stringSetEmpty } = stringSet
-
-type Config<M> = {
-   readonly packageGet: package_.Get
-   readonly moduleMapInterface: module.MapInterface<M>
-   readonly moduleId: module.Id
-   readonly moduleMap: M
-}
-
-type Result<M> = readonly[module.State, M]
-
-const notFound
-    : <M>(moduleMap: M) => Result<M>
-    = moduleMap => [['error', ['file not found']], moduleMap]
-
-export const getOrBuild
-    :   (compile: function_.Compile) =>
-        (packageGet: package_.Get) =>
-        <M>(moduleMapInterface: module.MapInterface<M>) =>
-        (moduleId: module.Id) =>
-        (moduleMap: M) =>
-        Result<M>
-    = compile => packageGet => moduleMapInterface =>  {
-
-    type M = typeof moduleMapInterface extends module.MapInterface<infer M> ? M : never
-
-    const build
-        :   (buildSet: stringSet.StringSet) =>
-            (moduleId: module.Id) =>
-            (source: string) =>
-            (moduleMap: M) =>
-            Result<M>
-        = buildSet => moduleId => {
-
-        const moduleIdStr = idToString(moduleId)
-        const buildSet1 = setSet(moduleIdStr)(buildSet)
-        const moduleDir = dir(moduleId)
-        const require_
-            : function_.Require<readonly[map.Map<string>, M]>
-            = p => ([requireMap, m]) => {
-            const error
-                : (e: unknown) => function_.Result<readonly[map.Map<string>, M]>
-                = e => [['error', e], [requireMap, m]]
-            if (moduleDir === null) { return error('file not found') }
-            const r = parseAndFind(packageGet)(moduleDir)(p)
-            if (r === null) { return error('file not found') }
-            const rIdStr = idToString(r.id)
-            if (setContains(rIdStr)(buildSet1)) { return error('circular reference') }
-            const [state, m1] = build(buildSet1)(r.id)(r.source)(m)
-            return [state[0] === 'error' ? state : ['ok', state[1].exports], [setReplace(p)(rIdStr)(requireMap), m1]]
-        }
-        return source => moduleMap => {
-            const set
-                : (s: module.State) => (m: M) => Result<M>
-                = s => m => [s, moduleMapInterface.setReplace(moduleIdStr)(s)(m)]
-            const error
-                : (e: module.Error) => (m: M) => Result<M>
-                = e => set(['error', e])
-            // check compilation
-            const [kind, result] = compile(source)
-            if (kind === 'error') { return error(['compilation error', result])(moduleMap) }
-            // build
-            const [[state, value], [requireMap, moduleMap2]] = result(require_)([mapEmpty, moduleMap])
-            const x = state === 'error' ?
-                error(['runtime error', value]) :
-                set(['ok', { exports: value, requireMap: fromMap(requireMap) }])
-            return x(moduleMap2)
-        }
-    }
-
-    const f
-        : (moduleId: module.Id) => (moduleMap: M) => Result<M>
-        = moduleId => moduleMap => {
-
-        const moduleIdStr = idToString(moduleId)
-        // check moduleMap
-        {
-            const m = moduleMapInterface.at(moduleIdStr)(moduleMap)
-            if (m !== null) { return [m, moduleMap] }
-        }
-        // check package
-        const p = packageGet(moduleId.package)
-        if (p === null) { return notFound(moduleMap) }
-        // check file
-        const source = p.file(moduleId.path.join('/'))
-        return (source === null ? notFound : build(stringSetEmpty)(moduleId)(source))(moduleMap)
-    }
-    return f
-}

package/commonjs/build/test.f.ts

@@ -1,107 +0,0 @@
-import * as _ from './module.f.ts'
-import * as map from '../../types/map/module.f.ts'
-import * as Module from '../module/module.f.ts'
-import * as ModuleFunction from '../module/function/module.f.ts'
-import * as Result from '../../types/result/module.f.ts'
-import * as Package from '../package/module.f.ts'
-import * as o from '../../types/object/module.f.ts'
-const { at } = o
-
-const compileMap
-    : { readonly [k in string]?: Result.Result<ModuleFunction.Function_, unknown> }
-    = {
-    ':index.js': [
-        'ok',
-        require_ => m0 => {
-            let [r, m] = require_('./b')(m0);
-            if (r[0] === 'error') { throw JSON.stringify(r) }
-            [r, m] = require_('./a/')(m);
-            if (r[0] === 'error') { throw JSON.stringify(r) }
-            [r, m] = require_('x/r')(m);
-            if (r[0] === 'error') { throw JSON.stringify(r) }
-            return [['ok', ':index.js'], m]
-        }],
-    ':b.js': [
-        'ok',
-        () => m0 => [['ok', ':b.js'], m0]],
-    ':a/index.js': [
-        'ok',
-        () => m0 => [['ok', ':a/index.js'], m0]],
-    'x:r.js': [
-        'ok',
-        () => m0 => [['ok', 'x:r.js'], m0]],
-}
-
-const compile
-    : ModuleFunction.Compile
-    = source => compileMap[source] ?? ['error', 'invalid source']
-
-type StringMap = { readonly [k in string]: string }
-
-const packageMap
-    : { readonly [k in string]: { readonly dependencies: StringMap, readonly files: StringMap }}
-    = {
-    '': {
-        dependencies: {
-            'x': '/node_modules/x'
-        },
-        files: {
-            'index.js': ':index.js',
-            'b.js': ':b.js',
-            'a/index.js': ':a/index.js',
-        }
-    },
-    '/node_modules/x': {
-        dependencies: {},
-        files: {
-            'r.js': 'x:r.js'
-        }
-    },
-}
-
-const packageGet
-    : Package.Get
-    = packageId => {
-    const p = at(packageId)(packageMap)
-    return p === null ? null :
-        {
-            dependency: dependency => at(dependency)(p.dependencies),
-            file: file => at(file)(p.files),
-        }
-}
-
-const getOrBuild = _.getOrBuild
-    (compile)
-    (packageGet)
-    (map as Module.MapInterface<map.Map<Module.State>>)
-
-export default () => {
-    let [r, m] = getOrBuild({ package: '', path: ['index.js'] })(map.empty)
-    {
-        if (r === null) { throw 'r === null' }
-        const x = JSON.stringify(r)
-        if (x !==
-            '["ok",{"exports":":index.js","requireMap":{"./a/":"/a/index.js","./b":"/b.js","x/r":"/node_modules/x/r.js"}}]'
-        ) {
-            throw `0:${x}`
-        }
-    }
-    {
-        [r, m] = getOrBuild({ package: '', path: ['b.js'] })(m)
-        const x = JSON.stringify(r)
-        if (x !==
-            '["ok",{"exports":":b.js","requireMap":{}}]'
-        ) {
-            throw x
-        }
-    }
-    {
-        [r, m] = getOrBuild({ package: '', path: ['c.js'] })(m)
-        const x = JSON.stringify(r)
-        if (x !==
-            '["error",["file not found"]]'
-        ) {
-            throw x
-        }
-    }
-}

package/commonjs/module/module.f.ts

@@ -1,41 +0,0 @@
-import * as O from '../../types/object/module.f.ts'
-
-export type MapInterface<M> = {
-    readonly at: (moduleId: string) => (moduleMap: M) => State | null
-    readonly setReplace: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M
-}
-
-export type State = |
-    readonly['ok', Module] |
-    readonly['error', Error]
-
-type Module = {
-    readonly exports: unknown
-    readonly requireMap: O.Map<string>
-}
-
-export type Error = |
-    ['file not found'] |
-    ['compilation error', unknown] |
-    ['runtime error', unknown] |
-    ['circular reference']
-
-export type Id = {
-    readonly package: string
-    readonly path: readonly string[]
-}
-
-export const dir
-    : (id: Id) => Id | null
-    = id => {
-    const len = id.path.length
-    if (len < 1) { return null }
-    return {
-        package: id.package,
-        path: id.path.slice(0, len - 1)
-    }
-}
-
-export const idToString
-    : (id: Id) => string
-    = id => `${id.package}/${id.path.join('/')}`

package/commonjs/module.f.ts

@@ -1,7 +0,0 @@
-type PackageMap = (packageName: string) => PackageMap|Package|null
-
-type Package = readonly[
-    string,
-    PackageMap,
-    (fileName: string) => string|null
-]

package/commonjs/module.ts

@@ -1,31 +0,0 @@
-import unsafeResult from '../types/result/module.ts'
-const { tryCatch } = unsafeResult
-import * as result from '../types/result/module.f.ts'
-const { unwrap } = result
-import * as ModuleFunction from './module/function/module.f.ts'
-
-const build
-    : (f: Function) => ModuleFunction.Function_
-    = f => immutableRequire => mutableData => {
-    const mutableRequire
-        : (path: string) => unknown
-        = path => {
-        const [result, data] = immutableRequire(path)(mutableData)
-        // Side effect: setting a variable from a nested function (closure)
-        // is not allowed in FunctionalScript.
-        mutableData = data
-        return unwrap(result)
-    }
-    const result = tryCatch(() => {
-        const mutableModule = { exports: {} }
-        f(mutableModule, mutableRequire)
-        return mutableModule.exports
-    })
-    return [result, mutableData]
-}
-
-export const compile
-    : ModuleFunction.Compile
-    = source =>
-    // Side effect: a `Function` constructor is not allowed in FunctionalScript.
-    tryCatch(() => build(Function('module', 'require', `"use strict";${source}`)))

package/commonjs/package/dependencies/module.f.ts

@@ -1,22 +0,0 @@
-import * as json from '../../../json/module.f.ts'
-const { isObject } = json
-import * as list from '../../../types/list/module.f.ts'
-const { map, every } = list
-const { entries } = Object
-
-type DependencyJson = readonly[string, string]
-
-type DependencyMapJson = {readonly[k in string]: string}
-
-export type DependenciesJson = DependencyMapJson|null
-
-const isDependencyJson
-    : (entry: json.Entry) => boolean
-    = ([, v]) => typeof v === 'string'
-
-export const isDependenciesJson
-    = (j: json.Unknown): j is DependenciesJson => {
-    if (j === null) { return true }
-    if (!isObject(j)) { return false }
-    return every(map(isDependencyJson)(entries(j)))
-}

package/commonjs/package/dependencies/test.f.ts

@@ -1,8 +0,0 @@
-import * as _ from './module.f.ts'
-
-export default () => {
-    if (!_.isDependenciesJson(null)) { throw 'error' }
-    if (!_.isDependenciesJson({})) { throw 'error' }
-    if (!_.isDependenciesJson({'a':'b'})) { throw 'error' }
-    if (_.isDependenciesJson({ 'a': 12 })) { throw 'error' }
-}

package/commonjs/package/module.f.ts

@@ -1,31 +0,0 @@
-import * as json from '../../json/module.f.ts'
-const { isObject } = json
-import * as dependencies from './dependencies/module.f.ts'
-const { isDependenciesJson } = dependencies
-import * as o from '../../types/object/module.f.ts'
-const { at } = o
-
-type PackageJson = {
-    readonly name: string
-    readonly version: string
-    readonly dependencies?: dependencies.DependenciesJson
-}
-
-export const isPackageJson
-    = (j: json.Unknown): j is PackageJson => {
-    if (!isObject(j)) { return false }
-    if (typeof j.name !== 'string') { return false }
-    if (typeof j.version !== 'string') { return false }
-    if (!isDependenciesJson(at('dependencies')(j))) { return false }
-    return true
-}
-
-export type Package = {
-    readonly dependency: (localPackageId: string) => string | null
-    readonly file: (localFileId: string) => string | null
- }
-
-/**
- * @note Current package has an empty string '' as a packageId.
- */
-export type Get = (packageId: string) => Package | null

package/commonjs/package/test.f.ts

@@ -1,12 +0,0 @@
-import * as _ from './module.f.ts'
-
-export default () => {
-    if (_.isPackageJson(null)) { throw 'error' }
-    if (_.isPackageJson({})) { throw 'error' }
-    if (_.isPackageJson({name:'x',version:12})) { throw 'error' }
-    if (!_.isPackageJson({name:'x',version:"12"})) { throw 'error' }
-    if (_.isPackageJson({version:"",dependencies:[]})) { throw 'error' }
-    if (!_.isPackageJson({name:'a', version: "", dependencies: {} })) { throw 'error' }
-    if (_.isPackageJson({name:'b', version: "", dependencies: { x: 12} })) { throw 'error' }
-    if (!_.isPackageJson({name:'c', version: "", dependencies: { x: "12" } })) { throw 'error' }
-}

package/commonjs/path/README.md

@@ -1,17 +0,0 @@
-# Path
-
-## Simplified Common.js
-
-A path should be disambiguous.
-
-Path limitations:
-
-- Accepted file extensions: `.f.js`, `.json`.
-- A file path should be fully specified.  For example `../package/dependencies/test.f.js`.
-- A package name can't contain `/`. For example 
-  - `functionalscript/main.f.js` is allowed.
-  - `functionalscript/functionalscript/main.f.js` is not allowed.
-
-`package.json` limitations:
-
-- Only GitHub packages can be referenced. In the future, we may add generic Git repositories.