public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder) { state.BeginTransaction(); state.Colorize(tokens, Color.Whitespace, Color.Operator); var innerBuilder = new ExpressionBuilder(ExpressionFlags.Standard); innerBuilder.Add(new FieldSymbol("__$0")); var operatorsParser = new OperatorsParser(innerBuilder); var result = from op in operatorsParser.Scan(state) from closing in state.Scan("^ /']'", Color.Operator) select op; if (result.ValueOrOriginal(out _, out var original)) { innerBuilder.Add(new FieldSymbol("__$1")); if (innerBuilder.ToExpression().If(out var expression, out var exception)) { var lambda = new LambdaSymbol(2, expression); builder.Add(new SendBinaryMessageSymbol("foldr", Precedence.ChainedOperator)); builder.Add(lambda); state.CommitTransaction(); return(Unit.Matched()); } else { state.RollBackTransaction(); return(failedMatch <Unit>(exception)); } }
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder) { state.Colorize(tokens, Color.Whitespace, Color.Operator); state.BeginTransaction(); var expressionBuilder = new ExpressionBuilder(builder.Flags); var parser = new AnyLambdaParser(expressionBuilder); var result = from parsed in parser.Scan(state) from endToken in state.Scan("/']'", Color.Operator) select parsed; if (result.ValueOrOriginal(out _, out var original)) { if (expressionBuilder.ToExpression().If(out var expression, out var exception)) { builder.Add(new ZipLambdaSymbol(expression)); state.CommitTransaction(); return(Unit.Matched()); } else { state.RollBackTransaction(); return(failedMatch <Unit>(exception)); } }
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder) { state.Colorize(tokens, Color.Whitespace, Color.Keyword, Color.Whitespace); if (getBlock(state).ValueOrCast <Unit>(out var block, out var asUnit)) { block.AddReturnIf(new UnitSymbol()); var lambda = new LambdaSymbol(0, block); var invokeBuilder = new ExpressionBuilder(ExpressionFlags.Standard); invokeBuilder.Add(lambda); invokeBuilder.Add(new PostfixInvokeSymbol(new Expression[0])); if (invokeBuilder.ToExpression().If(out var invokeExpression, out var exception)) { builder.Add(new TrySymbol(invokeExpression)); return(Unit.Matched()); } else { return(failedMatch <Unit>(exception)); } } else { return(asUnit); } }
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder) { state.Colorize(tokens, Color.Whitespace, Color.Structure); var result = from c in getExpression(state, builder.Flags | ExpressionFlags.Comparisand) from scanned in state.Scan("^ /')' /(|s|) /('->' | '=>')", Color.Structure, Color.Whitespace, Color.Structure) from typeConstraint in parseTypeConstraint(state) from b in getLambdaBlock(scanned.Contains("->"), state, builder.Flags, typeConstraint) select(c, b); if (result.If(out var tuple)) { var(comparisand, block) = tuple; var expressionBuilder = new ExpressionBuilder(ExpressionFlags.Standard); expressionBuilder.Add(new FieldSymbol("__$0")); expressionBuilder.Add(new MatchSymbol()); expressionBuilder.Add(comparisand); if (expressionBuilder.ToExpression().If(out var comparison, out var exception)) { var list = new List <Statement> { new If(comparison, block) }; var lambdaSymbol = new LambdaSymbol(1, new Block(list)); builder.Add(lambdaSymbol); return(Unit.Matched()); } else { return(failedMatch <Unit>(exception)); } } return(Unit.Matched()); }
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder) { state.Colorize(tokens, Color.Whitespace, Color.Keyword); if (builder.ToExpression().If(out var expression, out var exception)) { var comprehensions = new List <(Symbol, Expression, IMaybe <Expression>, string)>(); if (getInnerComprehension(state).ValueOrCast <Unit>(out var tuple, out var asUnit)) { var(comparisand, source, ifExp) = tuple; var image = $"for {comparisand} := {source}"; comprehensions.Add((comparisand, source, ifExp, image)); } else { return(asUnit); } while (state.More) { var parser = new InnerComprehensionParser(builder, comprehensions); if (parser.Scan(state).If(out _, out var anyException)) { } else if (anyException.If(out exception)) { return(failedMatch <Unit>(exception)); } else { break; } } var stack = new Stack <(Symbol, Expression, IMaybe <Expression>, string)>(); foreach (var item in comprehensions) { stack.Push(item); } For forStatement; var images = new StringBuilder(); if (stack.Count > 0) { var(symbol, source, ifExp, image) = stack.Pop(); images.Append(image); var yieldStatement = new Yield(expression); var block = new Block(yieldStatement); if (ifExp.If(out var boolean)) { block = new Block(new If(boolean, block)); } forStatement = new For(symbol, source, block); } else { return(notMatched <Unit>()); } while (stack.Count > 0) { var(symbol, source, ifExp, image) = stack.Pop(); images.Append(image); var block = new Block(forStatement); if (ifExp.If(out var boolean)) { block = new Block(new If(boolean, block)); } forStatement = new For(symbol, source, block); } builder.Clear(); state.CreateReturnType(); var statements = new List <Statement> { forStatement, new Return(new Expression(new NoneSymbol()), state.GetReturnType()) }; state.RemoveReturnType(); builder.Add(new ComprehensionSymbol(new Block(statements), images.ToString())); return(Unit.Matched()); } else { return(failedMatch <Unit>(exception)); } }
public override IMatched <Unit> Parse(ParseState state, Token[] tokens, ExpressionBuilder builder) { var functionName = tokens[2].Text; if (functionName == @"\/") { return(notMatched <Unit>()); } else { state.Colorize(tokens, Color.Whitespace, Color.Invokable, Color.OpenParenthesis); if (getArgumentsPlusLambda(state, builder.Flags).ValueOrCast <Unit>(out var tuple, out var asUnit)) { var(arguments, possibleLambda) = tuple; if (state.BlockFollows()) { state.Scan("^ /':'", Color.Structure); if (state.Advance().ValueOrOriginal(out _, out var unitMatched)) { var tempObjectField = newLabel("object"); var outerBuilder = new ExpressionBuilder(ExpressionFlags.Standard); var setPropertyParser = new SetPropertyParser(builder, tempObjectField, outerBuilder); while (state.More) { if (setPropertyParser.Scan(state).If(out _, out var anyException)) { } else if (anyException.If(out var exception)) { return(failedMatch <Unit>(exception)); } else { break; } } state.Regress(); if (outerBuilder.ToExpression().If(out var outerExpression, out var outerException)) { builder.Add(new NewObjectSymbol(tempObjectField, functionName, outerExpression)); } else { return(failedMatch <Unit>(outerException)); } } else { return(unitMatched); } } else if (state.Macro(functionName).If(out var function)) { builder.Add(new MacroInvokeSymbol(function, arguments)); } else { builder.Add(new InvokeSymbol(functionName, arguments, possibleLambda, builder.Flags[ExpressionFlags.Comparisand])); } return(Unit.Matched()); }