add Value postfix to value types

Author: xieyuheng

TODO.md

@@ -1,10 +1,7 @@
 > back to call-by-value evaluation
 
-add Value postfix to value types
 extract definition/
-
 rename bind to binding
-rename Values.Lambda to Value.Closure
 
 remove Lazy
 remove DelayedApply

src/lang/equal/equalInCtx.ts

@@ -44,8 +44,8 @@ export function equalInCtx(ctx: Ctx, lhs: Value, rhs: Value): boolean {
 
     const freshName = freshen(ctx.boundNames, lhs.name)
     ctx = ctxBindName(ctx, freshName)
-    const v = Neutrals.Var(freshName)
-    const arg = Values.NotYet(v)
+    const v = Neutrals.VarNeutral(freshName)
+    const arg = Values.NotYetValue(v)
     return equalInCtx(ctx, applyWithDelay(lhs, arg), applyWithDelay(rhs, arg))
   }
 
@@ -60,8 +60,8 @@ export function equalInCtx(ctx: Ctx, lhs: Value, rhs: Value): boolean {
 
     const freshName = freshen(ctx.boundNames, rhs.name)
     ctx = ctxBindName(ctx, freshName)
-    const v = Neutrals.Var(freshName)
-    const arg = Values.NotYet(v)
+    const v = Neutrals.VarNeutral(freshName)
+    const arg = Values.NotYetValue(v)
     return equalInCtx(ctx, applyWithDelay(lhs, arg), applyWithDelay(rhs, arg))
   }
 

src/lang/evaluate/evaluateWithDelay.ts

@@ -22,14 +22,14 @@ export function evaluateWithDelay(mod: Mod, env: Env, exp: Exp): Value {
     }
 
     case "Lambda": {
-      return Values.Lambda(mod, env, exp.name, exp.ret)
+      return Values.LambdaValue(mod, env, exp.name, exp.ret)
     }
 
     case "Apply": {
       const target = evaluateWithDelay(mod, env, exp.target)
       const arg = evaluateWithDelay(mod, env, exp.arg)
       // const arg = Values.Lazy(mod, env, exp.arg)
-      return Values.DelayedApply(target, arg)
+      return Values.DelayedApplyValue(target, arg)
     }
 
     case "Let": {
@@ -50,7 +50,7 @@ export function evaluateWithDelay(mod: Mod, env: Env, exp: Exp): Value {
 export function applyWithDelay(target: Value, arg: Value): Value {
   switch (target.kind) {
     case "NotYet": {
-      return Values.NotYet(Neutrals.Apply(target.neutral, arg))
+      return Values.NotYetValue(Neutrals.ApplyNeutral(target.neutral, arg))
     }
 
     case "Lambda": {

src/lang/readback/readbackInCtx.ts

@@ -34,7 +34,7 @@ export function readbackInCtx(ctx: Ctx, value: Value): Exp {
 
       const freshName = freshen(ctx.boundNames, value.name)
       ctx = ctxBindName(ctx, freshName)
-      const arg = Values.NotYet(Neutrals.Var(freshName))
+      const arg = Values.NotYetValue(Neutrals.VarNeutral(freshName))
       const ret = applyWithDelay(value, arg)
       return Exps.Lambda(freshName, readbackInCtx(ctx, ret))
     }

src/lang/same/sameInCtx.ts

@@ -41,14 +41,14 @@ export function sameInCtx(ctx: Ctx, lhs: Value, rhs: Value): boolean {
   if (lhs.kind === "Lambda" && !lambdaIsDefined(lhs)) {
     const freshName = freshen(ctx.boundNames, lhs.name)
     ctx = ctxBindName(ctx, freshName)
-    const arg = Values.NotYet(Neutrals.Var(freshName))
+    const arg = Values.NotYetValue(Neutrals.VarNeutral(freshName))
     return sameInCtx(ctx, applyWithDelay(lhs, arg), applyWithDelay(rhs, arg))
   }
 
   if (rhs.kind === "Lambda" && !lambdaIsDefined(rhs)) {
     const freshName = freshen(ctx.boundNames, rhs.name)
     ctx = ctxBindName(ctx, freshName)
-    const arg = Values.NotYet(Neutrals.Var(freshName))
+    const arg = Values.NotYetValue(Neutrals.VarNeutral(freshName))
     return sameInCtx(ctx, applyWithDelay(lhs, arg), applyWithDelay(rhs, arg))
   }
 

src/lang/value/Neutral.ts

@@ -1,17 +1,17 @@
 import { type Value } from "../value/index.ts"
 
-export type Neutral = Var | Apply
-export type Var = { kind: "Var"; name: string }
-export type Apply = { kind: "Apply"; target: Neutral; arg: Value }
+export type Neutral = VarNeutral | ApplyNeutral
+export type VarNeutral = { kind: "Var"; name: string }
+export type ApplyNeutral = { kind: "Apply"; target: Neutral; arg: Value }
 
-export function Var(name: string): Var {
+export function VarNeutral(name: string): VarNeutral {
   return {
     kind: "Var",
     name,
   }
 }
 
-export function Apply(target: Neutral, arg: Value): Apply {
+export function ApplyNeutral(target: Neutral, arg: Value): ApplyNeutral {
   return {
     kind: "Apply",
     target,

src/lang/value/Value.ts

@@ -3,14 +3,14 @@ import { type Exp } from "../exp/index.ts"
 import { type Mod } from "../mod/index.ts"
 import { type Neutral } from "../value/index.ts"
 
-export type Value = NotYet | Lambda | Lazy | DelayedApply
+export type Value = NotYetValue | ClosureValue | LazyValue | DelayedApplyValue
 
-export type NotYet = {
+export type NotYetValue = {
   kind: "NotYet"
   neutral: Neutral
 }
 
-export type Lambda = {
+export type ClosureValue = {
   kind: "Lambda"
   mod: Mod
   env: Env
@@ -19,28 +19,33 @@ export type Lambda = {
   definedName?: string
 }
 
-export type Lazy = {
+export type LazyValue = {
   kind: "Lazy"
   mod: Mod
   env: Env
   exp: Exp
   value?: Value
 }
 
-export type DelayedApply = {
+export type DelayedApplyValue = {
   kind: "DelayedApply"
   target: Value
   arg: Value
 }
 
-export function NotYet(neutral: Neutral): NotYet {
+export function NotYetValue(neutral: Neutral): NotYetValue {
   return {
     kind: "NotYet",
     neutral,
   }
 }
 
-export function Lambda(mod: Mod, env: Env, name: string, ret: Exp): Lambda {
+export function LambdaValue(
+  mod: Mod,
+  env: Env,
+  name: string,
+  ret: Exp,
+): ClosureValue {
   return {
     kind: "Lambda",
     mod,
@@ -50,7 +55,7 @@ export function Lambda(mod: Mod, env: Env, name: string, ret: Exp): Lambda {
   }
 }
 
-export function Lazy(mod: Mod, env: Env, exp: Exp): Lazy {
+export function LazyValue(mod: Mod, env: Env, exp: Exp): LazyValue {
   return {
     kind: "Lazy",
     mod,
@@ -59,7 +64,10 @@ export function Lazy(mod: Mod, env: Env, exp: Exp): Lazy {
   }
 }
 
-export function DelayedApply(target: Value, arg: Value): DelayedApply {
+export function DelayedApplyValue(
+  target: Value,
+  arg: Value,
+): DelayedApplyValue {
   return {
     kind: "DelayedApply",
     target,

src/lang/value/delayedApplyUtils.ts

@@ -1,6 +1,6 @@
-import { DelayedApply, type Value } from "./Value.ts"
+import { DelayedApplyValue, type Value } from "./Value.ts"
 
-export function delayedApplyHead(delayedApply: DelayedApply): Value {
+export function delayedApplyHead(delayedApply: DelayedApplyValue): Value {
   if (delayedApply.target.kind === "DelayedApply") {
     return delayedApplyHead(delayedApply.target)
   }

src/lang/value/lambdaUtils.ts

@@ -1,12 +1,12 @@
-import { type Lambda } from "./Value.ts"
+import { type ClosureValue } from "./Value.ts"
 
-export type DefinedLambda = Lambda & { definedName: string }
+export type DefinedLambda = ClosureValue & { definedName: string }
 
-export function lambdaIsDefined(lambda: Lambda): lambda is DefinedLambda {
+export function lambdaIsDefined(lambda: ClosureValue): lambda is DefinedLambda {
   return lambda.definedName !== undefined
 }
 
-export function lambdaSameDefined(x: Lambda, y: Lambda): boolean {
+export function lambdaSameDefined(x: ClosureValue, y: ClosureValue): boolean {
   return (
     lambdaIsDefined(x) &&
     lambdaIsDefined(y) &&

src/lang/value/lazyUtils.ts

@@ -2,7 +2,7 @@ import { evaluate } from "../evaluate/index.ts"
 import type * as Values from "./index.ts"
 import { type Value } from "./index.ts"
 
-export function lazyActive(lazy: Values.Lazy): Value {
+export function lazyActive(lazy: Values.LazyValue): Value {
   if (lazy.value !== undefined) {
     return lazy.value
   }