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

fix some things

Browse source
This commit is contained in:
Joeri Exelmans 2025-05-08 21:30:56 +02:00
parent d9111c3969
commit bbac7858ae
16 changed files with 69 additions and 55 deletions
Download patch file Download diff file Expand all files Collapse all files

2
lib/compare/dynamic.types.js
View file

@ -4,6 +4,6 @@ import { compareDynamic, makeCompareFn } from "./dynamic.js";
const mkType = getDefaultTypeParser();
export const ModuleCompareDynamic = [
{i: makeCompareFn , t: mkType("∀a: Type -> a -> a -> Int")},
{i: makeCompareFn , t: mkType("Type -> a -> a -> Int")},
{i: compareDynamic, t: mkType("Dynamic -> Dynamic -> Int")},
];

2
lib/compare/primitives.types.js
View file

@ -7,5 +7,5 @@ export const ModuleComparePrimitives = [
{i: compareNumbers, t: mkType("Double -> Double -> Int")},
{i: compareBools , t: mkType("Bool -> Bool -> Int")},
{i: compareUnits , t: mkType("Unit -> Unit -> Int")},
{i: compareSymbols, t: mkType("SymbolT -> SymbolT -> Int")},
{i: compareSymbols, t: mkType("UUID -> UUID -> Int")},
];

10
lib/compare/structures.types.js
View file

@ -4,13 +4,13 @@ import { compareDicts, compareLists, compareProducts, compareSets, compareSums }
const mkType = getDefaultTypeParser();
export const ModuleCompareStructures = [
{i: compareLists, t: mkType("∀a: (a -> a -> Int) -> [a] -> [a] -> Int")},
{i: compareLists, t: mkType("(a -> a -> Int) -> [a] -> [a] -> Int")},
{i: compareProducts, t: mkType("∀a,b: (a -> a -> Int) -> (b -> b -> Int) -> (a*b) -> (a*b) -> Int")},
{i: compareProducts, t: mkType("(a -> a -> Int) -> (b -> b -> Int) -> (a*b) -> (a*b) -> Int")},
{i: compareSums, t: mkType("∀a,b: (a -> a -> Int) -> (b -> b -> Int) -> (a+b) -> (a+b) -> Int")},
{i: compareSums, t: mkType("(a -> a -> Int) -> (b -> b -> Int) -> (a+b) -> (a+b) -> Int")},
{i: compareSets, t: mkType("∀a: (a -> a -> Int) -> {a} -> {a} -> Int")},
{i: compareSets, t: mkType("(a -> a -> Int) -> {a} -> {a} -> Int")},
{i: compareDicts, t: mkType("∀a,b: (a -> a -> Int) -> (b -> b-> Int) -> (a => b) -> (a => b) -> Int")}
{i: compareDicts, t: mkType("(a -> a -> Int) -> (b -> b-> Int) -> (a => b) -> (a => b) -> Int")}
];

2
lib/generics/generics.js
View file

@ -5,7 +5,7 @@ import { isTypeVar, TYPE_VARS } from "../primitives/typevars.js";
// helper for creating generic types
// for instance, the type:
// ∀a: a -> a -> Bool
// a -> a -> Bool
// is created by
// makeGeneric(a => fnType(() => a)(() => fnType(() => a)(() => Bool)))
export const makeGeneric = callback => {

2
lib/meta/type_constructor.types.js
View file

@ -5,5 +5,5 @@ const mkType = getDefaultTypeParser();
export const ModuleTypeConstructor = [
// Problem: number of parameters of returned function depends on the 'Int' parameter...
// {i: makeTypeConstructor, t: mkType("SymbolT -> Int -> ??")}
// {i: makeTypeConstructor, t: mkType("UUID -> Int -> ??")}
];

12
lib/parser/type_parser.js
View file

@ -8,6 +8,11 @@ import { TYPE_VARS } from "../primitives/typevars.js";
import { dictType, fnType, lsType, prodType, sumType } from "../structures/type_constructors.js";
import { setType } from "../structures/type_constructors.js";
// A very stupid little parser, that can only parse:
// - primitives => simply maps onto types.
// - things between brackets => calls a type constructor that takes one parameter on whatever is between the brackets.
// - binary (infix) operators => calls a type constructor that takes two parameters on the LHS and RHS.
export const makeTypeParser = ({
// parser can be extended:
extraPrimitives=[],
@ -49,13 +54,6 @@ export const makeTypeParser = ({
['⇒', dictType],
['=>', dictType],
// only used for type variables (e.g., ∀a,b,c:)
[',', fnX => fnY => {
const x = fnX();
const y = fnY();
return Array.isArray(x) ? x.concat(y) : [x].concat(y)
}],
...extraInfixOperators,
]);

14
lib/primitives/dynamic.js
View file

@ -1,3 +1,17 @@
import { assignFn } from "../generics/generics.js";
export const newDynamic = i => t => ({i, t});
export const getInst = lnk => lnk.i;
export const getType = lnk => lnk.t;
export const apply = input => fun => {
const inputType = getType(input)
const funType = getType(fun);
const outputType = assignFn(funType, inputType);
const inputValue = getInst(input);
const funValue = getInst(fun);
const outputValue = funValue(inputValue);
return newDynamic(outputValue, outputType);
};

8
lib/primitives/dynamic.types.js
View file

@ -1,14 +1,16 @@
import { getDefaultTypeParser } from "../parser/type_parser.js";
import { getInst, getType, newDynamic } from "./dynamic.js";
import { apply, getInst, getType, newDynamic } from "./dynamic.js";
const mkType = getDefaultTypeParser();
export const ModuleDynamic = [
{ i: newDynamic, t: mkType("∀a: a -> Type -> Dynamic")},
{ i: newDynamic, t: mkType("a -> Type -> Dynamic")},
// allows us to (unsafely) cast the result to the specific type...
// (not sure if this is the right way to go)
{ i: getInst, t: mkType("∀a: Dynamic -> a") },
{ i: getInst, t: mkType("Dynamic -> a") },
{ i: getType, t: mkType("Dynamic -> Type") },
{ i: apply, t: mkType("Dynamic -> Dynamic -> Dynamic") },
];

4
lib/primitives/symbol.types.js
View file

@ -4,6 +4,6 @@ import { eqSymbol, getHumanReadableName } from "./symbol.js";
const mkType = getDefaultTypeParser();
export const ModuleSymbol = [
{ i: getHumanReadableName, t: mkType("SymbolT -> String")},
{ i: eqSymbol, t: mkType("SymbolT -> SymbolT -> Bool")},
{ i: getHumanReadableName, t: mkType("UUID -> String")},
{ i: eqSymbol, t: mkType("UUID -> UUID -> Bool")},
];

2
lib/primitives/type.types.js
View file

@ -8,6 +8,6 @@ const mkType = getDefaultTypeParser();
// each 'typed object' is implicitly an instance of TypeLink (defined below)
export const ModuleType = [
{i: eqType , t: mkType("Type -> Type -> Bool")},
{i: getSymbol, t: mkType("Type -> SymbolT")},
{i: getSymbol, t: mkType("Type -> UUID")},
{i: getParams, t: mkType("Type -> [Type -> Type]")},
];

16
lib/structures/dict.types.js
View file

@ -9,12 +9,12 @@ const mkType = makeTypeParser({
});
export const ModuleDict = [
{ i: emptyDict , t: mkType("∀a,b: (a -> a -> Int) -> (a => b)") },
{ i: has , t: mkType("∀a,b: (a => b) -> a -> Bool")},
{ i: set , t: mkType("∀a,b: (a => b) -> a -> b -> (a => b)")},
{ i: remove , t: mkType("∀a,b: (a => b) -> a -> (a => b)")},
{ i: length , t: mkType("∀a,b: (a => b) -> Int")},
{ i: first , t: mkType("∀a,b: (a => b) -> (a |=>| b)")},
{ i: last , t: mkType("∀a,b: (a => b) -> (a |=>| b)")},
{ i: read , t: mkType("∀a,b: (a |=>| b) -> (Unit + ((a*b) * (a |=>| b)))")},
{ i: emptyDict , t: mkType("(a -> a -> Int) -> (a => b)") },
{ i: has , t: mkType("(a => b) -> a -> Bool")},
{ i: set , t: mkType("(a => b) -> a -> b -> (a => b)")},
{ i: remove , t: mkType("(a => b) -> a -> (a => b)")},
{ i: length , t: mkType("(a => b) -> Int")},
{ i: first , t: mkType("(a => b) -> (a |=>| b)")},
{ i: last , t: mkType("(a => b) -> (a |=>| b)")},
{ i: read , t: mkType("(a |=>| b) -> (Unit + ((a*b) * (a |=>| b)))")},
];

16
lib/structures/list.types.js
View file

@ -4,12 +4,12 @@ import { emptyList, fold, get, length, map, pop, push, put } from "./list.js";
const mkType = getDefaultTypeParser();
export const ModuleList = [
{ i: emptyList, t: mkType("∀a: [a]")},
{ i: get , t: mkType("∀a: [a] -> Int -> a")},
{ i: put , t: mkType("∀a: [a] -> Int -> a -> [a]")},
{ i: push , t: mkType("∀a: [a] -> a -> [a]")},
{ i: pop , t: mkType("∀a: [a] -> a")},
{ i: map , t: mkType("∀a: [a] -> (a -> b) -> [b]")},
{ i: length , t: mkType("∀a: [a] -> Int")},
{ i: fold , t: mkType("∀a: [a] -> (b -> a -> b) -> b -> b")},
{ i: emptyList, t: mkType("[a]")},
{ i: get , t: mkType("[a] -> Int -> a")},
{ i: put , t: mkType("[a] -> Int -> a -> [a]")},
{ i: push , t: mkType("[a] -> a -> [a]")},
{ i: pop , t: mkType("[a] -> a")},
{ i: map , t: mkType("[a] -> (a -> b) -> [b]")},
{ i: length , t: mkType("[a] -> Int")},
{ i: fold , t: mkType("[a] -> (b -> a -> b) -> b -> b")},
];

6
lib/structures/product.types.js
View file

@ -4,7 +4,7 @@ import { newProduct, getLeft, getRight } from "./product.js";
const mkType = getDefaultTypeParser();
export const ModuleProduct = [
{ i: newProduct, t: mkType("∀a,b: a -> b -> (a * b)") },
{ i: getLeft , t: mkType("∀a,b: (a * b) -> a" ) },
{ i: getRight , t: mkType("∀a,b: (a * b) -> b" ) },
{ i: newProduct, t: mkType("a -> b -> (a * b)") },
{ i: getLeft , t: mkType("(a * b) -> a" ) },
{ i: getRight , t: mkType("(a * b) -> b" ) },
];

18
lib/structures/set.types.js
View file

@ -9,13 +9,13 @@ const mkType = makeTypeParser({
});
export const ModuleSet = [
{ i: emptySet , t: mkType("∀a: (a -> a -> Int) -> {a}") },
{ i: has , t: mkType("∀a: {a} -> a -> Bool")},
{ i: add , t: mkType("∀a: {a} -> a -> {a}")},
{ i: remove , t: mkType("∀a: {a} -> a -> {a}")},
{ i: length , t: mkType("∀a: {a} -> Int")},
{ i: fold , t: mkType("∀a,b: {a} -> (b -> a -> b) -> b")},
{ i: first , t: mkType("∀a: {a} -> <a>")},
{ i: last , t: mkType("∀a: {a} -> <a>")},
{ i: read , t: mkType("∀a: <a> -> (Unit + (a * <a>))")},
{ i: emptySet , t: mkType("(a -> a -> Int) -> {a}") },
{ i: has , t: mkType("{a} -> a -> Bool")},
{ i: add , t: mkType("{a} -> a -> {a}")},
{ i: remove , t: mkType("{a} -> a -> {a}")},
{ i: length , t: mkType("{a} -> Int")},
{ i: fold , t: mkType("{a} -> (b -> a -> b) -> b")},
{ i: first , t: mkType("{a} -> <a>")},
{ i: last , t: mkType("{a} -> <a>")},
{ i: read , t: mkType("<a> -> (Unit + (a * <a>))")},
];

6
lib/structures/sum.types.js
View file

@ -4,7 +4,7 @@ import { match, newLeft, newRight } from "./sum.js";
const mkType = getDefaultTypeParser();
export const ModuleSum = [
{ i: newLeft , t: mkType("∀a,b: a -> (a + b)") },
{ i: newRight , t: mkType("∀a,b: b -> (a + b)") },
{ i: match , t: mkType("∀a,b,c: (a + b) -> (a -> c) -> (b -> c) -> c") },
{ i: newLeft , t: mkType("a -> (a + b)") },
{ i: newRight , t: mkType("b -> (a + b)") },
{ i: match , t: mkType("(a + b) -> (a -> c) -> (b -> c) -> c") },
];