define open class <token> (<object>)
end;

define constant <positionable-stream> = <object>;
define constant <parse-failure> = <object>;
define constant <parse-context> = <object>;

define function seq1 (#rest sub-rules) => (rule-parser :: <function>)
  local method foo (stream, context)
          values(if (context) #t end, #f, #t);
        end;
  foo;
end;

define constant program-parser-rule = seq1 (parse-ablock);


define function parse-program
 (stream :: <positionable-stream>, context :: <parse-context>)
 => (value :: false-or (<ablock-token>),
     success? :: <boolean>,
     failure :: false-or (<parse-failure>))
  let (prod, succb :: <boolean>, err :: false-or (<parse-failure>))
    = program-parser-rule (stream, context);
  succb := #f;
  values (succb, succb, err);
end function;

define class <ablock-token> (<token>) end class;

define constant ablock-parser-rule = seq1 (parse-procedure-block);

define function parse-ablock
 (stream :: <positionable-stream>, context :: <parse-context>)
 => (value :: false-or (<ablock-token>),
     success? :: <boolean>,
     failure :: false-or (<parse-failure>))
  let (prod, succb :: <boolean>, err :: false-or(<parse-failure>))
    = ablock-parser-rule (stream, context);
  succb := #f;
  values(succb, succb, err);
end function;

define class <procedure-block-token> (<token>) end class;

define constant procedure-block-parser-rule = seq1 ( parse-ablock);
define function parse-procedure-block
 (stream :: <positionable-stream>, context :: <parse-context>)
 => (value :: false-or (<procedure-block-token>),
     success? :: <boolean>,
     failure :: false-or (<parse-failure>))
  let (prod, succb :: <boolean>, err :: false-or (<parse-failure>))
    = procedure-block-parser-rule (stream, context);
  succb := #f;
  values (succb, succb, err);
end function;

define function seq1 (#rest sub-rules) => (rule-parser :: <function>)
  local method foo (stream, context)
          values(if (context) #t end, #f, #t);
        end;
  foo;
end;

define constant program-parser-rule = seq1(parse-ablock);

define function parse-program
 (stream, context)
  program-parser-rule(stream, context);
end function;

define constant ablock-parser-rule = seq1 (parse-ablock);

define function parse-ablock
 (stream, context)
  let (prod, succb, err)
    = ablock-parser-rule (stream, context);
  succb := #f;
  values(#t, #t, #t);
end function;

define constant <positionable-stream> = <object>;
define constant <parse-failure> = <object>;
define constant <parse-context> = <object>;

define function seq1 (#rest sub-rules) => (rule-parser :: <function>)
  local method foo (stream, context)
          values(if (context) #t end, #f, #t);
        end;
  foo;
end;

define constant program-parser-rule = seq1(parse-ablock);

define function parse-program
 (stream :: <positionable-stream>, context :: <parse-context>)
  program-parser-rule(stream, context);
end function;

define constant ablock-parser-rule = seq1 (parse-ablock);

define function parse-ablock
 (stream :: <positionable-stream>, context :: <parse-context>)
  let (prod, succb :: <boolean>, err :: false-or(<parse-failure>))
    = ablock-parser-rule (stream, context);
  succb := #f;
  values(#t, #t, #t);
end function;