functionalscript 0.2.5 → 0.3.0

package/text/utf16/{test.f.mjs → test.f.ts}

@@ -1,11 +1,12 @@
-import * as encoding from './module.f.mjs'
-import * as json from '../../json/module.f.mjs'
-import * as o from '../../types/object/module.f.mjs'
+import * as encoding from './module.f.ts'
+import * as json from '../../json/module.f.ts'
+import * as o from '../../types/object/module.f.ts'
 const { sort } = o
-import * as list from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.ts'
 
-/** @type {(a: readonly json.Unknown[]) => string} */
-const stringify = a => json.stringify(sort)(a)
+const stringify
+    : (a: readonly json.Unknown[]) => string
+    = a => json.stringify(sort)(a)
 
 export default {
     toCodePointList: [

package/text/utf8/{module.f.mjs → module.f.ts}

@@ -1,23 +1,23 @@
-// @ts-self-types="./module.f.d.mts"
-import * as list from '../../types/list/module.f.mjs'
-import * as operator from '../../types/function/operator/module.f.mjs'
-import * as Array from '../../types/array/module.f.mjs'
+import * as 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
 
-/** @typedef {u8|null} ByteOrEof */
+type ByteOrEof = u8|null
 
-/** @typedef {Array.Array1<number>|Array.Array2<number>|Array.Array3<number>} Utf8NonEmptyState */
+type Utf8NonEmptyState = Array.Array1<number>|Array.Array2<number>|Array.Array3<number>
 
-/** @typedef {null|Utf8NonEmptyState} Utf8State */
+type Utf8State = null|Utf8NonEmptyState
 
-/** @typedef {number} u8 */
+type u8 = number
 
-/** @typedef {number} i32 */
+type i32 = number
 
 const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
 
-/** @type {(input:number) => list.List<u8>} */
-const codePointToUtf8 = input => {
+const codePointToUtf8
+    : (input:number) => list.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] }
     if (input >= 0x0800 && input <= 0xffff) { return [input >> 12 | 0b1110_0000, input >> 6 & 0b0011_1111 | 0b1000_0000, input & 0b0011_1111 | 0b1000_0000] }
@@ -33,8 +33,9 @@ const codePointToUtf8 = input => {
 
 export const fromCodePointList = flatMap(codePointToUtf8)
 
-/** @type {(state: Utf8NonEmptyState) => i32}*/
-const utf8StateToError = state => {
+const utf8StateToError
+    : (state: Utf8NonEmptyState) => i32
+    = state => {
     let x
     switch (state.length) {
         case 1: {
@@ -59,8 +60,9 @@ const utf8StateToError = state => {
     return x | errorMask
 }
 
-/** @type {operator.StateScan<number, Utf8State, list.List<i32>>} */
-const utf8ByteToCodePointOp = state => byte => {
+const utf8ByteToCodePointOp
+    : operator.StateScan<number, Utf8State, list.List<i32>>
+    = state => byte => {
     if (byte < 0x00 || byte > 0xff) {
         return [[errorMask], state]
     }
@@ -95,15 +97,19 @@ const utf8ByteToCodePointOp = state => byte => {
     return [[error, byte | errorMask], null]
 }
 
-/** @type {(state: Utf8State) => readonly[list.List<i32>, Utf8State]} */
-const utf8EofToCodePointOp = state =>
+const utf8EofToCodePointOp
+    : (state: Utf8State) => readonly[list.List<i32>, Utf8State]
+    = state =>
     [state === null ? null : [utf8StateToError(state)], null]
 
-/** @type {operator.StateScan<ByteOrEof, Utf8State, list.List<i32>>} */
-const utf8ByteOrEofToCodePointOp = state => input => input === null ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
+const utf8ByteOrEofToCodePointOp
+    : operator.StateScan<ByteOrEof, Utf8State, list.List<i32>>
+    = state => input => input === null ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
 
-/** @type {list.List<ByteOrEof>} */
-const eofList = [null]
+const eofList
+    : list.List<ByteOrEof>
+    = [null]
 
-/** @type {(input: list.List<u8>) => list.List<i32>} */
-export const toCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
+export const toCodePointList
+    : (input: list.List<u8>) => list.List<i32>
+    = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])))

package/text/utf8/{test.f.mjs → test.f.ts}

@@ -1,8 +1,8 @@
-import * as encoding from './module.f.mjs'
-import * as json from '../../json/module.f.mjs'
-import * as o from '../../types/object/module.f.mjs'
+import * as encoding from './module.f.ts'
+import * as json from '../../json/module.f.ts'
+import * as o from '../../types/object/module.f.ts'
 const { sort } = o
-import * as list from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.ts'
 
 const stringify = json.stringify(sort)
 

package/tsconfig.json

@@ -1,6 +1,9 @@
 {
   "compilerOptions": {
     /* Visit https://aka.ms/tsconfig.json to read more about this file */
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "verbatimModuleSyntax": true,
 
     /* Projects */
     // "incremental": true,                              /* Enable incremental compilation */
@@ -47,7 +50,7 @@
     // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
     // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
     // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */
-    "outDir": "./out",                                   /* Specify an output folder for all emitted files. */
+    // "outDir": "./out",                                   /* Specify an output folder for all emitted files. */
     // "removeComments": true,                           /* Disable emitting comments. */
     "noEmit": true,                                   /* Disable emitting files from a compilation. */
     // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */

package/types/array/module.f.ts

@@ -0,0 +1,89 @@
+import * as option from '../nullable/module.f.ts'
+const { map } = option
+
+export type Array1<T> = readonly[T]
+
+type Index1 = 0
+
+export type Array2<T> = readonly[T, T]
+
+type Tuple2<T0, T1> = readonly[T0, T1]
+
+type Index2 = 0|1
+
+export type Array3<T> = readonly[T, T, T]
+
+type Tuple3<T0, T1, T2> = readonly[T0, T1, T2]
+
+export type Index3 = 0|1|2
+
+export type Array4<T> = readonly[T, T, T, T]
+
+type Index4 = 0|1|2|3
+
+export type Array5<T> = readonly[T, T, T, T, T]
+
+export type Array8<T> = readonly[T, T, T, T, T, T, T, T]
+
+export type Array16<T> = readonly[T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T]
+
+type Index16 = 0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15
+
+type Array1_5<T> = Array1<T>| Array2<T> | Array3<T> | Array4<T> | Array5<T>
+
+export type Index5 = 0|1|2|3|4
+
+export type KeyOf<T> = T extends Array1<infer _> ? Index1 :
+    T extends Array2<infer _> ? Index2 :
+    T extends Array3<infer _> ? Index3 :
+    T extends Array4<infer _> ? Index4 :
+    T extends Array5<infer _> ? Index5 :
+    T extends readonly (infer _)[] ? number :
+    never
+
+const uncheckTail
+    : <T>(_: readonly T[]) => readonly T[]
+    = a => a.slice(1)
+
+const uncheckHead
+    : <T>(_: readonly T[]) => readonly T[]
+    = a => a.slice(0, -1)
+
+export const at
+    : (index: number) => <T>(a: readonly T[]) => T|null
+    = i => a => {
+    const r = a[i]
+    return r === void 0 ? null : r
+}
+
+export const first
+    : <T>(_: readonly T[]) => T|null
+    = at(0)
+
+export const last
+    : <T>(_: readonly T[]) => T|null
+    = a => at(a.length - 1)(a)
+
+export const tail
+    : <T>(_: readonly T[]) => readonly T[] | null
+    = a => a.length === 0 ? null : uncheckTail(a)
+
+export const splitFirst
+    = <T>(a: readonly T[]): readonly[T, readonly T[]]|null => {
+    const split
+        : (_: T) => readonly[T, readonly T[]]
+        = first => [first, uncheckTail(a)]
+    return map(split)(first(a))
+}
+
+export const head
+    : <T>(_: readonly T[]) => readonly T[]|null
+    = a => a.length === 0 ? null : uncheckHead(a)
+
+export const splitLast
+    : <T>(_: readonly T[]) => readonly[readonly T[], T]|null
+    = a => {
+    const lastA = last(a)
+    if (lastA === null) { return null }
+    return [uncheckHead(a), lastA]
+}

package/types/array/{test.f.mjs → test.f.ts}

@@ -1,6 +1,6 @@
-import * as _ from './module.f.mjs'
-import * as json from '../../json/module.f.mjs'
-import * as o from '../object/module.f.mjs'
+import * as _ from './module.f.ts'
+import * as json from '../../json/module.f.ts'
+import * as o from '../object/module.f.ts'
 const { sort } = o
 
 const stringify = json.stringify(sort)

package/types/bigfloat/{module.f.mjs → module.f.ts}

@@ -1,16 +1,16 @@
-// @ts-self-types="./module.f.d.mts"
-import * as bi from '../bigint/module.f.mjs'
+import * as bi from '../bigint/module.f.ts'
 const { abs, sign } = bi
 
-/** @typedef {readonly[bigint,number]} BigFloat */
+export type BigFloat = readonly[bigint,number]
 
-/** @typedef {readonly[BigFloat,bigint]} BigFloatWithRemainder */
+type BigFloatWithRemainder = readonly[BigFloat,bigint]
 
 const twoPow53 = 0b0010_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n
 const twoPow54 = 0b0100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n
 
-/** @type {(value: BigFloat) => (min: bigint) => BigFloat} */
-const increaseMantissa = ([m, e]) => min => {
+const increaseMantissa
+    : (value: BigFloat) => (min: bigint) => BigFloat
+    = ([m, e]) => min => {
     if (m === 0n) {
         return [m, e]
     }
@@ -25,8 +25,9 @@ const increaseMantissa = ([m, e]) => min => {
     }
 }
 
-/** @type {(value: BigFloat) => (max: bigint) => BigFloat} */
-const decreaseMantissa = ([m, e]) => max => {
+const decreaseMantissa
+    : (value: BigFloat) => (max: bigint) => BigFloat
+    = ([m, e]) => max => {
     if (m === 0n) {
         return [m, e]
     }
@@ -41,19 +42,23 @@ const decreaseMantissa = ([m, e]) => max => {
     }
 }
 
-/** @type {(base: bigint) => (exp: number) => bigint} */
-const pow = base => exp => base ** BigInt(exp)
+const pow
+    : (base: bigint) => (exp: number) => bigint
+    = base => exp => base ** BigInt(exp)
 
 const pow5 = pow(5n)
 
-/** @type {(b: BigFloat) => (mul: bigint) => BigFloat} */
-export const multiply = ([m, e]) => mul => [m * mul, e]
+export const multiply
+    : (b: BigFloat) => (mul: bigint) => BigFloat
+    = ([m, e]) => mul => [m * mul, e]
 
-/** @type {(b: BigFloat) => (div: bigint) => BigFloatWithRemainder} */
-const divide = ([m, e]) => div => [[m / div, e], m % div]
+const divide
+    : (b: BigFloat) => (div: bigint) => BigFloatWithRemainder
+    = ([m, e]) => div => [[m / div, e], m % div]
 
-/** @type {(b: BigFloatWithRemainder) => BigFloat} */
-const round53 = ([[m, e], r]) => {
+const round53
+    : (b: BigFloatWithRemainder) => BigFloat
+    = ([[m, e], r]) => {
     const mabs = abs(m)
     const s = BigInt(sign(m))
     const [m54, e54] = decreaseMantissa([mabs, e])(twoPow54)
@@ -67,14 +72,14 @@ const round53 = ([[m, e], r]) => {
     return multiply([m53 + o54, e53])(s)
 }
 
-/** @type {(dec: BigFloat) => BigFloat} */
-export const decToBin = dec => {
+export const decToBin
+    : (dec: BigFloat) => BigFloat
+    = dec => {
     if (dec[0] === 0n) {
         return [0n, 0]
     }
     if (dec[1] >= 0) {
-        /** @type {BigFloat} */
-        const bin = [dec[0] * pow5(dec[1]), dec[1]]
+        const bin: BigFloat = [dec[0] * pow5(dec[1]), dec[1]]
         const inc = increaseMantissa(bin)(twoPow53)
         return round53([inc, 0n])
     }

package/types/bigfloat/{test.f.mjs → test.f.ts}

@@ -1,4 +1,4 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 const { decToBin } = _
 
 export default {

package/types/bigint/{module.f.mjs → module.f.ts}

@@ -1,36 +1,37 @@
-// @ts-self-types="./module.f.d.mts"
-import * as compare from '../function/compare/module.f.mjs'
-import * as Operator from '../function/operator/module.f.mjs'
+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.mjs'
+import * as list from '../list/module.f.ts'
 const { reduce } = list
 
-/** @typedef {Operator.Unary<bigint, bigint>} Unary*/
+type Unary = Operator.Unary<bigint, bigint>
 
-/** @type {(a: bigint) => (b: bigint) => bigint} */
-export const addition = a => b => a + b
+export const addition
+    : (a: bigint) => (b: bigint) => bigint
+    = a => b => a + b
 
 export const sum = reduce(addition)(0n)
 
-/** @type {(a: bigint) => bigint} */
-export const abs = a => a >= 0 ? a : -a
+export const abs
+    : (a: bigint) => bigint
+    = a => a >= 0 ? a : -a
 
-/** @type {(a: bigint) => compare.Sign} */
-export const sign = a => unsafeCmp(a)(0n)
+export const sign
+    : (a: bigint) => compare.Sign
+    = a => unsafeCmp(a)(0n)
 
-/** @type {(a: bigint) => string} */
-export const serialize = a => `${a}n`
+export const serialize
+    : (a: bigint) => string
+    = a => `${a}n`
 
-/**
- * @template T
- * @typedef {{
- *  readonly 0: T
- *  readonly add: Operator.Reduce<T>
- * }} Additive
- */
+type Additive<T> = {
+   readonly 0: T
+   readonly add: Operator.Reduce<T>
+}
 
-/** @type {<T>(a: Additive<T>) => (a: T) => (n: bigint) => T} */
-export const scalar_mul = ({ 0: _0, add }) => a => n => {
+export const scalar_mul
+    : <T>(a: Additive<T>) => (a: T) => (n: bigint) => T
+    = ({ 0: _0, add }) => a => n => {
     let ai = a
     let ni = n
     let result = _0
@@ -54,8 +55,8 @@ export const scalar_mul = ({ 0: _0, add }) => a => n => {
  * - `log2(2n)` returns `1n`,
  * - `log2(15n)` returns `3n`.
  *
- * @param {bigint} v - The input BigInt.
- * @returns {bigint} The base-2 logarithm (floor) of the input BigInt, or `-1n` if the input is less than or equal to 0.
+ * @param v - The input BigInt.
+ * @returns The base-2 logarithm (floor) of the input BigInt, or `-1n` if the input is less than or equal to 0.
  *
  * @remarks
  * The function operates in two phases:
@@ -64,7 +65,7 @@ export const scalar_mul = ({ 0: _0, add }) => a => n => {
  * 2. **Binary Search Phase:** Refines the result by halving the step size and incrementally
  *    determining the exact value of the logarithm.
  */
-export const log2 = v => {
+export const log2 = (v: bigint): bigint => {
     if (v <= 0n) { return -1n }
     let result = 0n
     let i = 1n
@@ -104,14 +105,14 @@ export const log2 = v => {
  * The function handles both positive and negative numbers. For negative inputs, the bit length is calculated
  * based on the absolute value of the number. Zero has a bit length of 0.
  *
- * @param {bigint} v - The input BigInt.
- * @returns {bigint} The bit length of the input BigInt.
+ * @param v - The input BigInt.
+ * @returns The bit length of the input BigInt.
  *
  * @remark
  * The function uses the `log2` function to calculate the position of the most significant bit(MSB)
  * and adds `1n` to account for the MSB itself.For negative numbers, the absolute value is used.
  */
-export const bitLength = v => {
+export const bitLength = (v: bigint): bigint => {
     if (v <= 0n) {
         if (v === 0n) { return 0n }
         v = -v

package/types/bigint/{test.f.mjs → test.f.ts}

@@ -1,4 +1,4 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 const { sum, abs, serialize, log2, bitLength } = _
 
 export default {
@@ -141,4 +141,4 @@ export default {
             },
         ]
     }
-}
+}

package/types/bit_vec/README.md

@@ -0,0 +1,18 @@
+# Vector of Bits
+
+A **vector of bits** is represented as a `bigint`. The value is always positive, and an **empty vector** is denoted by `1n`.
+
+## Key Characteristics
+
+- The **most significant bit** with a value of `1` is called the **`stop bit`**.
+- The **`stop bit`** marks the boundary of the vector.
+- The **`length`** of a vector represents the number of meaningful bits (excluding the **`stop bit`**).
+- An **empty vector** is represented by `1n`, with the implicit **`stop bit`** as the only bit.
+
+## Example
+
+| Vector        | Binary Representation | `length` | Vector Items |
+|---------------|-----------------------|----------|--------------|
+| `0b1001n`     | `0b1001n`             | 3        | `001`        |
+| `0x1FF`       | `0b111111111`         | 8        | `11111111`   |
+| `1n` (empty)  | `0b1`                 | 0        | (none)       |

package/types/bit_vec/module.f.ts

@@ -0,0 +1,185 @@
+import { log2 } from '../bigint/module.f.ts'
+import { flip } from '../function/module.f.ts'
+
+/**
+ * A vector of bits represented as a `bigint`.
+ */
+type Vec = bigint
+
+/**
+ * An empty vector of bits.
+ */
+export const empty = 1n
+
+/**
+ * Calculates the length of the given vector of bits.
+ */
+export const length = log2
+
+/**
+ * Creates a vector of bits of the given `len` and the given unsigned integer.
+ *
+ * @example
+ *
+ * ```js
+ * const vec4 = vec(4n)
+ * const v0 = vec4(5n)     // 0x15n
+ * const v1 = vec4(0x5FEn) // 0x1En
+ * ```
+ */
+export const vec = (len: bigint): (ui: bigint) => Vec => {
+    if (len <= 0n) { return () => empty }
+    const stop = 1n << len
+    const mask = stop - 1n
+    return data => stop | (data & mask)
+}
+
+const mask = (len: bigint) => (1n << len) - 1n
+
+/**
+ * Returns the unsigned integer of the given vector by removing a stop bit.
+ *
+ * @example
+ *
+ * ```js
+ * const vector = vec(8n)(0x5n) // 0x105n
+ * const result = uint(vector); // result is 0x5n
+ * ```
+ */
+export const uint = (v: Vec): bigint => v ^ (1n << length(v))
+
+/**
+ * Extract the least significant unsigned integer from the given vector.
+ *
+ * @example
+ *
+ * ```js
+ * const vector = vec(8n)(0xF5n) // 0x1F5n
+ * const result = uintLsb(4n)(vector); // result is 5n
+ * const result2 = uintLsb(16n)(vector); // result2 is 0xF5n
+ * ```
+ */
+export const uintLsb = (len: bigint): (v: Vec) => bigint => {
+    const m = mask(len)
+    return v => {
+        const result = v & m
+        return result === v ? uint(v) : result
+    }
+}
+
+/**
+ * Removes the first `len` least significant bits from the given vector.
+ *
+ * @example
+ *
+ * ```js
+ * const v = vec(16n)(0x3456n) // 0x13456n
+ * const r = removeLsb(4n)(v) // 0x1345n
+ * const r2 = removeLsb(24n)(v) // 0x1n
+ * ```
+ */
+export const removeLsb = (len: bigint) => (v: Vec): Vec => {
+    const r = v >> len
+    return r === 0n ? empty : r
+}
+
+/**
+ * Extracts the least significant unsigned integer and removes it from the vector.
+ *
+ * @example
+ *
+ * ```js
+ * const vector = vec(8n)(0xF5n) // 0x1F5n
+ * const [result, rest] = popUintLsb(4n)(vector); // result is 5n, rest is 0x1Fn
+ * const [result2, rest2] = popUintLsb(16n)(vector); // result2 is 0xF5n, rest2 is 1n
+ * ```
+ */
+export const popUintLsb = (len: bigint): (v: Vec) => readonly[bigint, Vec] => {
+    const m = mask(len)
+    return v => {
+        const result = v & m
+        return result === v ? [uint(v), empty] : [result, v >> len]
+    }
+}
+
+/**
+ * Extract the most significant unsigned integer of the given `len` from the given vector.
+ *
+ * @example
+ *
+ * ```js
+ * const vector = vec(8n)(0xF5n) // 0x1F5n
+ * const result = uintMsb(4n)(vector); // result is 0xFn
+ * const result2 = uintMsb(16n)(vector); // result2 is 0xF500n
+ * ```
+ */
+export const uintMsb = (len: bigint): (v: Vec) => bigint => {
+    const m = mask(len)
+    return v => (v >> (length(v) - len)) & m
+}
+
+/**
+ * Removes the first `len` most significant bits from the given vector.
+ *
+ * @example
+ *
+ * ```js
+ * const v = vec(16n)(0x3456n) // 0x13456n
+ * const r = removeMsb(4n)(v) // 0x1456n
+ * const r2 = removeMsb(24n)(v) // 0x1n
+ * ```
+ */
+export const removeMsb = (len: bigint) => (v: Vec): Vec => vec(length(v) - len)(v)
+
+/**
+ * Extracts the most significant unsigned integer and removes it from the vector.
+ *
+ * @example
+ *
+ * ```js
+ * const vector = vec(8n)(0xF5n) // 0x1F5n
+ * const [result, rest] = popUintMsb(4n)(vector); // [0xFn, 0x15n]
+ * const [result2, rest2] = popUintMsb(16n)(vector); // [0xF500n, 1n]
+ * ```
+ */
+export const popUintMsb = (len: bigint): (v: Vec) => readonly[bigint, Vec] => {
+    const m = mask(len)
+    return v => {
+        const d = length(v) - len
+        return [(v >> d) & m, vec(d)(v)]
+    }
+}
+
+/**
+ * Concat the given vectors of bits. The first vector is the least significant.
+ *
+ * @example
+ *
+ * ```js
+ * const u8 = vec(8n)
+ * const a = u8(0x45n) // 0x145n
+ * const b = u8(0x89n) // 0x189n
+ * const ab = concatLsb(a)(b) // 0x18945n
+ * ```
+ */
+export const concatLsb = (a: Vec): (b: Vec) => Vec => {
+    const aLen = length(a)
+    const m = mask(aLen)
+    return b => (b << aLen) | (a & m)
+}
+
+/**
+ * Concat the given vectors of bits. The first vector is the most significant.
+ *
+ * @example
+ *
+ * ```js
+ * const u8 = vec(8n)
+ * const a = u8(0x45n) // 0x145n
+ * const b = u8(0x89n) // 0x189n
+ * const ab = concatMsb(a)(b) // 0x14589n
+ * ```
+ */
+export const concatMsb
+    : (b: Vec) => (a: Vec) => Vec
+    = flip(concatLsb)