functionalscript 0.3.1 → 0.3.3

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/crypto/sha2/module.f.ts

@@ -206,6 +206,10 @@ export const computeSha224
     : (input: readonly number[]) => (bitsCount: number) => Hash8
     = compute(init224)
 
-export const compress256 = compress(init256)
+export const compress256
+: (data: Array16) => Hash8
+= compress(init256)
 
-export const compress224 = compress(init224)
+export const compress224
+: (data: Array16) => Hash8
+= compress(init224)

package/deno.json

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

package/dev/module.f.ts

@@ -1 +1 @@
-export const todo = () => { throw 'not implemented' }
+export const todo = (): never => { throw 'not implemented' }

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))
 }
 
@@ -79,7 +85,9 @@ const toInit
     : () => ToResult
     = () => () => [[], init]
 
-export const init = create([
+export const init
+: ToResult
+= create([
     codePointRange(one(terminal))(toInit),
     rangeSet(['\t', ' ', '\n', '\r'])(toInit),
     range('!')(() => () => [['!'], unexpectedSymbol]),

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,37 +69,41 @@ 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]])
 }
 
-export const html = compose(element)(listConcat(['<!DOCTYPE html>']))
+export const html
+: (_: Element) => List<string>
+= compose(element)(listConcat(['<!DOCTYPE html>']))
 
-export const htmlToString = compose(html)(stringConcat)
+export const htmlToString
+: (_: Element) => string
+= compose(html)(stringConcat)

package/json/serializer/module.f.ts

@@ -59,9 +59,13 @@ const wrap
     return input => flat([seqOpen, join(input), seqClose])
 }
 
-export const objectWrap = wrap('{')('}')
+export const objectWrap
+: (input: list.List<list.List<string>>) => list.List<string>
+= wrap('{')('}')
 
-export const arrayWrap = wrap('[')(']')
+export const arrayWrap
+: (input: list.List<list.List<string>>) => list.List<string>
+= wrap('[')(']')
 
 type Entry<T> = O.Entry<Unknown<T>>
 

package/package.json

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

package/text/sgr/module.f.ts

@@ -6,12 +6,8 @@ export const sgr
     = c => `\x1b[${c.toString()}m`
 
 export const codes = {
-    /** @readonly */
     reset: sgr(0),
-    /** @readonly */
     bold: sgr(1),
-    /** @readonly */
     fgRed: sgr(31),
-    /** @readonly */
     fgGreen: sgr(32),
 }

package/text/utf16/module.f.ts

@@ -1,10 +1,18 @@
-import * as list from '../../types/list/module.f.ts'
+import {
+    map,
+    flat,
+    stateScan,
+    reduce,
+    flatMap,
+    empty,
+    type List,
+    type Result,
+    type Thunk,
+} 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 +44,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
@@ -48,13 +56,17 @@ const codePointToUtf16
     return [codePoint & 0xffff]
 }
 
-export const fromCodePointList = flatMap(codePointToUtf16)
+export const fromCodePointList
+: (input: List<number>) => Thunk<number>
+= flatMap(codePointToUtf16)
 
-const u16 = contains([0x0000, 0xFFFF])
+const u16
+: (i: number) => boolean
+= 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 +86,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 +114,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, type Thunk } 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] }
@@ -31,7 +30,9 @@ const codePointToUtf8
     return [errorMask]
 }
 
-export const fromCodePointList = flatMap(codePointToUtf8)
+export const fromCodePointList
+: (input: List<number>) => Thunk<number>
+= flatMap(codePointToUtf8)
 
 const utf8StateToError
     : (state: Utf8NonEmptyState) => i32
@@ -61,7 +62,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 +99,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, type List } from '../list/module.f.ts'
 
 type Unary = Operator.Unary<bigint, bigint>
 
@@ -10,7 +9,9 @@ export const addition
     : (a: bigint) => (b: bigint) => bigint
     = a => b => a + b
 
-export const sum = reduce(addition)(0n)
+export const sum
+: (input: List<bigint>) => bigint
+= reduce(addition)(0n)
 
 export const abs
     : (a: 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'
@@ -47,13 +46,17 @@ const difference
 
 // additional operations
 
-export const set = compose(one)(union)
+export const set
+: (_: number) => (b: ByteSet) => ByteSet
+= compose(one)(union)
 
-export const setRange = compose(range)(union)
+export const setRange
+: (_: readonly [number, number]) => (b: ByteSet) => ByteSet
+= compose(range)(union)
 
 export const unset
-    : (n: Byte) => (s: ByteSet) => ByteSet
-    = n => s => difference(s)(one(n))
+: (n: Byte) => (s: ByteSet) => ByteSet
+= n => s => difference(s)(one(n))
 
 const counter = reverse(countdown(256))
 

package/types/function/operator/module.f.ts

@@ -58,6 +58,8 @@ export const max
 : Reduce<number>
 = a => b => a > b ? a : b
 
-export const increment = addition(1)
+export const increment
+: (b: number) => number
+= addition(1)
 
 export const counter = () => increment

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>
 
@@ -219,7 +222,9 @@ export const isEmpty
     .then(logicalNot)
     .result
 
-export const every = fn(map(logicalNot))
+export const every
+: (_: List<boolean>) => boolean
+= fn(map(logicalNot))
     .then(some)
     .then(logicalNot)
     .result
@@ -248,30 +253,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 +309,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 +333,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,16 +1,20 @@
-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, type List } 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
 
-export const sum = reduce(addition)(0)
+export const sum
+: (input: List<number>) => number
+= reduce(addition)(0)
 
-export const min = reduce(minOp)(null)
+export const min
+: (input: List<number>) => number | null
+= reduce(minOp)(null)
 
-export const max = reduce(maxOp)(null)
+export const max
+: (input: List<number>) => number | null
+= reduce(maxOp)(null)
 
 export const cmp
-    : (a: number) => (b: number) => compare.Sign
-    = unsafeCmp
+: (a: number) => (b: number) => compare.Sign
+= unsafeCmp

package/types/string/module.f.ts

@@ -1,24 +1,26 @@
 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 => listReduce(o)('')
+: (o: Reduce<string>) => (input: list.List<string>) => string
+= o => listReduce(o)('')
 
-export const join = compose(joinOp)(reduce)
+export const join
+: (_: string) => (input: list.List<string>) => string
+= compose(joinOp)(reduce)
 
-export const concat = reduce(concatOp)
+export const concat
+: (input: list.List<string>) => string
+= reduce(concatOp)
 
 export const repeat
-    : (n: string) => (v: number) => string
-    = v => compose(listRepeat(v))(concat)
+: (n: string) => (v: number) => string
+= v => compose(listRepeat(v))(concat)
 
 export const cmp
-    : (a: string) => (b: string) => compare.Sign
-    = unsafeCmp
+: (a: string) => (b: string) => compare.Sign
+= unsafeCmp

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
@@ -30,8 +28,10 @@ export const set
     : (value: string) => (s: StringSet) => StringSet
     = value => btreeSet(cmp(value))(() => value)
 
-export const fromValues = fold(set)(null)
+export const fromValues
+: (input: List<string>) => StringSet
+= fold(set)(null)
 
 export const remove
-    : (value: string) => (s: StringSet) => StringSet
-    = compose(cmp)(btreeRemove)
+: (value: string) => (s: StringSet) => StringSet
+= compose(cmp)(btreeRemove)