conjure-js 0.0.12 → 0.0.13

package/src/core/stdlib/predicates.ts

@@ -1,228 +1,366 @@
 // Predicates & logical: nil?, true?, false?, truthy?, falsy?, not, not=,
 // number?, string?, boolean?, vector?, list?, map?, keyword?, symbol?, fn?,
 // coll?, some, every?
-import {
-  isAFunction,
-  isCollection,
-  isEqual,
-  isFalsy,
-  isKeyword,
-  isSeqable,
-  isSymbol,
-  isTruthy,
-  isList,
-  isVector,
-  isMap,
-} from '../assertions'
-import { applyFunction } from '../evaluator'
+import { is } from '../assertions'
 import { EvaluationError } from '../errors'
-import { cljBoolean, cljNativeFunction, cljNil, withDoc } from '../factories'
+import { v } from '../factories'
 import { printString } from '../printer'
 import { toSeq } from '../transformations'
-import type { CljValue } from '../types'
+import type { CljNumber, CljValue, Env, EvaluationContext } from '../types'
 
 export const predicateFunctions: Record<string, CljValue> = {
-  'nil?': withDoc(
-    cljNativeFunction('nil?', (arg: CljValue) => {
-      return cljBoolean(arg.kind === 'nil')
-    }),
-    'Returns true if the value is nil, false otherwise.',
-    [['arg']]
-  ),
-  'true?': withDoc(
-    cljNativeFunction('true?', (arg: CljValue) => {
+  'nil?': v
+    .nativeFn('nil?', function nilPredImpl(arg: CljValue) {
+      return v.boolean(arg.kind === 'nil')
+    })
+    .doc('Returns true if the value is nil, false otherwise.', [['arg']]),
+  'true?': v
+    .nativeFn('true?', function truePredImpl(arg: CljValue) {
       // returns true if the value is a boolean and true
       if (arg.kind !== 'boolean') {
-        return cljBoolean(false)
+        return v.boolean(false)
       }
-      return cljBoolean(arg.value === true)
-    }),
-    'Returns true if the value is a boolean and true, false otherwise.',
-    [['arg']]
-  ),
-  'false?': withDoc(
-    cljNativeFunction('false?', (arg: CljValue) => {
+      return v.boolean(arg.value === true)
+    })
+    .doc('Returns true if the value is a boolean and true, false otherwise.', [
+      ['arg'],
+    ]),
+  'false?': v
+    .nativeFn('false?', function falsePredImpl(arg: CljValue) {
       // returns true if the value is a boolean and false
       if (arg.kind !== 'boolean') {
-        return cljBoolean(false)
+        return v.boolean(false)
       }
-      return cljBoolean(arg.value === false)
-    }),
-    'Returns true if the value is a boolean and false, false otherwise.',
-    [['arg']]
-  ),
-  'truthy?': withDoc(
-    cljNativeFunction('truthy?', (arg: CljValue) => {
-      return cljBoolean(isTruthy(arg))
-    }),
-    'Returns true if the value is not nil or false, false otherwise.',
-    [['arg']]
-  ),
-  'falsy?': withDoc(
-    cljNativeFunction('falsy?', (arg: CljValue) => {
-      return cljBoolean(isFalsy(arg))
-    }),
-    'Returns true if the value is nil or false, false otherwise.',
-    [['arg']]
-  ),
-  // not: withDoc(
-  //   cljNativeFunction('not', (arg: CljValue) => {
-  //     return cljBoolean(!isTruthy(arg))
-  //   }),
-  //   'Returns the negation of the truthiness of the value.',
-  //   [['arg']]
-  // ),
-  'not=': withDoc(
-    cljNativeFunction('not=', (...vals: CljValue[]) => {
+      return v.boolean(arg.value === false)
+    })
+    .doc('Returns true if the value is a boolean and false, false otherwise.', [
+      ['arg'],
+    ]),
+  'truthy?': v
+    .nativeFn('truthy?', function truthyPredImpl(arg: CljValue) {
+      return v.boolean(is.truthy(arg))
+    })
+    .doc('Returns true if the value is not nil or false, false otherwise.', [
+      ['arg'],
+    ]),
+  'falsy?': v
+    .nativeFn('falsy?', function falsyPredImpl(arg: CljValue) {
+      return v.boolean(is.falsy(arg))
+    })
+    .doc('Returns true if the value is nil or false, false otherwise.', [
+      ['arg'],
+    ]),
+  'not=': v
+    .nativeFn('not=', function notEqualImpl(...vals: CljValue[]) {
       if (vals.length < 2) {
         throw new EvaluationError('not= expects at least two arguments', {
           args: vals,
         })
       }
       for (let i = 1; i < vals.length; i++) {
-        if (!isEqual(vals[i], vals[i - 1])) {
-          return cljBoolean(true)
+        if (!is.equal(vals[i], vals[i - 1])) {
+          return v.boolean(true)
         }
       }
-      return cljBoolean(false)
-    }),
-    'Returns true if any two adjacent arguments are not equal, false otherwise.',
-    [['&', 'vals']]
-  ),
-  'number?': withDoc(
-    cljNativeFunction('number?', (x: CljValue) =>
-      cljBoolean(x !== undefined && x.kind === 'number')
+      return v.boolean(false)
+    })
+    .doc(
+      'Returns true if any two adjacent arguments are not equal, false otherwise.',
+      [['&', 'vals']]
     ),
-    'Returns true if the value is a number, false otherwise.',
-    [['x']]
-  ),
+  'number?': v
+    .nativeFn('number?', function numberPredImpl(x: CljValue) {
+      return v.boolean(x !== undefined && x.kind === 'number')
+    })
+    .doc('Returns true if the value is a number, false otherwise.', [['x']]),
 
-  'string?': withDoc(
-    cljNativeFunction('string?', (x: CljValue) =>
-      cljBoolean(x !== undefined && x.kind === 'string')
-    ),
-    'Returns true if the value is a string, false otherwise.',
-    [['x']]
-  ),
+  'string?': v
+    .nativeFn('string?', function stringPredImpl(x: CljValue) {
+      return v.boolean(x !== undefined && is.string(x))
+    })
+    .doc('Returns true if the value is a string, false otherwise.', [['x']]),
 
-  'boolean?': withDoc(
-    cljNativeFunction('boolean?', (x: CljValue) =>
-      cljBoolean(x !== undefined && x.kind === 'boolean')
-    ),
-    'Returns true if the value is a boolean, false otherwise.',
-    [['x']]
-  ),
+  'boolean?': v
+    .nativeFn('boolean?', function booleanPredImpl(x: CljValue) {
+      return v.boolean(x !== undefined && x.kind === 'boolean')
+    })
+    .doc('Returns true if the value is a boolean, false otherwise.', [['x']]),
 
-  'vector?': withDoc(
-    cljNativeFunction('vector?', (x: CljValue) =>
-      cljBoolean(x !== undefined && isVector(x))
-    ),
-    'Returns true if the value is a vector, false otherwise.',
-    [['x']]
-  ),
-
-  'list?': withDoc(
-    cljNativeFunction('list?', (x: CljValue) =>
-      cljBoolean(x !== undefined && isList(x))
-    ),
-    'Returns true if the value is a list, false otherwise.',
-    [['x']]
-  ),
+  'vector?': v
+    .nativeFn('vector?', function vectorPredImpl(x: CljValue) {
+      return v.boolean(x !== undefined && is.vector(x))
+    })
+    .doc('Returns true if the value is a vector, false otherwise.', [['x']]),
 
-  'map?': withDoc(
-    cljNativeFunction('map?', (x: CljValue) =>
-      cljBoolean(x !== undefined && isMap(x))
-    ),
-    'Returns true if the value is a map, false otherwise.',
-    [['x']]
-  ),
+  'list?': v
+    .nativeFn('list?', function listPredImpl(x: CljValue) {
+      return v.boolean(x !== undefined && is.list(x))
+    })
+    .doc('Returns true if the value is a list, false otherwise.', [['x']]),
 
-  'keyword?': withDoc(
-    cljNativeFunction('keyword?', (x: CljValue) =>
-      cljBoolean(x !== undefined && isKeyword(x))
-    ),
-    'Returns true if the value is a keyword, false otherwise.',
-    [['x']]
-  ),
+  'map?': v
+    .nativeFn('map?', function mapPredImpl(x: CljValue) {
+      return v.boolean(x !== undefined && is.map(x))
+    })
+    .doc('Returns true if the value is a map, false otherwise.', [['x']]),
 
-  'qualified-keyword?': withDoc(
-    cljNativeFunction('qualified-keyword?', (x: CljValue) =>
-      cljBoolean(x !== undefined && isKeyword(x) && x.name.includes('/'))
-    ),
-    'Returns true if the value is a qualified keyword, false otherwise.',
-    [['x']]
-  ),
+  'keyword?': v
+    .nativeFn('keyword?', function keywordPredImpl(x: CljValue) {
+      return v.boolean(x !== undefined && is.keyword(x))
+    })
+    .doc('Returns true if the value is a keyword, false otherwise.', [['x']]),
 
-  'symbol?': withDoc(
-    cljNativeFunction('symbol?', (x: CljValue) =>
-      cljBoolean(x !== undefined && isSymbol(x))
-    ),
-    'Returns true if the value is a symbol, false otherwise.',
-    [['x']]
-  ),
+  'qualified-keyword?': v
+    .nativeFn(
+      'qualified-keyword?',
+      function qualifiedKeywordPredImpl(x: CljValue) {
+        return v.boolean(
+          x !== undefined && is.keyword(x) && x.name.includes('/')
+        )
+      }
+    )
+    .doc('Returns true if the value is a qualified keyword, false otherwise.', [
+      ['x'],
+    ]),
 
-  'qualified-symbol?': withDoc(
-    cljNativeFunction('qualified-symbol?', (x: CljValue) =>
-      cljBoolean(x !== undefined && isSymbol(x) && x.name.includes('/'))
-    ),
-    'Returns true if the value is a qualified symbol, false otherwise.',
-    [['x']]
-  ),
+  'symbol?': v
+    .nativeFn('symbol?', function symbolPredImpl(x: CljValue) {
+      return v.boolean(x !== undefined && is.symbol(x))
+    })
+    .doc('Returns true if the value is a symbol, false otherwise.', [['x']]),
 
-  'fn?': withDoc(
-    cljNativeFunction('fn?', (x: CljValue) =>
-      cljBoolean(x !== undefined && isAFunction(x))
-    ),
-    'Returns true if the value is a function, false otherwise.',
-    [['x']]
-  ),
+  'namespace?': v
+    .nativeFn('namespace?', function namespaceQImpl(x: CljValue) {
+      return v.boolean(x !== undefined && x.kind === 'namespace')
+    })
+    .doc('Returns true if x is a namespace.', [['x']]),
 
-  'coll?': withDoc(
-    cljNativeFunction('coll?', (x: CljValue) =>
-      cljBoolean(x !== undefined && isCollection(x))
-    ),
-    'Returns true if the value is a collection, false otherwise.',
-    [['x']]
-  ),
-  some: withDoc(
-    cljNativeFunction('some', (pred: CljValue, coll: CljValue): CljValue => {
-      if (pred === undefined || !isAFunction(pred)) {
-        throw EvaluationError.atArg(`some expects a function as first argument${pred !== undefined ? `, got ${printString(pred)}` : ''}`, { pred }, 0)
-      }
-      if (coll === undefined) {
-        return cljNil()
-      }
-      if (!isSeqable(coll)) {
-        throw EvaluationError.atArg(`some expects a collection or string as second argument, got ${printString(coll)}`, { coll }, 1)
+  'qualified-symbol?': v
+    .nativeFn(
+      'qualified-symbol?',
+      function qualifiedSymbolPredImpl(x: CljValue) {
+        return v.boolean(
+          x !== undefined && is.symbol(x) && x.name.includes('/')
+        )
       }
-      for (const item of toSeq(coll)) {
-        const result = applyFunction(pred, [item])
-        if (isTruthy(result)) {
-          return result
+    )
+    .doc('Returns true if the value is a qualified symbol, false otherwise.', [
+      ['x'],
+    ]),
+
+  'fn?': v
+    .nativeFn('fn?', function fnPredImpl(x: CljValue) {
+      return v.boolean(x !== undefined && is.aFunction(x))
+    })
+    .doc('Returns true if the value is a function, false otherwise.', [['x']]),
+
+  'coll?': v
+    .nativeFn('coll?', function collPredImpl(x: CljValue) {
+      return v.boolean(x !== undefined && is.collection(x))
+    })
+    .doc('Returns true if the value is a collection, false otherwise.', [
+      ['x'],
+    ]),
+  some: v
+    .nativeFnCtx(
+      'some',
+      function someImpl(
+        ctx: EvaluationContext,
+        callEnv: Env,
+        pred: CljValue,
+        coll: CljValue
+      ): CljValue {
+        if (pred === undefined || !is.aFunction(pred)) {
+          throw EvaluationError.atArg(
+            `some expects a function as first argument${pred !== undefined ? `, got ${printString(pred)}` : ''}`,
+            { pred },
+            0
+          )
+        }
+        if (coll === undefined) {
+          return v.nil()
+        }
+        if (!is.seqable(coll)) {
+          throw EvaluationError.atArg(
+            `some expects a collection or string as second argument, got ${printString(coll)}`,
+            { coll },
+            1
+          )
+        }
+        for (const item of toSeq(coll)) {
+          const result = ctx.applyFunction(pred, [item], callEnv)
+          if (is.truthy(result)) {
+            return result
+          }
         }
+        return v.nil()
       }
-      return cljNil()
-    }),
-    'Returns the first truthy result of applying pred to each item in coll, or nil if no item satisfies pred.',
-    [['pred', 'coll']]
-  ),
-
-  'every?': withDoc(
-    cljNativeFunction('every?', (pred: CljValue, coll: CljValue): CljValue => {
-      if (pred === undefined || !isAFunction(pred)) {
-        throw EvaluationError.atArg(`every? expects a function as first argument${pred !== undefined ? `, got ${printString(pred)}` : ''}`, { pred }, 0)
+    )
+    .doc(
+      'Returns the first truthy result of applying pred to each item in coll, or nil if no item satisfies pred.',
+      [['pred', 'coll']]
+    ),
+
+  'every?': v
+    .nativeFnCtx(
+      'every?',
+      function everyPredImpl(
+        ctx: EvaluationContext,
+        callEnv: Env,
+        pred: CljValue,
+        coll: CljValue
+      ): CljValue {
+        if (pred === undefined || !is.aFunction(pred)) {
+          throw EvaluationError.atArg(
+            `every? expects a function as first argument${pred !== undefined ? `, got ${printString(pred)}` : ''}`,
+            { pred },
+            0
+          )
+        }
+        if (coll === undefined || !is.seqable(coll)) {
+          throw EvaluationError.atArg(
+            `every? expects a collection or string as second argument${coll !== undefined ? `, got ${printString(coll)}` : ''}`,
+            { coll },
+            1
+          )
+        }
+        for (const item of toSeq(coll)) {
+          if (is.falsy(ctx.applyFunction(pred, [item], callEnv))) {
+            return v.boolean(false)
+          }
+        }
+        return v.boolean(true)
       }
-      if (coll === undefined || !isSeqable(coll)) {
-        throw EvaluationError.atArg(`every? expects a collection or string as second argument${coll !== undefined ? `, got ${printString(coll)}` : ''}`, { coll }, 1)
+    )
+    .doc('Returns true if all items in coll satisfy pred, false otherwise.', [
+      ['pred', 'coll'],
+    ]),
+
+  'identical?': v
+    .nativeFn(
+      'identical?',
+      function identicalPredImpl(x: CljValue, y: CljValue) {
+        return v.boolean(x === y)
       }
-      for (const item of toSeq(coll)) {
-        if (isFalsy(applyFunction(pred, [item]))) {
-          return cljBoolean(false)
+    )
+    .doc('Tests if 2 arguments are the same object (reference equality).', [
+      ['x', 'y'],
+    ]),
+
+  'seqable?': v
+    .nativeFn('seqable?', function seqablePredImpl(x: CljValue) {
+      return v.boolean(x !== undefined && is.seqable(x))
+    })
+    .doc('Return true if the seq function is supported for x.', [['x']]),
+
+  'sequential?': v
+    .nativeFn('sequential?', function sequentialPredImpl(x: CljValue) {
+      return v.boolean(x !== undefined && (is.list(x) || is.vector(x)))
+    })
+    .doc('Returns true if coll is a sequential collection (list or vector).', [
+      ['coll'],
+    ]),
+
+  'associative?': v
+    .nativeFn('associative?', function associativePredImpl(x: CljValue) {
+      return v.boolean(x !== undefined && (is.map(x) || is.vector(x)))
+    })
+    .doc('Returns true if coll implements Associative (map or vector).', [
+      ['coll'],
+    ]),
+
+  'counted?': v
+    .nativeFn('counted?', function countedPredImpl(x: CljValue) {
+      return v.boolean(
+        x !== undefined &&
+          (is.list(x) ||
+            is.vector(x) ||
+            is.map(x) ||
+            x.kind === 'set' ||
+            is.string(x))
+      )
+    })
+    .doc('Returns true if coll implements count in constant time.', [['coll']]),
+
+  'int?': v
+    .nativeFn('int?', function intPredImpl(x: CljValue) {
+      return v.boolean(
+        x !== undefined &&
+          x.kind === 'number' &&
+          Number.isInteger((x as import('../types').CljNumber).value)
+      )
+    })
+    .doc('Return true if x is a fixed precision integer.', [['x']]),
+
+  'double?': v
+    .nativeFn('double?', function doublePredImpl(x: CljValue) {
+      return v.boolean(x !== undefined && x.kind === 'number')
+    })
+    .doc('Return true if x is a Double (all numbers in JS are doubles).', [
+      ['x'],
+    ]),
+
+  'NaN?': v
+    .nativeFn('NaN?', function nanPredImpl(x: CljValue) {
+      return v.boolean(
+        x !== undefined && x.kind === 'number' && isNaN((x as CljNumber).value)
+      )
+    })
+    .doc('Returns true if num is NaN, else false.', [['num']]),
+
+  'infinite?': v
+    .nativeFn('infinite?', function infinitePredImpl(x: CljValue) {
+      return v.boolean(
+        x !== undefined &&
+          x.kind === 'number' &&
+          !isFinite((x as CljNumber).value)
+      )
+    })
+    .doc('Returns true if num is positive or negative infinity, else false.', [
+      ['num'],
+    ]),
+
+  compare: v
+    .nativeFn(
+      'compare',
+      function compareImpl(x: CljValue, y: CljValue): CljValue {
+        if (is.nil(x) && is.nil(y)) return v.number(0)
+        if (is.nil(x)) return v.number(-1)
+        if (is.nil(y)) return v.number(1)
+        if (is.number(x) && is.number(y)) {
+          return v.number(
+            (x as CljNumber).value < (y as CljNumber).value
+              ? -1
+              : (x as CljNumber).value > (y as CljNumber).value
+                ? 1
+                : 0
+          )
         }
+        if (is.string(x) && is.string(y)) {
+          return v.number(x.value < y.value ? -1 : x.value > y.value ? 1 : 0)
+        }
+        if (is.keyword(x) && is.keyword(y)) {
+          return v.number(x.name < y.name ? -1 : x.name > y.name ? 1 : 0)
+        }
+        throw new EvaluationError(
+          `compare: cannot compare ${printString(x)} to ${printString(y)}`,
+          { x, y }
+        )
+      }
+    )
+    .doc('Comparator. Returns a negative number, zero, or a positive number.', [
+      ['x', 'y'],
+    ]),
+
+  hash: v
+    .nativeFn('hash', function hashImpl(x: CljValue) {
+      // Simple hash — consistent within a session, not cryptographic
+      const s = printString(x)
+      let h = 0
+      for (let i = 0; i < s.length; i++) {
+        h = (Math.imul(31, h) + s.charCodeAt(i)) | 0
       }
-      return cljBoolean(true)
-    }),
-    'Returns true if all items in coll satisfy pred, false otherwise.',
-    [['pred', 'coll']]
-  ),
+      return v.number(h)
+    })
+    .doc('Returns the hash code of its argument.', [['x']]),
 }