S-expressions: Difference between revisions

m
→‎JavaScript :: Functional: (disaggregated expression parser)
m (→‎{{header|Haskell}}: (disaggregated expression parser))
m (→‎JavaScript :: Functional: (disaggregated expression parser))
Line 3,789:
 
// parseExpr [String] -> ([Expr], [String])
const parseExpr = tokens => {
// A tuple of (parsed trees, residual tokens)
// derived from a list of tokens.
const until(finished = )([, tkns]readToken) =>(
0 === tkns.length || ")" === tknsTuple([0];)(tokens)
);
 
const readToken = ([exprs, tkns]) =>
0 < tkns.length ? (() => {
const [t, ...ts] = tkns;
 
// finished :: ([Expr], [String]) -> Bool
// Subforests are introduced by brackets,
const readTokenfinished = ([exprs, tkns]) =>
return "(" === t ? (
0 === tkns.length || ")" === bimap(tkns[0];
xs => exprs.concat([xs])
)(
tail
)(
parseExpr(ts)
)
 
// and conclude where brackets close.
) : ")" === t ? (
Tuple(exprs)(ts)
 
// readToken :: ([Expr], [String]) -> ([Expr], [String])
// Other tokens are appended leaves.
const readToken = ([exprs, tkns]) : Tuple(=>
0 < tkns.length ? exprs.concat(atom(t)) => {
const [t, ...ts] = )(ts)tkns;
 
})() : Tuple(exprs)(tkns);
// Subforests are introduced by brackets,
return "(" === t ? (
)bimap(
xs => exprs.concat([xs])
)(tail)(parseExpr(ts))
 
// and conclude where brackets close.
0) <: tkns.length ? ((")" =>== {t ? (
const [t, ...Tuple(exprs)(ts] = tkns;)
 
)// :Other ")"tokens ===are tappended ? (leaves.
) : tailTuple(
exprs.concat(atom(t))
)(ts);
})() : Tuple(exprs)(tstkns);
 
return until(finished)(readToken)(
Tuple([])(tokens)
);
};
 
// ------------------- ATOM PARSER -------------------
9,655

edits