conjure-js 0.0.12 → 0.0.13

package/src/core/stdlib/strings.ts

@@ -1,17 +1,8 @@
 // Native string helpers used by clojure.string.
 // All public API lives in src/clojure/string.clj; these are private helpers.
-import { isAFunction } from '../assertions'
+import { is } from '../assertions'
 import { EvaluationError } from '../errors'
-import {
-  cljBoolean,
-  cljNativeFunction,
-  cljNativeFunctionWithContext,
-  cljNil,
-  cljNumber,
-  cljString,
-  cljVector,
-  withDoc,
-} from '../factories'
+import { v } from '../factories'
 import { printString } from '../printer'
 import { valueToString } from '../transformations'
 import type {
@@ -37,7 +28,11 @@ function assertStr(val: CljValue | undefined, fnName: string): string {
   return val.value
 }
 
-function assertStrArg(val: CljValue | undefined, pos: string, fnName: string): string {
+function assertStrArg(
+  val: CljValue | undefined,
+  pos: string,
+  fnName: string
+): string {
   if (val === undefined || val.kind !== 'string') {
     throw new EvaluationError(
       `${fnName} expects a string as ${pos} argument${val !== undefined ? `, got ${printString(val)}` : ''}`,
@@ -70,10 +65,12 @@ function buildMatchValue(whole: string, args: unknown[]): CljValue {
     }
   }
   const groups = offsetIdx > 0 ? args.slice(0, offsetIdx) : []
-  if (groups.length === 0) return cljString(whole)
-  return cljVector([
-    cljString(whole),
-    ...groups.map((g) => (g == null ? cljNil() : cljString(String(g)))),
+  if (groups.length === 0) return v.string(whole)
+  return v.vector([
+    v.string(whole),
+    ...groups.map(function mapGroupToClj(g) {
+      return g == null ? v.nil() : v.string(String(g))
+    }),
   ])
 }
 
@@ -103,7 +100,7 @@ function doReplace(
       )
     }
     const re = new RegExp(escapeRegex(matchVal.value), global ? 'g' : '')
-    return cljString(s.replace(re, escapeDollarInReplacement(replVal.value)))
+    return v.string(s.replace(re, escapeDollarInReplacement(replVal.value)))
   }
 
   // --- regex / * ---
@@ -114,18 +111,21 @@ function doReplace(
 
     // regex / string
     if (replVal.kind === 'string') {
-      return cljString(s.replace(jsRe, replVal.value))
+      return v.string(s.replace(jsRe, replVal.value))
     }
 
     // regex / function
-    if (isAFunction(replVal)) {
+    if (is.aFunction(replVal)) {
       const fn = replVal as CljFunction | CljNativeFunction
-      const result = s.replace(jsRe, (whole: string, ...args: unknown[]) => {
-        const matchClj = buildMatchValue(whole, args)
-        const replResult = ctx.applyFunction(fn, [matchClj], callEnv)
-        return valueToString(replResult)
-      })
-      return cljString(result)
+      const result = s.replace(
+        jsRe,
+        function replaceCallback(whole: string, ...args: unknown[]) {
+          const matchClj = buildMatchValue(whole, args)
+          const replResult = ctx.applyFunction(fn, [matchClj], callEnv)
+          return valueToString(replResult)
+        }
+      )
+      return v.string(result)
     }
 
     throw new EvaluationError(
@@ -145,110 +145,122 @@ function doReplace(
 // ---------------------------------------------------------------------------
 
 export const stringFunctions: Record<string, CljValue> = {
-  'str-upper-case*': withDoc(
-    cljNativeFunction('str-upper-case*', (sVal: CljValue) => {
-      return cljString(assertStr(sVal, 'str-upper-case*').toUpperCase())
-    }),
-    'Internal helper. Converts s to upper-case.',
-    [['s']]
-  ),
+  'str-upper-case*': v
+    .nativeFn('str-upper-case*', function strUpperCaseImpl(sVal: CljValue) {
+      return v.string(assertStr(sVal, 'str-upper-case*').toUpperCase())
+    })
+    .doc('Internal helper. Converts s to upper-case.', [['s']]),
 
-  'str-lower-case*': withDoc(
-    cljNativeFunction('str-lower-case*', (sVal: CljValue) => {
-      return cljString(assertStr(sVal, 'str-lower-case*').toLowerCase())
-    }),
-    'Internal helper. Converts s to lower-case.',
-    [['s']]
-  ),
+  'str-lower-case*': v
+    .nativeFn('str-lower-case*', function strLowerCaseImpl(sVal: CljValue) {
+      return v.string(assertStr(sVal, 'str-lower-case*').toLowerCase())
+    })
+    .doc('Internal helper. Converts s to lower-case.', [['s']]),
 
-  'str-trim*': withDoc(
-    cljNativeFunction('str-trim*', (sVal: CljValue) => {
-      return cljString(assertStr(sVal, 'str-trim*').trim())
-    }),
-    'Internal helper. Removes whitespace from both ends of s.',
-    [['s']]
-  ),
+  'str-trim*': v
+    .nativeFn('str-trim*', function strTrimImpl(sVal: CljValue) {
+      return v.string(assertStr(sVal, 'str-trim*').trim())
+    })
+    .doc('Internal helper. Removes whitespace from both ends of s.', [['s']]),
 
-  'str-triml*': withDoc(
-    cljNativeFunction('str-triml*', (sVal: CljValue) => {
-      return cljString(assertStr(sVal, 'str-triml*').trimStart())
-    }),
-    'Internal helper. Removes whitespace from the left of s.',
-    [['s']]
-  ),
+  'str-triml*': v
+    .nativeFn('str-triml*', function strTrimlImpl(sVal: CljValue) {
+      return v.string(assertStr(sVal, 'str-triml*').trimStart())
+    })
+    .doc('Internal helper. Removes whitespace from the left of s.', [['s']]),
 
-  'str-trimr*': withDoc(
-    cljNativeFunction('str-trimr*', (sVal: CljValue) => {
-      return cljString(assertStr(sVal, 'str-trimr*').trimEnd())
-    }),
-    'Internal helper. Removes whitespace from the right of s.',
-    [['s']]
-  ),
+  'str-trimr*': v
+    .nativeFn('str-trimr*', function strTrimrImpl(sVal: CljValue) {
+      return v.string(assertStr(sVal, 'str-trimr*').trimEnd())
+    })
+    .doc('Internal helper. Removes whitespace from the right of s.', [['s']]),
 
-  'str-reverse*': withDoc(
-    cljNativeFunction('str-reverse*', (sVal: CljValue) => {
-      return cljString([...assertStr(sVal, 'str-reverse*')].reverse().join(''))
-    }),
-    'Internal helper. Returns s with its characters reversed (Unicode-safe).',
-    [['s']]
-  ),
+  'str-reverse*': v
+    .nativeFn('str-reverse*', function strReverseImpl(sVal: CljValue) {
+      return v.string([...assertStr(sVal, 'str-reverse*')].reverse().join(''))
+    })
+    .doc(
+      'Internal helper. Returns s with its characters reversed (Unicode-safe).',
+      [['s']]
+    ),
 
-  'str-starts-with*': withDoc(
-    cljNativeFunction('str-starts-with*', (sVal: CljValue, substrVal: CljValue) => {
-      const s = assertStr(sVal, 'str-starts-with*')
-      const substr = assertStrArg(substrVal, 'second', 'str-starts-with*')
-      return cljBoolean(s.startsWith(substr))
-    }),
-    'Internal helper. Returns true if s starts with substr.',
-    [['s', 'substr']]
-  ),
+  'str-starts-with*': v
+    .nativeFn(
+      'str-starts-with*',
+      function strStartsWithImpl(sVal: CljValue, substrVal: CljValue) {
+        const s = assertStr(sVal, 'str-starts-with*')
+        const substr = assertStrArg(substrVal, 'second', 'str-starts-with*')
+        return v.boolean(s.startsWith(substr))
+      }
+    )
+    .doc('Internal helper. Returns true if s starts with substr.', [
+      ['s', 'substr'],
+    ]),
 
-  'str-ends-with*': withDoc(
-    cljNativeFunction('str-ends-with*', (sVal: CljValue, substrVal: CljValue) => {
-      const s = assertStr(sVal, 'str-ends-with*')
-      const substr = assertStrArg(substrVal, 'second', 'str-ends-with*')
-      return cljBoolean(s.endsWith(substr))
-    }),
-    'Internal helper. Returns true if s ends with substr.',
-    [['s', 'substr']]
-  ),
+  'str-ends-with*': v
+    .nativeFn(
+      'str-ends-with*',
+      function strEndsWithImpl(sVal: CljValue, substrVal: CljValue) {
+        const s = assertStr(sVal, 'str-ends-with*')
+        const substr = assertStrArg(substrVal, 'second', 'str-ends-with*')
+        return v.boolean(s.endsWith(substr))
+      }
+    )
+    .doc('Internal helper. Returns true if s ends with substr.', [
+      ['s', 'substr'],
+    ]),
 
-  'str-includes*': withDoc(
-    cljNativeFunction('str-includes*', (sVal: CljValue, substrVal: CljValue) => {
-      const s = assertStr(sVal, 'str-includes*')
-      const substr = assertStrArg(substrVal, 'second', 'str-includes*')
-      return cljBoolean(s.includes(substr))
-    }),
-    'Internal helper. Returns true if s contains substr.',
-    [['s', 'substr']]
-  ),
+  'str-includes*': v
+    .nativeFn(
+      'str-includes*',
+      function strIncludesImpl(sVal: CljValue, substrVal: CljValue) {
+        const s = assertStr(sVal, 'str-includes*')
+        const substr = assertStrArg(substrVal, 'second', 'str-includes*')
+        return v.boolean(s.includes(substr))
+      }
+    )
+    .doc('Internal helper. Returns true if s contains substr.', [
+      ['s', 'substr'],
+    ]),
 
-  'str-index-of*': withDoc(
-    cljNativeFunction('str-index-of*', (sVal: CljValue, valVal: CljValue, fromVal?: CljValue) => {
-      const s = assertStr(sVal, 'str-index-of*')
-      const needle = assertStrArg(valVal, 'second', 'str-index-of*')
-      let idx: number
-      if (fromVal !== undefined && fromVal.kind !== 'nil') {
-        if (fromVal.kind !== 'number') {
-          throw new EvaluationError(
-            `str-index-of* expects a number as third argument, got ${printString(fromVal)}`,
-            { fromVal }
-          )
+  'str-index-of*': v
+    .nativeFn(
+      'str-index-of*',
+      function strIndexOfImpl(
+        sVal: CljValue,
+        valVal: CljValue,
+        fromVal?: CljValue
+      ) {
+        const s = assertStr(sVal, 'str-index-of*')
+        const needle = assertStrArg(valVal, 'second', 'str-index-of*')
+        let idx: number
+        if (fromVal !== undefined && fromVal.kind !== 'nil') {
+          if (fromVal.kind !== 'number') {
+            throw new EvaluationError(
+              `str-index-of* expects a number as third argument, got ${printString(fromVal)}`,
+              { fromVal }
+            )
+          }
+          idx = s.indexOf(needle, fromVal.value)
+        } else {
+          idx = s.indexOf(needle)
         }
-        idx = s.indexOf(needle, fromVal.value)
-      } else {
-        idx = s.indexOf(needle)
+        return idx === -1 ? v.nil() : v.number(idx)
       }
-      return idx === -1 ? cljNil() : cljNumber(idx)
-    }),
-    'Internal helper. Returns index of value in s, or nil if not found.',
-    [['s', 'value'], ['s', 'value', 'from-index']]
-  ),
+    )
+    .doc('Internal helper. Returns index of value in s, or nil if not found.', [
+      ['s', 'value'],
+      ['s', 'value', 'from-index'],
+    ]),
 
-  'str-last-index-of*': withDoc(
-    cljNativeFunction(
+  'str-last-index-of*': v
+    .nativeFn(
       'str-last-index-of*',
-      (sVal: CljValue, valVal: CljValue, fromVal?: CljValue) => {
+      function strLastIndexOfImpl(
+        sVal: CljValue,
+        valVal: CljValue,
+        fromVal?: CljValue
+      ) {
         const s = assertStr(sVal, 'str-last-index-of*')
         const needle = assertStrArg(valVal, 'second', 'str-last-index-of*')
         let idx: number
@@ -263,39 +275,54 @@ export const stringFunctions: Record<string, CljValue> = {
         } else {
           idx = s.lastIndexOf(needle)
         }
-        return idx === -1 ? cljNil() : cljNumber(idx)
+        return idx === -1 ? v.nil() : v.number(idx)
       }
+    )
+    .doc(
+      'Internal helper. Returns last index of value in s, or nil if not found.',
+      [
+        ['s', 'value'],
+        ['s', 'value', 'from-index'],
+      ]
     ),
-    'Internal helper. Returns last index of value in s, or nil if not found.',
-    [['s', 'value'], ['s', 'value', 'from-index']]
-  ),
 
-  'str-replace*': withDoc(
-    cljNativeFunctionWithContext(
+  'str-replace*': v
+    .nativeFnCtx(
       'str-replace*',
-      (
+      function strReplaceImpl(
         ctx: EvaluationContext,
         callEnv: Env,
         sVal: CljValue,
         matchVal: CljValue,
         replVal: CljValue
-      ) => doReplace(ctx, callEnv, 'str-replace*', sVal, matchVal, replVal, true)
+      ) {
+        return doReplace(
+          ctx,
+          callEnv,
+          'str-replace*',
+          sVal,
+          matchVal,
+          replVal,
+          true
+        )
+      }
+    )
+    .doc(
+      'Internal helper. Replaces all occurrences of match with replacement in s.',
+      [['s', 'match', 'replacement']]
     ),
-    'Internal helper. Replaces all occurrences of match with replacement in s.',
-    [['s', 'match', 'replacement']]
-  ),
 
-  'str-replace-first*': withDoc(
-    cljNativeFunctionWithContext(
+  'str-replace-first*': v
+    .nativeFnCtx(
       'str-replace-first*',
-      (
+      function strReplaceFirstImpl(
         ctx: EvaluationContext,
         callEnv: Env,
         sVal: CljValue,
         matchVal: CljValue,
         replVal: CljValue
-      ) =>
-        doReplace(
+      ) {
+        return doReplace(
           ctx,
           callEnv,
           'str-replace-first*',
@@ -304,8 +331,10 @@ export const stringFunctions: Record<string, CljValue> = {
           replVal,
           false
         )
+      }
+    )
+    .doc(
+      'Internal helper. Replaces the first occurrence of match with replacement in s.',
+      [['s', 'match', 'replacement']]
     ),
-    'Internal helper. Replaces the first occurrence of match with replacement in s.',
-    [['s', 'match', 'replacement']]
-  ),
 }