research/dope2-webapp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

one last fix

Browse source
This commit is contained in:
Joeri Exelmans 2025-05-23 20:33:08 +02:00
parent ca9af544ba
commit 3ff7e76694
3 changed files with 21 additions and 15 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/CallBlock.tsx
View file

@ -127,8 +127,10 @@ function InputParams({ depth, errorDepth, ...rest }) {
errorDepth={errorDepth} errorDepth={errorDepth}
/>} />}
{/* Our own input param */} {/* Our own input param */}
<ExprBlock <EnvContext value={inferTypeCall(rest.state, env).inputEnv}>
{...nestedInputProperties(rest as CallBlockProps, env)} <ExprBlock
{...nestedInputProperties(rest as CallBlockProps, env)}
/> />
</EnvContext>
</div>; </div>;
} }

4
src/LetInBlock.tsx
View file

@ -51,8 +51,6 @@ function DeclColumns({state, setState, score}) {
const {paramType, innerEnv} = inferTypeLet(state, env); const {paramType, innerEnv} = inferTypeLet(state, env);
// const innerEnv = env; // todo: change this
return <> return <>
<span className="keyword column">let&nbsp;</span> <span className="keyword column">let&nbsp;</span>
<span className="column rightAlign"> <span className="column rightAlign">
@ -95,7 +93,7 @@ function InnerMost({state, setState, score}) {
const setInner = callback => setState(state => ({...state, inner: callback(state.inner)})); const setInner = callback => setState(state => ({...state, inner: callback(state.inner)}));
// const [valueResolved] = evalExprBlock(state.value, env); // const [valueResolved] = evalExprBlock(state.value, env);
// const innerEnv = makeInnerEnv(env, state.name, valueResolved); // const innerEnv = makeInnerEnv(env, state.name, valueResolved);
const innerEnv = env; // todo: change this const {paramType, innerEnv} = inferTypeLet(state, env);
const onCancel = () => setState(state => state.value); const onCancel = () => setState(state => state.value);
if (state.inner.kind === "let" && globalContext?.syntacticSugar) { if (state.inner.kind === "let" && globalContext?.syntacticSugar) {
return <EnvContext value={innerEnv}> return <EnvContext value={innerEnv}>

26
src/infer_type.ts
View file

@ -25,10 +25,13 @@ export interface TypeInfo {
err?: IncompatibleTypesError; err?: IncompatibleTypesError;
} }
export interface LambdaTypeInfo extends TypeInfo { export interface TypeInfoLambda extends TypeInfo {
paramType: Type; paramType: Type;
innerEnv: Environment; innerEnv: Environment;
} }
export interface TypeInfoCall extends TypeInfo {
inputEnv: Environment;
}
export function inferType(s: ExprBlockState, env: Environment): TypeInfo { export function inferType(s: ExprBlockState, env: Environment): TypeInfo {
if (s.kind === "input") { if (s.kind === "input") {
@ -60,11 +63,9 @@ export function inferTypeInput(s: InputBlockState, env: Environment): TypeInfo {
else if (s.value.kind === "name") { else if (s.value.kind === "name") {
const found = trie.get(env.names)(s.text); const found = trie.get(env.names)(s.text);
if (found) { if (found) {
let type = found.t; const [type, newEnv] = (found.kind === "unknown")
let newEnv = env; ? [found.t, env]
if (found.kind !== "unknown") { : rewriteType(found.t, env);
[type, newEnv] = rewriteType(found.t, env);
}
return { return {
type, type,
subs: new Map(), subs: new Map(),
@ -82,9 +83,10 @@ export function inferTypeInput(s: InputBlockState, env: Environment): TypeInfo {
} }
// @ts-ignore // @ts-ignore
export function inferTypeCall(s: CallBlockState, env: Environment): TypeInfo { export function inferTypeCall(s: CallBlockState, env: Environment): TypeInfoCall {
const fnTypeInfo = inferType(s.fn, env); const fnTypeInfo = inferType(s.fn, env);
const inputTypeInfo = inferType(s.input, fnTypeInfo.newEnv); const inputEnv = fnTypeInfo.newEnv;
const inputTypeInfo = inferType(s.input, inputEnv);
const [returnType, envWithReturn] = typeUnknown(inputTypeInfo.newEnv); const [returnType, envWithReturn] = typeUnknown(inputTypeInfo.newEnv);
const fakeFnType = fnType(_ => inputTypeInfo.type)(_ => returnType); const fakeFnType = fnType(_ => inputTypeInfo.type)(_ => returnType);
try { try {
@ -111,6 +113,7 @@ export function inferTypeCall(s: CallBlockState, env: Environment): TypeInfo {
type, type,
subs: mergedSubs, subs: mergedSubs,
newEnv, newEnv,
inputEnv,
}; };
} }
catch (e) { catch (e) {
@ -121,17 +124,20 @@ export function inferTypeCall(s: CallBlockState, env: Environment): TypeInfo {
subs: new Map(), subs: new Map(),
newEnv, newEnv,
err: e, err: e,
inputEnv,
} }
} }
} }
} }
export function inferTypeLet(s: LetInBlockState, env: Environment): LambdaTypeInfo { export function inferTypeLet(s: LetInBlockState, env: Environment): TypeInfoLambda {
const valTypeInfo = inferType(s.value, env); const valTypeInfo = inferType(s.value, env);
const innerEnv = { const innerEnv = {
names: trie.insert(env.names)(s.name)({kind: "value", t: valTypeInfo.type}), names: trie.insert(env.names)(s.name)({kind: "value", t: valTypeInfo.type}),
typevars: env.typevars, typevars: env.typevars,
}; };
console.log(s.name);
console.log("innerEnv.names:", innerEnv.names);
return { return {
...inferType(s.inner, innerEnv), ...inferType(s.inner, innerEnv),
paramType: valTypeInfo.type, paramType: valTypeInfo.type,
@ -140,7 +146,7 @@ export function inferTypeLet(s: LetInBlockState, env: Environment): LambdaTypeIn
} }
export function inferTypeLambda(s: LambdaBlockState, env: Environment): LambdaTypeInfo { export function inferTypeLambda(s: LambdaBlockState, env: Environment): TypeInfoLambda {
let [paramType] = typeUnknown(env); let [paramType] = typeUnknown(env);
const paramTypeVar = paramType.symbol; const paramTypeVar = paramType.symbol;