functionalscript 0.3.1 → 0.3.2

package/.github/workflows/npm-publish.yml

@@ -27,12 +27,11 @@ jobs:
       - run: npm ci
       - run: npm run version
       - run: npm run index
-      - run: npm run tscp
       - run: npm publish
         continue-on-error: true
         env:
           NODE_AUTH_TOKEN: ${{secrets.npm_token}}
-      - run: deno publish --allow-dirty
+      - run: deno publish --allow-dirty --allow-slow-types
         continue-on-error: true
 
 

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@functionalscript/functionalscript",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "license": "AGPL-3.0-only",
   "exports": {
     "./com/cpp": "./com/cpp/module.f.ts",

package/fsc/module.f.ts

@@ -1,24 +1,27 @@
 import * as operator from '../types/function/operator/module.f.ts'
-import * as rangeMap from '../types/range_map/module.f.ts'
-const { merge: rangeMapMerge, fromRange, get } = rangeMap
+import {
+    merge as rangeMapMerge,
+    fromRange,
+    get,
+    type RangeMapArray,
+    type RangeMerge,
+} from '../types/range_map/module.f.ts'
 import * as list from '../types/list/module.f.ts'
 const { reduce: listReduce } = list
-import * as ascii from '../text/ascii/module.f.ts'
-const { range: asciiRange } = ascii
-const { fromCharCode } = String
-import * as f from '../types/function/module.f.ts'
-const { fn } = f
-import * as _range from '../types/range/module.f.ts'
-const { one } = _range
+import { range as asciiRange } from '../text/ascii/module.f.ts'
+import { fn } from '../types/function/module.f.ts'
+import { one, type Range } from '../types/range/module.f.ts'
 const { toArray, map } = list
 
+const fromCharCode = String.fromCharCode
+
 type Result = readonly[readonly string[], ToResult]
 
 type ToResult = (codePoint: number) => Result
 
 type CreateToResult<T> = (state: T) => ToResult
 
-type State<T> = rangeMap.RangeMapArray<CreateToResult<T>>
+type State<T> = RangeMapArray<CreateToResult<T>>
 
 const unexpectedSymbol
     : ToResult
@@ -42,8 +45,8 @@ const empty
 
 const reduce = <T>(a: list.List<State<T>>): State<T> => {
     const merge
-        : rangeMap.RangeMerge<CreateToResult<T>>
-        = rangeMapMerge({
+    : RangeMerge<CreateToResult<T>>
+    = rangeMapMerge({
         union,
         equal: operator.strictEqual,
     })
@@ -55,13 +58,16 @@ const codePointRange = fromRange(def)
 const range = fn(asciiRange).then(codePointRange).result
 
 const rangeSet
-    = (l: readonly string[]) => <T>(f: CreateToResult<T>): State<T> => {
+= (l: readonly string[]) => <T>(f: CreateToResult<T>): State<T> => {
+
     const codePointRange
-        : (a: _range.Range) => (f: CreateToResult<T>) => State<T>
-        = fromRange(def)
+    : (a: Range) => (f: CreateToResult<T>) => State<T>
+    = fromRange(def)
+
     const g
-        : (r: string) => State<T>
-        = r => codePointRange(asciiRange(r))(f)
+    : (r: string) => State<T>
+    = r => codePointRange(asciiRange(r))(f)
+
     return reduce(map(g)(l))
 }
 

package/html/module.f.ts

@@ -1,10 +1,7 @@
-import * as list from '../types/list/module.f.ts'
-const { map, flatMap, flat, concat: listConcat } = list
-import * as s from '../types/string/module.f.ts'
-const { concat: stringConcat } = s
+import { map, flatMap, flat, concat as listConcat, type List } from '../types/list/module.f.ts'
+import { concat as stringConcat } from '../types/string/module.f.ts'
 import * as O from '../types/object/module.f.ts'
-import * as f from '../types/function/module.f.ts'
-const { compose } = f
+import { compose } from '../types/function/module.f.ts'
 import * as utf16 from '../text/utf16/module.f.ts'
 const { stringToList } = utf16
 const { fromCharCode } = String
@@ -72,33 +69,33 @@ const escapeCharCode
 const escape = compose(stringToList)(map(escapeCharCode))
 
 const node
-    : (n: Node) => list.List<string>
-    = n => typeof n === 'string' ? escape(n) : element(n)
+: (n: Node) => List<string>
+= n => typeof n === 'string' ? escape(n) : element(n)
 
 const nodes = flatMap(node)
 
 const attribute
-    : (a: O.Entry<string>) => list.List<string>
-    = ([name, value]) => flat([[' ', name, '="'], escape(value), ['"']])
+: (a: O.Entry<string>) => List<string>
+= ([name, value]) => flat([[' ', name, '="'], escape(value), ['"']])
 
 const attributes
-    : (a: Attributes) => list.List<string>
-    = compose(entries)(flatMap(attribute))
+: (a: Attributes) => List<string>
+= compose(entries)(flatMap(attribute))
 
 const open
-    : (t: string) => (a: Attributes) => list.List<string>
-    = t => a => flat([[`<`, t], attributes(a), [`>`]])
+: (t: string) => (a: Attributes) => List<string>
+= t => a => flat([[`<`, t], attributes(a), [`>`]])
 
 const element3
-    : (t: string) => (an: readonly[Attributes, readonly Node[]]) => list.List<string>
-    = t => ([a, n]) => {
+: (t: string) => (an: readonly[Attributes, readonly Node[]]) => List<string>
+= t => ([a, n]) => {
     const o = flat([[`<`, t], attributes(a), [`>`]])
     return isVoid(t) ? o : flat([o, nodes(n), ['</', t, '>']])
 }
 
 export const element
-    : (element: Element) => list.List<string>
-    = e => {
+: (element: Element) => List<string>
+= e => {
     const [t, a, ...n] = e
     return element3(t)(a === undefined ? [{}, []]: typeof a === 'object' && !(a instanceof Array) ? [a, n] : [{}, [a, ...n]])
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "type": "module",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "scripts": {

package/text/utf16/module.f.ts

@@ -1,10 +1,17 @@
-import * as list from '../../types/list/module.f.ts'
+import {
+    map,
+    flat,
+    stateScan,
+    reduce,
+    flatMap,
+    empty,
+    type List,
+    type Result,
+} from '../../types/list/module.f.ts'
 import * as operator from '../../types/function/operator/module.f.ts'
-import * as range from '../../types/range/module.f.ts'
-const { contains } = range
+import { contains } from '../../types/range/module.f.ts'
 import * as f from '../../types/function/module.f.ts'
 const { fn } = f
-const { map, flat, stateScan, reduce, flatMap, empty } = list
 
 type WordOrEof = u16|null
 
@@ -36,8 +43,8 @@ const isSupplementaryPlane
     = contains([0x01_0000, 0x10_ffff])
 
 const codePointToUtf16
-    : (input: i32) => list.List<u16>
-    = codePoint => {
+: (input: i32) => List<u16>
+= codePoint => {
     if (isBmpCodePoint(codePoint)) { return [codePoint] }
     if (isSupplementaryPlane(codePoint)) {
         const n = codePoint - 0x1_0000
@@ -53,8 +60,8 @@ export const fromCodePointList = flatMap(codePointToUtf16)
 const u16 = contains([0x0000, 0xFFFF])
 
 const utf16ByteToCodePointOp
-    : operator.StateScan<u16, Utf16State, list.List<i32>>
-    = state => word => {
+: operator.StateScan<u16, Utf16State, List<i32>>
+= state => word => {
     if (!u16(word)) {
         return [[0xffffffff], state]
     }
@@ -74,27 +81,27 @@ const utf16ByteToCodePointOp
 }
 
 const utf16EofToCodePointOp
-    : (state: Utf16State) => readonly[list.List<i32>, Utf16State]
-    = state => [state === null ? empty : [state | errorMask],  null]
+: (state: Utf16State) => readonly[List<i32>, Utf16State]
+= state => [state === null ? empty : [state | errorMask],  null]
 
 const utf16ByteOrEofToCodePointOp
-    : operator.StateScan<WordOrEof, Utf16State, list.List<i32>>
-    = state => input => input === null ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input)
+: operator.StateScan<WordOrEof, Utf16State, List<i32>>
+= state => input => input === null ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input)
 
 const eofList
-    : list.List<WordOrEof>
-    = [null]
+: List<WordOrEof>
+= [null]
 
 export const toCodePointList
-    : (input: list.List<u16>) => list.List<i32>
-    = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
+: (input: List<u16>) => List<i32>
+= input => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
 
 export const stringToList
-    : (s: string) => list.List<u16>
-    = s => {
+: (s: string) => List<u16>
+= s => {
     const at
-        : (i: number) => list.Result<number>
-        = i => {
+    : (i: number) => Result<number>
+    = i => {
         const first = s.charCodeAt(i)
         return isNaN(first) ? empty : { first, tail: () => at(i + 1) }
     }
@@ -102,7 +109,7 @@ export const stringToList
 }
 
 export const listToString
-    : (input: list.List<u16>) => string
-    = fn(map(String.fromCharCode))
+: (input: List<u16>) => string
+= fn(map(String.fromCharCode))
     .then(reduce(operator.concat)(''))
     .result

package/text/utf8/module.f.ts

@@ -1,7 +1,6 @@
-import * as list from '../../types/list/module.f.ts'
+import { flatMap, flat, stateScan, type List } from '../../types/list/module.f.ts'
 import * as operator from '../../types/function/operator/module.f.ts'
 import * as Array from '../../types/array/module.f.ts'
-const { flatMap, flat, stateScan } = list
 
 type ByteOrEof = u8|null
 
@@ -16,7 +15,7 @@ type i32 = number
 const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
 
 const codePointToUtf8
-    : (input:number) => list.List<u8>
+    : (input:number) => List<u8>
     = input => {
     if (input >= 0x0000 && input <= 0x007f) { return [input & 0b01111_1111] }
     if (input >= 0x0080 && input <= 0x07ff) { return [input >> 6 | 0b1100_0000, input & 0b0011_1111 | 0b1000_0000] }
@@ -61,7 +60,7 @@ const utf8StateToError
 }
 
 const utf8ByteToCodePointOp
-    : operator.StateScan<number, Utf8State, list.List<i32>>
+    : operator.StateScan<number, Utf8State, List<i32>>
     = state => byte => {
     if (byte < 0x00 || byte > 0xff) {
         return [[errorMask], state]
@@ -98,18 +97,18 @@ const utf8ByteToCodePointOp
 }
 
 const utf8EofToCodePointOp
-    : (state: Utf8State) => readonly[list.List<i32>, Utf8State]
-    = state =>
+: (state: Utf8State) => readonly[List<i32>, Utf8State]
+= state =>
     [state === null ? null : [utf8StateToError(state)], null]
 
 const utf8ByteOrEofToCodePointOp
-    : operator.StateScan<ByteOrEof, Utf8State, list.List<i32>>
-    = state => input => input === null ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
+: operator.StateScan<ByteOrEof, Utf8State, List<i32>>
+= state => input => input === null ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
 
 const eofList
-    : list.List<ByteOrEof>
-    = [null]
+: List<ByteOrEof>
+= [null]
 
 export const toCodePointList
-    : (input: list.List<u8>) => list.List<i32>
-    = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
+: (input: List<u8>) => List<i32>
+= input => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])))

package/types/bigint/module.f.ts

@@ -1,8 +1,7 @@
 import * as compare from '../function/compare/module.f.ts'
 import * as Operator from '../function/operator/module.f.ts'
 const { unsafeCmp } = compare
-import * as list from '../list/module.f.ts'
-const { reduce } = list
+import { reduce } from '../list/module.f.ts'
 
 type Unary = Operator.Unary<bigint, bigint>
 

package/types/byte_set/module.f.ts

@@ -1,5 +1,4 @@
-import * as f from '../function/module.f.ts'
-const { compose } = f
+import { compose } from '../function/module.f.ts'
 import * as RangeMap from '../range_map/module.f.ts'
 import * as SortedSet from '../sorted_set/module.f.ts'
 import * as list from '../list/module.f.ts'

package/types/list/module.f.ts

@@ -1,14 +1,17 @@
-import * as function_ from '../function/module.f.ts'
-const { identity, fn, compose } = function_
-import * as operator from '../function/operator/module.f.ts'
-const {
+import { identity, fn, compose } from '../function/module.f.ts'
+import {
     addition,
     logicalNot,
     strictEqual,
     stateScanToScan,
     foldToScan,
-    reduceToScan
-} = operator
+    reduceToScan,
+    type Scan,
+    type StateScan,
+    type Fold,
+    type Reduce,
+    type Equal,
+} from '../function/operator/module.f.ts'
 
 export type List<T> = NotLazy<T> | Thunk<T>
 
@@ -248,30 +251,30 @@ export const cycle
 }
 
 const scanStep
-: <I, O>(op: operator.Scan<I, O>) => (ne: NonEmpty<I>) => List<O>
+: <I, O>(op: Scan<I, O>) => (ne: NonEmpty<I>) => List<O>
 = op => ne => {
     const [first, newOp] = op(ne.first)
     return { first, tail: scan(newOp)(ne.tail) }
 }
 
 export const scan
-: <I, O>(op: operator.Scan<I, O>) => (input: List<I>) => Thunk<O>
+: <I, O>(op: Scan<I, O>) => (input: List<I>) => Thunk<O>
 = op => apply(scanStep(op))
 
 export const stateScan
-: <I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>
+: <I, S, O>(op: StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>
 = op => compose(stateScanToScan(op))(scan)
 
 export const foldScan
-: <I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>
+: <I,O>(op: Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>
 = op => compose(foldToScan(op))(scan)
 
 export const fold
-: <I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O
+: <I,O>(op: Fold<I, O>) => (init: O) => (input: List<I>) => O
 = op => init => compose(foldScan(op)(init))(last(init))
 
 export const reduce
-: <T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T
+: <T>(op: Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T
 = op => def => compose(scan(reduceToScan(op)))(last(def))
 
 const lengthList
@@ -304,7 +307,7 @@ export const entries
 = input => {
     type T = typeof input extends List<infer T> ? T : never
     const o
-    : operator.StateScan<T, number, Entry<T>>
+    : StateScan<T, number, Entry<T>>
     = entryOperator
     return stateScan(o)(0)(input)
 }
@@ -328,9 +331,9 @@ export const zip
 }
 
 export const equal
-: <T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean
+: <T>(e: Equal<T>) => (a: List<T>) => (b: List<T>) => boolean
 = e => {
-    type T = typeof e extends operator.Equal<infer T> ? T : never
+    type T = typeof e extends Equal<infer T> ? T : never
     const f
     : (a: List<T>) => (b: List<T>) => List<boolean>
     = a => b => () => {

package/types/number/module.f.ts

@@ -1,7 +1,5 @@
-import * as list from '../list/module.f.ts'
-const { reduce } = list
-import * as operator from '../function/operator/module.f.ts'
-const { addition, min: minOp, max: maxOp } = operator
+import { reduce } from '../list/module.f.ts'
+import { addition, min as minOp, max as maxOp } from '../function/operator/module.f.ts'
 import * as compare from '../function/compare/module.f.ts'
 const { unsafeCmp } = compare
 

package/types/string/module.f.ts

@@ -1,14 +1,12 @@
 import * as list from '../list/module.f.ts'
 const { reduce: listReduce, repeat: listRepeat } = list
-import * as f from '../function/module.f.ts'
-const { compose } = f
+import { compose } from '../function/module.f.ts'
 import * as compare from '../function/compare/module.f.ts'
 const { unsafeCmp } = compare
-import * as op from '../function/operator/module.f.ts'
-const { join: joinOp, concat: concatOp } = op
+import { join as joinOp, concat as concatOp, type Reduce } from '../function/operator/module.f.ts'
 
 const reduce
-    : (o: op.Reduce<string>) => (input: list.List<string>) => string
+    : (o: Reduce<string>) => (input: list.List<string>) => string
     = o => listReduce(o)('')
 
 export const join = compose(joinOp)(reduce)

package/types/string_set/module.f.ts

@@ -6,17 +6,15 @@ import * as btr from '../btree/remove/module.f.ts'
 const { remove: btreeRemove } = btr
 import * as bts from '../btree/set/module.f.ts'
 const { set: btreeSet } = bts
-export const {
-    values,
-    empty,
-}: { values: (s: StringSet) => list.List<string>, empty: null } = btree
 import * as string from "../string/module.f.ts"
 const { cmp } = string
-import * as list from '../list/module.f.ts'
-const { fold } = list
+import { fold, type List } from '../list/module.f.ts'
 import * as f from '../function/module.f.ts'
 const { compose } = f
 
+export const values: (s: StringSet) => List<string> = btree.values
+export const empty: null = btree.empty
+
 export type StringSet = BtreeTypes.Tree<string>
 
 export const contains