Better code for Pinafore interpretation

[AshleyYakeley]

Currently:

evaluate.Eval @A: Text -> Action (Result Text A)

Something like:

pure.Pinafore @A: A -> Pinafore;
parse.Pinafore: Text -> Action (Result Text Pinafore);
let.Pinafore: [(Text,Pinafore)] -> Pinafore -> Pinafore;
evaluate.Pinafore @A: Pinafore -> Action (Result Text A);

Possibilities:

• Interpreter monad
• open and closed expressions

namespace Pinafore of  # Reflect?
type Error;
subtype Error <: Showable;

type Positive.Type -a;
const.Positive.Type @A: Positive.Type A;
type Negative.Type +a;
const.Negative.Type @A: Negative.Type A;
unify.Type: PositiveType a -> NegativeType b -> Result UnifyError (a -> b);

type Type {-p,+q};
subtype Type -a <: Positive.Type a;
subtype Type +a <: Negative.Type a;
const.Type @A: Type A;

type Value;
mk.Value: PositiveType a -> a -> Value;
unify.Value: NegativeType a -> Value -> Result UnifyError a;

type OpenExpression +a;
# applicative OpenExpression
evaluate.OpenExpression: OpenExpression a -> Result EvaluateError a;

type Expression;
pure.Expression: Value -> Expression;
mk.Expression: PositiveType a -> OpenExpression a -> Expression;
unify.Expression: NegativeType a -> Expression -> Result UnifyError (OpenExpression a);
evaluate.Expression: Expression -> Result EvaluateError Value;
interpret.Expression: Text -> Action (Result InterpretError Expression);

end;