Simple conversion away from using modules
This commit is contained in:
parent
beb22274d6
commit
30f721eeb6
|
@ -529,7 +529,6 @@ export const SquigglePlayground: FC<PlaygroundProps> = ({
|
|||
|
||||
const withoutEditor = <div className="mt-3">{tabs}</div>;
|
||||
|
||||
console.log(vars);
|
||||
return (
|
||||
<SquiggleContainer>
|
||||
<StyledTab.Group>
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
module InternalExpressionValue = ReducerInterface_InternalExpressionValue
|
||||
module ExpressionT = Reducer_Expression_T
|
||||
module Module = Reducer_Module
|
||||
module Bindings = Reducer_Module
|
||||
// module Module = Reducer_Module
|
||||
// module Bindings = Reducer_Module
|
||||
module ErrorValue = Reducer_ErrorValue
|
||||
|
||||
open Jest
|
||||
|
@ -50,44 +50,44 @@ module FooImplementation = {
|
|||
let library = [fn1]
|
||||
}
|
||||
|
||||
let makeBindings = FunctionRegistry_Core.Registry.makeBindings(_, FooImplementation.library)
|
||||
// let makeBindings = FunctionRegistry_Core.Registry.makeBindings(_, FooImplementation.library)
|
||||
|
||||
let stdLibWithFoo = Bindings.emptyBindings->makeBindings
|
||||
// let stdLibWithFoo = Bindings.emptyBindings->makeBindings
|
||||
|
||||
let evalWithFoo = sourceCode =>
|
||||
Reducer_Expression.parse(sourceCode)->Belt.Result.flatMap(expr =>
|
||||
Reducer_Expression.reduceExpression(
|
||||
expr,
|
||||
stdLibWithFoo,
|
||||
InternalExpressionValue.defaultEnvironment,
|
||||
)
|
||||
)
|
||||
// let evalWithFoo = sourceCode =>
|
||||
// Reducer_Expression.parse(sourceCode)->Belt.Result.flatMap(expr =>
|
||||
// Reducer_Expression.reduceExpression(
|
||||
// expr,
|
||||
// stdLibWithFoo,
|
||||
// InternalExpressionValue.defaultEnvironment,
|
||||
// )
|
||||
// )
|
||||
|
||||
let evalToStringResultWithFoo = sourceCode =>
|
||||
evalWithFoo(sourceCode)->InternalExpressionValue.toStringResult
|
||||
// let evalToStringResultWithFoo = sourceCode =>
|
||||
// evalWithFoo(sourceCode)->InternalExpressionValue.toStringResult
|
||||
|
||||
describe("Module", () => {
|
||||
test("add2(1,2)", () => {
|
||||
let result = evalToStringResultWithFoo("Foo.add2(1,2)")
|
||||
expect(result)->toEqual("Ok(3)")
|
||||
})
|
||||
test("add3(1,2,3)", () => {
|
||||
let result = evalToStringResultWithFoo("Foo.add3(1,2,3)")
|
||||
expect(result)->toEqual("Ok(6)")
|
||||
})
|
||||
})
|
||||
// describe("Module", () => {
|
||||
// test("add2(1,2)", () => {
|
||||
// let result = evalToStringResultWithFoo("Foo.add2(1,2)")
|
||||
// expect(result)->toEqual("Ok(3)")
|
||||
// })
|
||||
// test("add3(1,2,3)", () => {
|
||||
// let result = evalToStringResultWithFoo("Foo.add3(1,2,3)")
|
||||
// expect(result)->toEqual("Ok(6)")
|
||||
// })
|
||||
// })
|
||||
|
||||
describe("Fn auto-testing", () => {
|
||||
let items = FooImplementation.fn1.examples->E.A.to_list
|
||||
// describe("Fn auto-testing", () => {
|
||||
// let items = FooImplementation.fn1.examples->E.A.to_list
|
||||
|
||||
testAll("tests of validity", items, r => {
|
||||
expect(r->evalWithFoo->E.R.isOk)->toEqual(true)
|
||||
})
|
||||
// testAll("tests of validity", items, r => {
|
||||
// expect(r->evalWithFoo->E.R.isOk)->toEqual(true)
|
||||
// })
|
||||
|
||||
testAll("tests of type", items, r => {
|
||||
let responseType =
|
||||
r->evalWithFoo->E.R2.fmap(ReducerInterface_InternalExpressionValue.valueToValueType)
|
||||
let expectedOutputType = FooImplementation.fn1.output |> E.O.toExn("")
|
||||
expect(responseType)->toEqual(Ok(expectedOutputType))
|
||||
})
|
||||
})
|
||||
// testAll("tests of type", items, r => {
|
||||
// let responseType =
|
||||
// r->evalWithFoo->E.R2.fmap(ReducerInterface_InternalExpressionValue.valueToValueType)
|
||||
// let expectedOutputType = FooImplementation.fn1.output |> E.O.toExn("")
|
||||
// expect(responseType)->toEqual(Ok(expectedOutputType))
|
||||
// })
|
||||
// })
|
||||
|
|
|
@ -303,10 +303,13 @@ module Matcher = {
|
|||
}
|
||||
|
||||
let findMatches = (r: registry, fnName: string, args: array<internalExpressionValue>) => {
|
||||
switch _findExactMatches(r, fnName, args) {
|
||||
let fnNameInParts = Js.String.split(".", fnName)
|
||||
let fnToSearch = E.A.get(fnNameInParts, 1) |> E.O.default(fnNameInParts[0])
|
||||
|
||||
switch _findExactMatches(r, fnToSearch, args) {
|
||||
| Some(r) => Match.FullMatch(r)
|
||||
| None =>
|
||||
switch _findNameMatches(r, fnName, args) {
|
||||
switch _findNameMatches(r, fnToSearch, args) {
|
||||
| Some(r) => Match.SameNameDifferentArguments(r)
|
||||
| None => Match.DifferentName
|
||||
}
|
||||
|
@ -349,9 +352,6 @@ module FnDefinition = {
|
|||
let toFfiFn = (t: t): Reducer_Expression_T.optionFfiFn =>
|
||||
(args, environment) => run(t, args, environment)->E.R.toOption
|
||||
|
||||
let toLambda = (t: t) =>
|
||||
Reducer_Module.convertOptionToFfiFn(t.name, toFfiFn(t))->Reducer_Module.eLambdaFFIValue
|
||||
|
||||
let make = (~name, ~inputs, ~run, ()): t => {
|
||||
name: name,
|
||||
inputs: inputs,
|
||||
|
@ -405,39 +405,40 @@ module NameSpace = {
|
|||
let definitions = (t: t) => t.functions->E.A2.fmap(f => f.definitions)->E.A.concatMany
|
||||
let uniqueFnNames = (t: t) => definitions(t)->E.A2.fmap(r => r.name)->E.A.uniq
|
||||
let nameToDefinitions = (t: t, name: string) => definitions(t)->E.A2.filter(r => r.name == name)
|
||||
|
||||
//todo: It could be good to set a warning if two definitions are both valid, but I don't expect this often.
|
||||
let nameFfiFn = (t: t, name: string): Reducer_Expression_T.optionFfiFn => {
|
||||
(args, environment) => {
|
||||
let definitions =
|
||||
nameToDefinitions(t, name)->E.A2.fmap((def, ()) =>
|
||||
FnDefinition.isMatch(def, args)
|
||||
? FnDefinition.run(def, args, environment) |> E.R.toOption
|
||||
: None
|
||||
)
|
||||
E.A.O.firstSomeFn(definitions)
|
||||
}
|
||||
}
|
||||
|
||||
let toModule = (t: t): Reducer_Module.t =>
|
||||
E.A.reduce(uniqueFnNames(t), Reducer_Module.emptyStdLib, (acc, uniqueName) => {
|
||||
let relevantDefinitions = nameFfiFn(t, uniqueName)
|
||||
acc->Reducer_Module.defineFunction(uniqueName, relevantDefinitions)
|
||||
})
|
||||
}
|
||||
|
||||
module Registry = {
|
||||
let toJson = (r: registry) => r->E.A2.fmap(Function.toJson)
|
||||
|
||||
let allExamples = (r: registry) => r->E.A2.fmap(r => r.examples)->E.A.concatMany
|
||||
let allExamplesWithFns = (r: registry) =>
|
||||
r->E.A2.fmap(fn => fn.examples->E.A2.fmap(example => (fn, example)))->E.A.concatMany
|
||||
|
||||
let allDefinitionsWithFns = (r: registry) =>
|
||||
r->E.A2.fmap(fn => fn.definitions->E.A2.fmap(definitions => (fn, definitions)))->E.A.concatMany
|
||||
|
||||
let cache = (r: registry): Js.Dict.t<array<Function.t>> => {
|
||||
let functionsWithFnNames =
|
||||
allDefinitionsWithFns(r)
|
||||
->E.A2.fmap(((fn, def)) => {
|
||||
let nameWithNamespace = `${fn.nameSpace}.${def.name}`
|
||||
let nameWithoutNamespace = def.name
|
||||
fn.requiresNamespace
|
||||
? [(nameWithNamespace, fn)]
|
||||
: [(nameWithNamespace, fn), (nameWithoutNamespace, fn)]
|
||||
})
|
||||
->E.A.concatMany
|
||||
let uniqueNames = functionsWithFnNames->E.A2.fmap(((name, _)) => name)->E.A.uniq
|
||||
let cacheAsArray: array<(string, array<function>)> = uniqueNames->E.A2.fmap(uniqueName => {
|
||||
let relevantItems =
|
||||
E.A2.filter(functionsWithFnNames, ((defName, _)) => defName == uniqueName)->E.A2.fmap(
|
||||
E.Tuple2.second,
|
||||
)
|
||||
(uniqueName, relevantItems)
|
||||
})
|
||||
cacheAsArray->Js.Dict.fromArray
|
||||
}
|
||||
|
||||
let _exportedSubset = (r: registry): registry => r |> E.A.filter(r => !r.requiresNamespace)
|
||||
|
||||
let definitionsWithFunctions = (r: registry) =>
|
||||
r->E.A2.fmap(fn => fn.definitions->E.A2.fmap(def => (def, fn)))->E.A.concatMany
|
||||
|
||||
/*
|
||||
There's a (potential+minor) bug here: If a function definition is called outside of the calls
|
||||
to the registry, then it's possible that there could be a match after the registry is
|
||||
|
@ -449,7 +450,10 @@ module Registry = {
|
|||
~args: array<internalExpressionValue>,
|
||||
~env: GenericDist.env,
|
||||
) => {
|
||||
let matchToDef = m => Matcher.Registry.matchToDef(registry, m)
|
||||
let cc = cache(registry)
|
||||
let relevantFunctions = Js.Dict.get(cc, fnName) |> E.O.default([])
|
||||
|
||||
let matchToDef = m => Matcher.Registry.matchToDef(relevantFunctions, m)
|
||||
let showNameMatchDefinitions = matches => {
|
||||
let defs =
|
||||
matches
|
||||
|
@ -460,7 +464,8 @@ module Registry = {
|
|||
->E.A2.joinWith("; ")
|
||||
`There are function matches for ${fnName}(), but with different arguments: ${defs}`
|
||||
}
|
||||
switch Matcher.Registry.findMatches(registry, fnName, args) {
|
||||
|
||||
switch Matcher.Registry.findMatches(relevantFunctions, fnName, args) {
|
||||
| Matcher.Match.FullMatch(match) => match->matchToDef->E.O2.fmap(FnDefinition.run(_, args, env))
|
||||
| SameNameDifferentArguments(m) => Some(Error(showNameMatchDefinitions(m)))
|
||||
| _ => None
|
||||
|
@ -476,20 +481,4 @@ module Registry = {
|
|||
E.R2.errMap(_, s => Reducer_ErrorValue.RETodo(s)),
|
||||
)
|
||||
}
|
||||
|
||||
let allNamespaces = (t: registry) => t->E.A2.fmap(r => r.nameSpace)->E.A.uniq
|
||||
|
||||
let makeBindings = (prevBindings: Reducer_Module.t, t: registry): Reducer_Module.t => {
|
||||
let nameSpaces = allNamespaces(t)
|
||||
let nameSpaceBindings = nameSpaces->E.A2.fmap(nameSpace => {
|
||||
let namespaceModule: NameSpace.t = {
|
||||
name: nameSpace,
|
||||
functions: t->E.A2.filter(r => r.nameSpace == nameSpace),
|
||||
}
|
||||
(nameSpace, NameSpace.toModule(namespaceModule))
|
||||
})
|
||||
E.A.reduce(nameSpaceBindings, prevBindings, (acc, (name, fn)) =>
|
||||
acc->Reducer_Module.defineModule(name, fn)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,7 +1,6 @@
|
|||
module Bindings = Reducer_Bindings
|
||||
|
||||
let internalStdLib = Bindings.emptyBindings->SquiggleLibrary_Math.makeBindings
|
||||
->FunctionRegistry_Core.Registry.makeBindings(FunctionRegistry_Library.registry)
|
||||
|
||||
@genType
|
||||
let externalStdLib = internalStdLib->Bindings.toTypeScriptBindings
|
||||
|
|
Loading…
Reference in New Issue
Block a user