septima-lang 0.0.8 → 0.0.10

package/src/ast-node.ts

@@ -1,269 +0,0 @@
-import { Span } from './location'
-import { Token } from './scanner'
-import { shouldNeverHappen } from './should-never-happen'
-import { switchOn } from './switch-on'
-
-export type Let = { start: Token; ident: Ident; value: AstNode }
-
-export type Import = {
-  start: Token
-  ident: Ident
-  pathToImportFrom: Token
-}
-
-export type Literal = {
-  tag: 'literal'
-  type: 'str' | 'bool' | 'num' | 'sink' | 'sink!' | 'sink!!'
-  t: Token
-}
-
-export type ObjectLiteralPart =
-  | { tag: 'hardName'; k: Ident; v: AstNode }
-  | { tag: 'computedName'; k: AstNode; v: AstNode }
-  | { tag: 'spread'; o: AstNode }
-
-export type ArrayLiteralPart = { tag: 'element'; v: AstNode } | { tag: 'spread'; v: AstNode }
-
-export type Ident = {
-  tag: 'ident'
-  t: Token
-}
-
-export type Lambda = {
-  tag: 'lambda'
-  start: Token
-  formalArgs: Ident[]
-  body: AstNode
-}
-
-export type Unit = {
-  tag: 'unit'
-  imports: Import[]
-  expression: AstNode
-}
-
-export type AstNode =
-  | Ident
-  | Literal
-  | Unit
-  | {
-      start: Token
-      tag: 'arrayLiteral'
-      parts: ArrayLiteralPart[]
-      end: Token
-    }
-  | {
-      start: Token
-      tag: 'objectLiteral'
-      parts: ObjectLiteralPart[]
-      end: Token
-    }
-  | {
-      tag: 'binaryOperator'
-      operator: '+' | '-' | '*' | '/' | '**' | '%' | '&&' | '||' | '>' | '<' | '>=' | '<=' | '==' | '!=' | '??'
-      lhs: AstNode
-      rhs: AstNode
-    }
-  | {
-      tag: 'unaryOperator'
-      operatorToken: Token
-      operator: '+' | '-' | '!'
-      operand: AstNode
-    }
-  | {
-      tag: 'topLevelExpression'
-      definitions: Let[]
-      computation?: AstNode
-    }
-  | Lambda
-  | {
-      tag: 'ternary'
-      condition: AstNode
-      positive: AstNode
-      negative: AstNode
-    }
-  | {
-      tag: 'functionCall'
-      actualArgs: AstNode[]
-      callee: AstNode
-      end: Token
-    }
-  | {
-      tag: 'if'
-      condition: AstNode
-      positive: AstNode
-      negative: AstNode
-    }
-  | {
-      tag: 'dot'
-      receiver: AstNode
-      ident: Ident
-    }
-  | {
-      tag: 'indexAccess'
-      receiver: AstNode
-      index: AstNode
-    }
-  | {
-      // A sepcial AST node meant to be generated internally (needed for exporting definition from one unit to another).
-      // Not intended to be parsed from source code. Hence, it is effectively empty, and its location cannot be
-      // determined.
-      tag: 'export*'
-    }
-
-export function show(ast: AstNode | AstNode[]): string {
-  if (Array.isArray(ast)) {
-    return ast.map(curr => show(curr)).join(', ')
-  }
-  if (ast.tag === 'arrayLiteral') {
-    const parts = ast.parts.map(p => {
-      if (p.tag === 'element') {
-        return show(p.v)
-      }
-
-      if (p.tag === 'spread') {
-        return `...${show(p.v)}`
-      }
-
-      shouldNeverHappen(p)
-    })
-    return `[${parts.join(', ')}]`
-  }
-
-  if (ast.tag === 'binaryOperator') {
-    return `(${show(ast.lhs)} ${ast.operator} ${show(ast.rhs)})`
-  }
-  if (ast.tag === 'dot') {
-    return `${show(ast.receiver)}.${show(ast.ident)}`
-  }
-  if (ast.tag === 'export*') {
-    return `(export*)`
-  }
-  if (ast.tag === 'ternary') {
-    return `${show(ast.condition)} ? ${show(ast.positive)} : ${show(ast.negative)}`
-  }
-  if (ast.tag === 'functionCall') {
-    return `${show(ast.callee)}(${show(ast.actualArgs)})`
-  }
-  if (ast.tag === 'ident') {
-    return ast.t.text
-  }
-  if (ast.tag === 'if') {
-    return `if (${show(ast.condition)}) ${show(ast.positive)} else ${show(ast.negative)}`
-  }
-  if (ast.tag === 'indexAccess') {
-    return `${show(ast.receiver)}[${show(ast.index)}]`
-  }
-  if (ast.tag === 'lambda') {
-    return `fun (${show(ast.formalArgs)}) ${show(ast.body)}`
-  }
-  if (ast.tag === 'literal') {
-    return switchOn(ast.type, {
-      bool: () => ast.t.text,
-      num: () => ast.t.text,
-      sink: () => 'sink',
-      'sink!': () => 'sink!',
-      'sink!!': () => 'sink!!',
-      str: () => `'${ast.t.text}'`,
-    })
-  }
-  if (ast.tag === 'objectLiteral') {
-    const pairs = ast.parts.map(p => {
-      if (p.tag === 'computedName') {
-        return `[${show(p.k)}]: ${show(p.v)}`
-      }
-
-      if (p.tag === 'hardName') {
-        return `${show(p.k)}: ${show(p.v)}`
-      }
-
-      if (p.tag === 'spread') {
-        return `...${show(p.o)}`
-      }
-
-      shouldNeverHappen(p)
-    })
-    return `{${pairs.join(', ')}}`
-  }
-  if (ast.tag === 'topLevelExpression') {
-    const defs = ast.definitions.map(d => `let ${show(d.ident)} = ${show(d.value)}`).join('; ')
-    const sep = defs && ast.computation ? ' ' : ''
-    return `${defs ? defs + ';' : ''}${sep}${ast.computation ? show(ast.computation) : ''}`
-  }
-  if (ast.tag === 'unaryOperator') {
-    return `${ast.operator}${show(ast.operand)}`
-  }
-  if (ast.tag === 'unit') {
-    const imports = ast.imports
-      .map(imp => `import * as ${show(imp.ident)} from '${imp.pathToImportFrom.text}';`)
-      .join('\n')
-    return `${imports ? imports + '\n' : ''}${show(ast.expression)}`
-  }
-
-  shouldNeverHappen(ast)
-}
-
-export function span(ast: AstNode): Span {
-  const ofRange = (a: Span, b: Span) => ({ from: a.from, to: b.to })
-  const ofToken = (t: Token) => ({ from: t.location, to: { offset: t.location.offset + t.text.length - 1 } })
-
-  if (ast.tag === 'arrayLiteral') {
-    return ofRange(ofToken(ast.start), ofToken(ast.end))
-  }
-  if (ast.tag === 'binaryOperator') {
-    return ofRange(span(ast.lhs), span(ast.rhs))
-  }
-  if (ast.tag === 'dot') {
-    return ofRange(span(ast.receiver), span(ast.ident))
-  }
-  if (ast.tag === 'functionCall') {
-    return ofRange(span(ast.callee), ofToken(ast.end))
-  }
-  if (ast.tag === 'ident') {
-    return ofToken(ast.t)
-  }
-  if (ast.tag === 'export*') {
-    return { from: { offset: 0 }, to: { offset: 0 } }
-  }
-  if (ast.tag === 'if') {
-    return ofRange(span(ast.condition), span(ast.negative))
-  }
-  if (ast.tag === 'indexAccess') {
-    return ofRange(span(ast.receiver), span(ast.index))
-  }
-  if (ast.tag === 'lambda') {
-    return ofRange(ofToken(ast.start), span(ast.body))
-  }
-  if (ast.tag === 'ternary') {
-    return ofRange(span(ast.condition), span(ast.negative))
-  }
-  if (ast.tag === 'literal') {
-    return ofToken(ast.t)
-  }
-  if (ast.tag === 'objectLiteral') {
-    return ofRange(ofToken(ast.start), ofToken(ast.end))
-  }
-  if (ast.tag === 'topLevelExpression') {
-    if (ast.computation) {
-      const d0 = ast.definitions.find(Boolean)
-      const comp = span(ast.computation)
-      return ofRange(d0 ? ofToken(d0.start) : comp, comp)
-    } else if (ast.definitions.length) {
-      const first = ast.definitions[0]
-      const last = ast.definitions[ast.definitions.length - 1]
-      return ofRange(ofToken(first.start), span(last.value))
-    } else {
-      return { from: { offset: 0 }, to: { offset: 0 } }
-    }
-  }
-  if (ast.tag === 'unaryOperator') {
-    return ofRange(ofToken(ast.operatorToken), span(ast.operand))
-  }
-  if (ast.tag === 'unit') {
-    const i0 = ast.imports.find(Boolean)
-    const exp = span(ast.expression)
-    return ofRange(i0 ? ofToken(i0.start) : exp, exp)
-  }
-
-  shouldNeverHappen(ast)
-}

package/src/extract-message.ts

@@ -1,5 +0,0 @@
-export function extractMessage(e: unknown): string | unknown {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  const typed = e as { message?: string }
-  return typed.message
-}

package/src/fail-me.ts

@@ -1,7 +0,0 @@
-export function failMe<R>(hint?: string): NonNullable<R> {
-  if (!hint) {
-    throw new Error(`This expression must never be evaluated`)
-  }
-
-  throw new Error(`Bad value: ${hint}`)
-}

package/src/find-array-method.ts

@@ -1,115 +0,0 @@
-import { Value } from './value'
-
-export type CallEvaluator = (callable: Value, args: Value[]) => Value
-/**
- * return an implementation for array methods. The following Array methods were not implemented
- * as it is hard to find an intuitive immutable API due to their mutable nature:
- *  - copyWithin
- *  - fill
- *  - forEach
- *  - keys
- *  - pop
- *  - push
- *  - shift
- *  - unshift
- */
-export function findArrayMethod(arr: unknown[], index: string, callEvaluator: CallEvaluator) {
-  const adjustedCallback =
-    (callback: Value) =>
-    (...args: unknown[]) =>
-      callEvaluator(
-        callback,
-        args.map(x => Value.from(x)),
-      )
-
-  const adjustedPredicate =
-    (predicate: Value) =>
-    (...args: unknown[]) =>
-      callEvaluator(
-        predicate,
-        args.map(x => Value.from(x)),
-      ).assertBool()
-
-  if (index === 'at') {
-    return Value.foreign(n => arr.at(n.assertNum()))
-  }
-  if (index === 'concat') {
-    return Value.foreign(arg => arr.concat(arg.assertArr()))
-  }
-  if (index === 'entries') {
-    return Value.foreign(() => [...arr.entries()])
-  }
-  if (index === 'every') {
-    return Value.foreign(predicate => arr.every(adjustedPredicate(predicate)))
-  }
-  if (index === 'filter') {
-    return Value.foreign(predicate => arr.filter(adjustedPredicate(predicate)))
-  }
-  if (index === 'find') {
-    return Value.foreign(predicate => arr.find(adjustedPredicate(predicate)))
-  }
-  if (index === 'findIndex') {
-    return Value.foreign(predicate => arr.findIndex(adjustedPredicate(predicate)))
-  }
-  if (index === 'flatMap') {
-    return Value.foreign(callback => flatten(arr.map(adjustedCallback(callback))))
-  }
-  if (index === 'flat') {
-    return Value.foreign(() => flatten(arr))
-  }
-  if (index === 'includes') {
-    return Value.foreign((arg: Value) => arr.some(curr => Value.from(curr).equalsTo(arg).isTrue()))
-  }
-  if (index === 'indexOf') {
-    return Value.foreign(arg => arr.findIndex(curr => Value.from(curr).equalsTo(arg).isTrue()))
-  }
-  if (index === 'join') {
-    return Value.foreign(arg => arr.join(arg.assertStr()))
-  }
-  if (index === 'lastIndexOf') {
-    return Value.foreign(arg => {
-      for (let i = arr.length - 1; i >= 0; --i) {
-        if (Value.from(arr[i]).equalsTo(arg).isTrue()) {
-          return i
-        }
-      }
-      return -1
-    })
-  }
-  if (index === 'length') {
-    return Value.num(arr.length)
-  }
-  if (index === 'map') {
-    return Value.foreign(callback => arr.map(adjustedCallback(callback)))
-  }
-  if (index === 'reverse') {
-    return Value.foreign(() => [...arr].reverse())
-  }
-  if (index === 'reduce') {
-    return Value.foreign((callback, initialValue) => arr.reduce(adjustedCallback(callback), initialValue))
-  }
-  if (index === 'reduceRight') {
-    return Value.foreign((callback, initialValue) => arr.reduceRight(adjustedCallback(callback), initialValue))
-  }
-  if (index === 'slice') {
-    return Value.foreign((start, end) => arr.slice(start?.assertNum(), end?.assertNum()))
-  }
-  if (index === 'some') {
-    return Value.foreign(predicate => arr.some(adjustedPredicate(predicate)))
-  }
-  throw new Error(`Unrecognized array method: ${index}`)
-}
-
-function flatten(input: unknown[]) {
-  const ret = []
-  for (const curr of input) {
-    const v = Value.from(curr)
-    const unwrapped = v.unwrap()
-    if (Array.isArray(unwrapped)) {
-      ret.push(...unwrapped)
-    } else {
-      ret.push(v)
-    }
-  }
-  return ret
-}

package/src/find-string-method.ts

@@ -1,84 +0,0 @@
-import { Value } from './value'
-
-export function findStringMethod(s: string, indexValue: string | Value) {
-  const index = Value.toStringOrNumber(indexValue)
-  if (typeof index === 'number') {
-    throw new Error(`Index is of type number - not supported`)
-  }
-  if (index === 'at') {
-    return Value.foreign(n => s.at(n.assertNum()))
-  }
-  if (index === 'charAt') {
-    return Value.foreign(n => s.charAt(n.assertNum()))
-  }
-  if (index === 'concat') {
-    return Value.foreign(arg => s.concat(arg.assertStr()))
-  }
-  if (index === 'endsWith') {
-    return Value.foreign(arg => s.endsWith(arg.assertStr()))
-  }
-  if (index === 'includes') {
-    return Value.foreign(arg => s.includes(arg.assertStr()))
-  }
-  if (index === 'indexOf') {
-    return Value.foreign(searchString => s.indexOf(searchString.assertStr()))
-  }
-  if (index === 'lastIndexOf') {
-    return Value.foreign(searchString => s.lastIndexOf(searchString.assertStr()))
-  }
-  if (index === 'length') {
-    return Value.num(s.length)
-  }
-  if (index === 'match') {
-    return Value.foreign(r => s.match(r.assertStr()))
-  }
-  if (index === 'matchAll') {
-    return Value.foreign(r => [...s.matchAll(new RegExp(r.assertStr(), 'g'))])
-  }
-  if (index === 'padEnd') {
-    return Value.foreign((maxLength, fillString) => s.padEnd(maxLength.assertNum(), fillString?.assertStr()))
-  }
-  if (index === 'padStart') {
-    return Value.foreign((maxLength, fillString) => s.padStart(maxLength.assertNum(), fillString?.assertStr()))
-  }
-  if (index === 'repeat') {
-    return Value.foreign(count => s.repeat(count.assertNum()))
-  }
-  if (index === 'replace') {
-    return Value.foreign((searchValue, replacer) => s.replace(searchValue.assertStr(), replacer.assertStr()))
-  }
-  if (index === 'replaceAll') {
-    return Value.foreign((searchValue, replacer) => s.replaceAll(searchValue.assertStr(), replacer.assertStr()))
-  }
-  if (index === 'search') {
-    return Value.foreign(searcher => s.search(searcher.assertStr()))
-  }
-  if (index === 'slice') {
-    return Value.foreign((start, end) => s.slice(start?.assertNum(), end?.assertNum()))
-  }
-  if (index === 'split') {
-    return Value.foreign(splitter => s.split(splitter.assertStr()))
-  }
-  if (index === 'startsWith') {
-    return Value.foreign(arg => s.startsWith(arg.assertStr()))
-  }
-  if (index === 'substring') {
-    return Value.foreign((start, end) => s.substring(start.assertNum(), end?.assertNum()))
-  }
-  if (index === 'toLowerCase') {
-    return Value.foreign(() => s.toLowerCase())
-  }
-  if (index === 'toUpperCase') {
-    return Value.foreign(() => s.toUpperCase())
-  }
-  if (index === 'trim') {
-    return Value.foreign(() => s.trim())
-  }
-  if (index === 'trimEnd') {
-    return Value.foreign(() => s.trimEnd())
-  }
-  if (index === 'trimStart') {
-    return Value.foreign(() => s.trimStart())
-  }
-  throw new Error(`Unrecognized string method: ${index}`)
-}

package/src/index.ts

@@ -1 +0,0 @@
-export * from './septima'

package/src/location.ts

@@ -1,13 +0,0 @@
-export interface Location {
-  readonly offset: number
-}
-
-export interface Span {
-  from: Location
-  to: Location
-}
-
-export interface Location2d {
-  line: number
-  col: number
-}