conjure-js 0.0.11 → 0.0.13

package/src/vite-plugin-clj/index.ts

@@ -1,15 +1,47 @@
 import { execFileSync } from 'node:child_process'
 import { readFileSync, writeFileSync, readdirSync, statSync } from 'node:fs'
-import { resolve, relative, join } from 'node:path'
-import type { Plugin, ResolvedConfig } from 'vite'
+import { resolve, relative, join, dirname } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { createRequire } from 'node:module'
+import type { Plugin, ResolvedConfig, ViteDevServer } from 'vite'
 import { createSession } from '../core/session'
 import type { Session } from '../core/session'
-import { nsToPath, pathToNs } from './namespace-utils'
+import { nsToPath, pathToNs, extractStringRequires } from './namespace-utils'
 import { generateModuleCode, generateDts, safeJsIdentifier } from './codegen'
 import type { CodegenContext } from './codegen'
+import { startBrowserNreplRelay } from '../nrepl/relay'
 
 interface CljPluginOptions {
   sourceRoots?: string[]
+  nreplPort?: number
+  /**
+   * Path to a user-defined session factory (relative to project root).
+   * The factory must be the default export with signature:
+   *   (importMap: Record<string, unknown>) => SessionOptions | null | undefined
+   *
+   * The plugin automatically injects `importModule` (wired to the import map) and
+   * `output` (wired to nREPL output capture + console.log). Do NOT provide these.
+   * Return only what you need: hostBindings, modules, entries, stderr, etc.
+   *
+   * Example: entrypoint: 'src/conjure.ts'
+   */
+  entrypoint?: string
+}
+
+// Resolve the conjure-js core index path regardless of whether this plugin
+// is running from TypeScript source (src/vite-plugin-clj/) or the pre-built
+// output (dist-vite-plugin/). Never use the consuming project's root.
+function resolveCoreIndexPath(): string {
+  const thisDir = dirname(fileURLToPath(import.meta.url))
+  // Source layout: packages/conjure-js/src/vite-plugin-clj/index.ts
+  const fromSource = resolve(thisDir, '../core/index.ts')
+  try {
+    statSync(fromSource)
+    return fromSource
+  } catch {
+    // Built layout: packages/conjure-js/dist-vite-plugin/index.mjs
+    return resolve(thisDir, '../src/core/index.ts')
+  }
 }
 
 const VIRTUAL_SESSION_ID = 'virtual:clj-session'
@@ -22,6 +54,13 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
   let coreIndexPath: string
   let codegenCtx: CodegenContext
   let generatorScriptPath: string
+  let serveMode = false
+  // Collected during configResolved: original CLJ source string → resolved path/package name.
+  // Original string = what the CLJ runtime passes to importModule(s).
+  // Resolved = what Vite should actually import (absolute path for relative, unchanged for pkgs).
+  let stringRequires: Array<{ original: string; resolved: string }> = []
+  // Resolved absolute path to the user-defined session entrypoint (Mode 2), or null (Mode 1).
+  let entrypointPath: string | null = null
 
   function writeFileIfChanged(path: string, content: string) {
     try {
@@ -68,7 +107,7 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
           const source = readFileSync(filePath, 'utf-8')
           const nsNameFromPath = pathToNs(relative(projectRoot, filePath), sourceRoots)
           const dts = generateDts(codegenCtx, nsNameFromPath, source)
-          writeFileIfChanged(filePath + '.d.ts', dts)
+          if (dts) writeFileIfChanged(filePath + '.d.ts', dts)
         } catch {
           continue
         }
@@ -77,14 +116,45 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
   }
 
   function initServerSession() {
+    // Use a require resolver anchored to the project root so that the server session
+    // can import npm packages from the consuming project's node_modules (e.g. date-fns),
+    // not just from the plugin's own node_modules.
+    const projectRequire = createRequire(resolve(projectRoot, 'package.json'))
+
     serverSession = createSession({
       sourceRoots,
       readFile: (filePath: string) =>
         readFileSync(resolve(projectRoot, filePath), 'utf-8'),
       output: () => {},
+      // Node dynamic import — used only during server-side code generation (DTS inference).
+      // In the browser bundle, importModule is a synchronous import map lookup instead.
+      importModule: async (s: string) => {
+        if (!s.startsWith('.') && !s.startsWith('/')) {
+          // Package import: resolve from project root context so the consuming project's
+          // node_modules are searched instead of (or in addition to) the plugin's.
+          try {
+            const resolved = projectRequire.resolve(s)
+            return import(pathToFileURL(resolved).href)
+          } catch {
+            try {
+              return await import(s)
+            } catch {
+              // Package not importable in Node context (browser-only) — return stub
+              // so that namespace loading succeeds and codegen can infer exported vars.
+              return {}
+            }
+          }
+        }
+        // Local/absolute path: may be a browser-only file (e.g. local .ts with DOM deps).
+        // Return a stub so the CLJ namespace still loads for server-side var inference.
+        try {
+          return await import(s)
+        } catch {
+          return {}
+        }
+      },
     })
     codegenCtx = {
-      session: serverSession,
       sourceRoots,
       coreIndexPath,
       virtualSessionId: VIRTUAL_SESSION_ID,
@@ -103,7 +173,40 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
     }
   }
 
+  function scanStringRequires() {
+    // original string (what CLJ runtime passes to importModule) → resolved path/pkg
+    const seen = new Map<string, string>()
+    for (const root of sourceRoots) {
+      const rootPath = resolve(projectRoot, root)
+      for (const filePath of collectCljFiles(rootPath)) {
+        try {
+          const source = readFileSync(filePath, 'utf-8')
+          // Call twice: without filePath to get original CLJ source strings,
+          // with filePath to get resolved absolute paths for relative specifiers.
+          const originals = extractStringRequires(source)
+          const resolved = extractStringRequires(source, filePath)
+          for (let i = 0; i < originals.length; i++) {
+            seen.set(originals[i], resolved[i])
+          }
+        } catch {
+          continue
+        }
+      }
+    }
+    stringRequires = [...seen.entries()].map(([original, resolved]) => ({
+      original,
+      resolved,
+    }))
+  }
+
   function regenerateBuiltInNamespaceSources() {
+    try {
+      statSync(generatorScriptPath)
+    } catch {
+      // Script doesn't exist in this project — pre-built sources are already
+      // included in the conjure-js package, no regeneration needed.
+      return
+    }
     try {
       execFileSync(process.execPath, [generatorScriptPath], {
         cwd: projectRoot,
@@ -115,18 +218,61 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
     }
   }
 
+  /**
+   * Generate the static import table lines for the virtual session module.
+   * Each specifier gets a unique variable name. Returns { importLines, mapEntries }.
+   */
+  function buildImportTable(): { importLines: string[]; mapEntries: string[] } {
+    const importLines: string[] = []
+    const mapEntries: string[] = []
+    stringRequires.forEach(({ original, resolved }, i) => {
+      const varName = `_imp_${i}`
+      // Import statement uses the resolved path (absolute for local files, pkg name for packages).
+      // Map key uses the original CLJ source string — this is what importModule(s) receives at runtime.
+      importLines.push(`import * as ${varName} from ${JSON.stringify(resolved)};`)
+      mapEntries.push(`  ${JSON.stringify(original)}: ${varName},`)
+    })
+    return { importLines, mapEntries }
+  }
+
   return {
     name: 'vite-plugin-clj',
 
     configResolved(config: ResolvedConfig) {
       projectRoot = config.root
+      serveMode = config.command === 'serve'
       generatorScriptPath = resolve(projectRoot, 'scripts/gen-core-source.mjs')
       regenerateBuiltInNamespaceSources()
-      coreIndexPath = resolve(projectRoot, 'src/core/index.ts')
+      coreIndexPath = resolveCoreIndexPath()
       initServerSession()
+
+      // Detect Mode 2: explicit user entrypoint
+      if (options?.entrypoint) {
+        const ep = resolve(projectRoot, options.entrypoint)
+        try {
+          statSync(ep)
+          entrypointPath = ep
+        } catch {
+          // Configured entrypoint doesn't exist — fall through to Mode 1 with a warning
+          console.warn(
+            `[vite-plugin-clj] entrypoint not found: ${options.entrypoint} — falling back to auto-generated session`
+          )
+        }
+      }
+
+      scanStringRequires()
       eagerlyGenerateDts()
     },
 
+    configureServer(server: ViteDevServer) {
+      startBrowserNreplRelay({
+        port: options?.nreplPort,
+        cwd: projectRoot,
+        ws: server.ws,
+        serverSession,
+      })
+    },
+
     resolveId(source: string) {
       if (source === VIRTUAL_SESSION_ID) {
         return RESOLVED_VIRTUAL_SESSION_ID
@@ -139,25 +285,103 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
 
     load(id: string) {
       if (id === RESOLVED_VIRTUAL_SESSION_ID) {
-        return [
-          `import { createSession } from ${JSON.stringify(coreIndexPath)};`,
+        const { importLines, mapEntries } = buildImportTable()
+
+        // All static imports must be at the top of the module (ESM hoist semantics)
+        const lines: string[] = [
+          `import { createSession, printString } from ${JSON.stringify(coreIndexPath)};`,
+          ...importLines,
+          ...(entrypointPath
+            ? [`import __conjureFactory from ${JSON.stringify(entrypointPath)};`]
+            : []),
+          ``,
+          `const __importMap = {`,
+          ...mapEntries,
+          `};`,
           ``,
           `let _session = null;`,
-          `export function getSession() {`,
-          `  if (!_session) {`,
-          `    _session = createSession();`,
-          `  }`,
-          `  return _session;`,
-          `}`,
-        ].join('\n')
+          `let _outputLines = [];`,
+        ]
+
+        if (entrypointPath) {
+          // Mode 2: user-defined factory returns SessionOptions (without output/importModule).
+          // The plugin owns output capture (for nREPL relay) and importModule (import map wiring).
+          // User factory controls hostBindings, modules, entries, etc.
+          lines.push(
+            `export function getSession() {`,
+            `  if (!_session) {`,
+            `    const __userOpts = __conjureFactory(__importMap) ?? {};`,
+            `    _session = createSession({`,
+            `      ...(__userOpts),`,
+            `      importModule: (s) => __importMap[s],`,
+            `      output: (text) => { _outputLines.push(text); console.log(text.replace(/\\n$/, '')); },`,
+            `    });`,
+            `  }`,
+            `  return _session;`,
+            `}`,
+          )
+        } else {
+          // Mode 1: auto-generate session with import map wired in
+          lines.push(
+            `export function getSession() {`,
+            `  if (!_session) {`,
+            `    _session = createSession({`,
+            `      importModule: (s) => __importMap[s],`,
+            `      output: (text) => { _outputLines.push(text); console.log(text.replace(/\\n$/, '')); },`,
+            `    });`,
+            `  }`,
+            `  return _session;`,
+            `}`,
+          )
+        }
+
+        if (serveMode) {
+          lines.push(
+            ``,
+            `// Browser nREPL relay — active only in Vite dev server`,
+            `if (import.meta.hot) {`,
+            `  import.meta.hot.on('conjure:eval', async ({ id, code, ns }) => {`,
+            `    const session = getSession();`,
+            `    _outputLines = [];`,
+            `    try {`,
+            `      if (ns && ns !== session.currentNs) session.setNs(ns);`,
+            `      const result = await session.evaluateAsync(code);`,
+            `      const out = _outputLines.join('');`,
+            `      import.meta.hot.send('conjure:eval-result', { id, value: printString(result), ns: session.currentNs, ...(out ? { out } : {}) });`,
+            `    } catch (err) {`,
+            `      console.error(err);`,
+            `      const out = _outputLines.join('');`,
+            `      import.meta.hot.send('conjure:eval-result', { id, error: err instanceof Error ? err.message : String(err), ns: session.currentNs, ...(out ? { out } : {}) });`,
+            `    }`,
+            `  });`,
+            ``,
+            `  import.meta.hot.on('conjure:load-file', async ({ id, source, nsHint, filePath }) => {`,
+            `    const session = getSession();`,
+            `    _outputLines = [];`,
+            `    try {`,
+            `      const loadedNs = await session.loadFileAsync(source, nsHint, filePath || undefined);`,
+            `      if (loadedNs) session.setNs(loadedNs);`,
+            `      const out = _outputLines.join('');`,
+            `      import.meta.hot.send('conjure:load-file-result', { id, value: 'nil', ns: session.currentNs, ...(out ? { out } : {}) });`,
+            `    } catch (err) {`,
+            `      console.error(err);`,
+            `      const out = _outputLines.join('');`,
+            `      import.meta.hot.send('conjure:load-file-result', { id, error: err instanceof Error ? err.message : String(err), ns: session.currentNs, ...(out ? { out } : {}) });`,
+            `    }`,
+            `  });`,
+            `}`,
+          )
+        }
+
+        return lines.join('\n')
       }
 
       if (id.endsWith('.clj') && !id.includes('?')) {
         const source = readFileSync(id, 'utf-8')
         const nsNameFromPath = pathToNs(relative(projectRoot, id), sourceRoots)
-        const code = generateModuleCode(codegenCtx, nsNameFromPath, source)
+        const code = generateModuleCode(codegenCtx, nsNameFromPath, source, id)
         const dts = generateDts(codegenCtx, nsNameFromPath, source)
-        writeFileIfChanged(id + '.d.ts', dts)
+        if (dts) writeFileIfChanged(id + '.d.ts', dts)
         return code
       }
     },
@@ -172,7 +396,7 @@ export function cljPlugin(options?: CljPluginOptions): Plugin {
         const source = await read()
         try {
           const nsNameFromPath = pathToNs(relative(projectRoot, file), sourceRoots)
-          serverSession.loadFile(source, nsNameFromPath)
+          await serverSession.loadFileAsync(source, nsNameFromPath)
           const dts = generateDts(codegenCtx, nsNameFromPath, source)
           writeFileIfChanged(file + '.d.ts', dts)
         } catch {

package/src/vite-plugin-clj/namespace-utils.ts

@@ -1,3 +1,4 @@
+import { resolve, dirname } from 'node:path'
 import { isKeyword, isList, isSymbol, isVector } from '../core/assertions'
 import { readForms } from '../core/reader'
 import { tokenize } from '../core/tokenizer'
@@ -63,6 +64,44 @@ export function extractNsRequires(source: string): string[] {
   return requires
 }
 
+/**
+ * Parse Clojure source and extract all string module specifiers from (:require ...) clauses.
+ * These are the JS/npm imports written as string literals: (:require ["react" :as React]).
+ * Returns an array of resolved specifier strings (deduplicated).
+ *
+ * If filePath is provided, relative specifiers (starting with ./ or ../) are resolved
+ * to absolute paths using the file's directory. Package specifiers are returned as-is.
+ */
+export function extractStringRequires(source: string, filePath?: string): string[] {
+  const forms = readForms(tokenize(source))
+  const nsForm = forms.find(
+    (f) => isList(f) && isSymbol(f.value[0]) && f.value[0].name === 'ns'
+  )
+  if (!nsForm || !isList(nsForm)) return []
+
+  const specifiers: string[] = []
+  for (let i = 2; i < nsForm.value.length; i++) {
+    const clause = nsForm.value[i]
+    if (
+      isList(clause) &&
+      isKeyword(clause.value[0]) &&
+      clause.value[0].name === ':require'
+    ) {
+      for (let j = 1; j < clause.value.length; j++) {
+        const spec = clause.value[j]
+        const first = isVector(spec) && spec.value.length > 0 ? spec.value[0] : null
+        if (!first || first.kind !== 'string') continue
+        let specifier = first.value
+        if (filePath && (specifier.startsWith('./') || specifier.startsWith('../'))) {
+          specifier = resolve(dirname(filePath), specifier)
+        }
+        specifiers.push(specifier)
+      }
+    }
+  }
+  return [...new Set(specifiers)]
+}
+
 /**
  * Extract the namespace name from the (ns ...) form in a Clojure source string.
  * Returns null if no ns form is found.

package/src/vite-plugin-clj/static-analysis.ts

@@ -0,0 +1,211 @@
+import { isList, isSymbol, isVector } from '../core/assertions'
+import { readForms } from '../core/reader'
+import { tokenize } from '../core/tokenizer'
+import type { Arity, CljList, CljMap, CljValue, DestructurePattern } from '../core/types'
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+export interface VarDescriptor {
+  name: string
+  kind: 'fn' | 'const' | 'unknown'
+  arities?: Arity[]   // present when kind === 'fn'
+  tsType?: string     // present when kind === 'const' and value type is inferrable
+  isPrivate: boolean
+  isMacro: boolean
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse Clojure source and return descriptors for all top-level var definitions.
+ * Pure function — no session, no execution, no side effects.
+ *
+ * Handles: defn, defn-, defmacro, def, defonce, declare.
+ * Skips: ns, and any other top-level form that is not a definition.
+ *
+ * Private vars (defn-) are included with isPrivate: true so callers can decide
+ * whether to export them or not.
+ */
+export function readNamespaceVars(source: string): VarDescriptor[] {
+  const forms = readForms(tokenize(source))
+  const descriptors: VarDescriptor[] = []
+
+  for (const form of forms) {
+    if (!isList(form) || form.value.length < 2) continue
+    const head = form.value[0]
+    if (!isSymbol(head)) continue
+
+    const descriptor = parseTopLevelDef(form, head.name)
+    if (descriptor) descriptors.push(descriptor)
+  }
+
+  return descriptors
+}
+
+// ---------------------------------------------------------------------------
+// Metadata helpers
+// ---------------------------------------------------------------------------
+
+function hasPrivateMeta(meta: CljMap | undefined): boolean {
+  return (meta?.entries ?? []).some(
+    ([k, val]) =>
+      k.kind === 'keyword' && k.name === ':private' &&
+      val.kind === 'boolean' && val.value === true
+  )
+}
+
+// ---------------------------------------------------------------------------
+// Per-form dispatch
+// ---------------------------------------------------------------------------
+
+function parseTopLevelDef(form: CljList, op: string): VarDescriptor | null {
+  switch (op) {
+    case 'defn':
+      return parseDefn(form, false, false)
+    case 'defn-':
+      return parseDefn(form, true, false)
+    case 'defmacro':
+      return parseDefn(form, false, true)
+    case 'def':
+    case 'defonce':
+      return parseDef(form)
+    case 'declare':
+      return parseDeclare(form)
+    default:
+      return null
+  }
+}
+
+// ---------------------------------------------------------------------------
+// defn / defn- / defmacro
+// ---------------------------------------------------------------------------
+
+function parseDefn(form: CljList, isPrivate: boolean, isMacro: boolean): VarDescriptor | null {
+  const nameSym = form.value[1]
+  if (!isSymbol(nameSym)) return null
+
+  const private_ = isPrivate || hasPrivateMeta(nameSym.meta)
+
+  // Elements after the name: optional docstring, then params or arity clauses
+  const rest = form.value.slice(2)
+  // Skip optional docstring
+  const start = rest.length > 0 && rest[0].kind === 'string' ? 1 : 0
+  const bodyForms = rest.slice(start)
+
+  if (bodyForms.length === 0) {
+    // Bare defn with no param list — treat as unknown function
+    return { name: nameSym.name, kind: 'fn', arities: [], isPrivate: private_, isMacro }
+  }
+
+  const arities: Arity[] = isList(bodyForms[0])
+    ? // Multi-arity: each clause is a list whose first element is the params vector
+      bodyForms.filter(isList).map(parseArityClause)
+    : // Single-arity: bodyForms[0] is the params vector
+      isVector(bodyForms[0]) ? [vectorToArity(bodyForms[0])] : []
+
+  return { name: nameSym.name, kind: 'fn', arities, isPrivate: private_, isMacro }
+}
+
+function parseArityClause(clause: CljList): Arity {
+  const paramVec = clause.value[0]
+  return isVector(paramVec) ? vectorToArity(paramVec) : { params: [], restParam: null, body: [] }
+}
+
+function vectorToArity(paramVec: { value: CljValue[] }): Arity {
+  const params: DestructurePattern[] = []
+  let restParam: DestructurePattern | null = null
+
+  for (let i = 0; i < paramVec.value.length; i++) {
+    const p = paramVec.value[i]
+    if (isSymbol(p) && p.name === '&') {
+      const next = paramVec.value[i + 1]
+      if (next) restParam = next as DestructurePattern
+      break
+    }
+    params.push(p as DestructurePattern)
+  }
+
+  return { params, restParam, body: [] }
+}
+
+// ---------------------------------------------------------------------------
+// def / defonce
+// ---------------------------------------------------------------------------
+
+function parseDef(form: CljList): VarDescriptor | null {
+  const nameSym = form.value[1]
+  if (!isSymbol(nameSym)) return null
+
+  const isPrivate = hasPrivateMeta(nameSym.meta)
+  const value = form.value[2] // may be undefined for bare (def name)
+
+  if (!value) {
+    return { name: nameSym.name, kind: 'unknown', isPrivate, isMacro: false }
+  }
+
+  // Inline function literal
+  const fnArities = tryExtractFnArities(value)
+  if (fnArities !== null) {
+    return { name: nameSym.name, kind: 'fn', arities: fnArities, isPrivate, isMacro: false }
+  }
+
+  // Literal values with inferrable TypeScript types
+  const tsType = inferLiteralTsType(value)
+  if (tsType !== null) {
+    return { name: nameSym.name, kind: 'const', tsType, isPrivate, isMacro: false }
+  }
+
+  return { name: nameSym.name, kind: 'unknown', isPrivate, isMacro: false }
+}
+
+function inferLiteralTsType(value: CljValue): string | null {
+  switch (value.kind) {
+    case 'number':  return 'number'
+    case 'string':  return 'string'
+    case 'boolean': return 'boolean'
+    case 'nil':     return 'null'
+    case 'keyword': return 'string'
+    case 'vector':
+    case 'set':     return 'unknown[]'
+    case 'map':     return 'Record<string, unknown>'
+    default:        return null
+  }
+}
+
+// ---------------------------------------------------------------------------
+// declare
+// ---------------------------------------------------------------------------
+
+function parseDeclare(form: CljList): VarDescriptor | null {
+  const nameSym = form.value[1]
+  if (!isSymbol(nameSym)) return null
+  return { name: nameSym.name, kind: 'unknown', isPrivate: false, isMacro: false }
+}
+
+// ---------------------------------------------------------------------------
+// (fn ...) extraction for def with inline function
+// ---------------------------------------------------------------------------
+
+function tryExtractFnArities(value: CljValue): Arity[] | null {
+  if (!isList(value)) return null
+  const head = value.value[0]
+  if (!isSymbol(head) || head.name !== 'fn') return null
+
+  // After fn: optional name symbol, then params-vector or arity-clauses
+  let rest = value.value.slice(1)
+  if (rest.length > 0 && isSymbol(rest[0])) rest = rest.slice(1) // skip optional fn name
+
+  if (rest.length === 0) return []
+
+  if (isVector(rest[0])) {
+    // Single arity: (fn [params] body)
+    return [vectorToArity(rest[0])]
+  }
+
+  // Multi arity: (fn ([params] body) ([params] body))
+  return rest.filter(isList).map(parseArityClause)
+}

package/src/clojure/demo.clj

@@ -1,63 +0,0 @@
-(ns demo
-  (:require [demo.math :refer [pi square factorial] :as m]))
-
-(def greeting "Hello from Clojure!")
-
-
-greeting
-(def add m/add)
-
-pi
-
-(add 1 2)
-
-(square 3)
-
-(def x 42)
-
-(doc -)
-
-(var? #'x)
-
-#'x
-
-(+ 1 2)
-
-pi
-
-(slurp "test.txt")
-(spit "test.txt" "hello from the runtime")
-
-(doc reduce)
-
-(defn greet [name]
-  (str greeting " Welcome, " name "!"))
-
-(greet "Regibyte")
-
-(defn fibonacci
-  "This is the fibonacci function"
-  [n]
-  (loop [i 0 a 0 b 1]
-    (if (= i n)
-      a
-      (recur (inc i) b (+ a b)))))
-
-(map fibonacci [1 2 3 4 5 6])
-
-m/factorial
-
-(+ 1 2)
-
-(println "Hello World!" "From Calva!!!!!!")
-
-(type {:this-is :awesome!})
-
-(when true
-  (println "Yes\n")
-  (println "This\n")
-  (println "Is working!")
-  42)
-
-
-(map inc [2 3 4 5 8 2])