pamela: defpclass defproposition
pamela   ::= ( defpclass | defproposition )*
 no referencesdefpclass: ( defpclass symbol args option )
defpclass
         ::= '(' 'defpclass' symbol args option* ')'
 referenced by: pamela args: [ symbol ]
args     ::= '[' symbol* ']'
 referenced by: defpclass defpmethod defproposition option: meta inherit modes fields methods transitions propositions
option   ::= meta
           | inherit
           | modes
           | fields
           | methods
           | transitions
           | propositions
 referenced by: defpclass defproposition: ( defproposition keyword args meta )
         ::= '(' 'defproposition' keyword args meta* ')'
 referenced by: pamela meta: :meta { meta-entry }
meta     ::= ':meta' '{' meta-entry+ '}'
 referenced by: defproposition option meta-entry: version icon depends doc
         ::= version
           | icon
           | depends
           | doc
 referenced by: meta depends: :depends [ dep ]
depends  ::= ':depends' '[' dep* ']'
 referenced by: meta-entry dep: [ symbol string ]
dep      ::= '[' symbol string ']'
 referenced by: depends icon: :icon string
icon     ::= ':icon' string
 referenced by: meta-entry version: :version string
version  ::= ':version' string
 referenced by: meta-entry doc: :doc string
doc      ::= ':doc' string
 referenced by: cond meta-entry trans inherit: :inherit [ symbol ]
inherit  ::= ':inherit' '[' symbol+ ']'
 referenced by: option modes: :modes mode-enum mode-map
modes    ::= ':modes' ( mode-enum | mode-map )
 referenced by: option mode-enum: [ keyword ]
         ::= '[' keyword* ']'
 referenced by: modes mode-map: { mode-init }
mode-map ::= '{' mode-init* '}'
 referenced by: modes mode-init: keyword cond-expr
         ::= keyword cond-expr
 referenced by: mode-map cond-expr: true false not-expr and-expr or-expr implies-expr equal-expr gt-expr ge-expr lt-expr le-expr call-expr same-expr propositions-expr
         ::= 'true'
           | 'false'
           | not-expr
           | and-expr
           | or-expr
           | implies-expr
           | equal-expr
           | gt-expr
           | ge-expr
           | lt-expr
           | le-expr
           | call-expr
           | same-expr
           | propositions-expr
 referenced by: and-expr ask assert guard implies-expr maintain mode-init not-expr or-expr post pre propositions-expr tell unless when whenever and-expr: ( and cond-expr cond-operand )
and-expr ::= '(' 'and' ( cond-expr | cond-operand )+ ')'
 referenced by: cond-expr or-expr: ( or cond-expr cond-operand )
or-expr  ::= '(' 'or' ( cond-expr | cond-operand )+ ')'
 referenced by: cond-expr implies-expr: ( implies cond-expr cond-operand )
         ::= '(' 'implies' ( cond-expr | cond-operand )+ ')'
 referenced by: cond-expr not-expr: ( not cond-expr cond-operand )
not-expr ::= '(' 'not' ( cond-expr | cond-operand )+ ')'
 referenced by: cond-expr equal-expr: ( = cond-operand )
         ::= '(' '=' cond-operand+ ')'
 referenced by: cond-expr gt-expr: ( > cond-operand )
gt-expr  ::= '(' '>' cond-operand+ ')'
 referenced by: cond-expr ge-expr: ( >= cond-operand )
ge-expr  ::= '(' '>=' cond-operand+ ')'
 referenced by: cond-expr lt-expr: ( < cond-operand )
lt-expr  ::= '(' '<' cond-operand+ ')'
 referenced by: cond-expr le-expr: ( <= cond-operand )
le-expr  ::= '(' '<=' cond-operand+ ')'
 referenced by: cond-expr same-expr: ( same cond-operand )
         ::= '(' 'same' cond-operand+ ')'
 referenced by: cond-expr call-expr: ( call cond-operand )
         ::= '(' 'call' cond-operand+ ')'
 referenced by: cond-expr propositions-expr: ( propositions [ prop-search ] where cond-expr )
         ::= '(' 'propositions' '[' prop-search+ ']' ( 'where' cond-expr )? ')'
 referenced by: cond-expr prop-search: ( search-constraints keyword cond-operand )
         ::= '(' search-constraints? keyword cond-operand+ ')'
 referenced by: propositions propositions-expr search-constraints: [ wm ltm recency ]
         ::= '[' ( 'wm' | 'ltm' | recency )* ']'
 referenced by: prop-search cond-operand: literal mode-ref symbol-ref
         ::= literal
           | mode-ref
           | symbol-ref
 referenced by: and-expr call-expr equal-expr ge-expr gt-expr implies-expr le-expr lt-expr not-expr or-expr prop-search same-expr mode-ref: ( mode-of symbol-ref keyword )
mode-ref ::= '(' 'mode-of' symbol-ref keyword ')'
 referenced by: argval cond-operand expr-argval field-type recency: ( recency number-ref )
recency  ::= '(' 'recency' number-ref ')'
 referenced by: search-constraints fields: :fields { field }
fields   ::= ':fields' '{' field* '}'
 referenced by: option field: symbol { field-init } field-type
field    ::= symbol ( '{' field-init+ '}' | field-type )
 referenced by: fields field-type: literal lvar-ctor pclass-ctor mode-ref symbol-ref
         ::= literal
           | lvar-ctor
           | pclass-ctor
           | mode-ref
           | symbol-ref
 referenced by: field initial field-init: initial access observable consumer producer
         ::= initial
           | access
           | observable
           | consumer
           | producer
 referenced by: field initial: :initial field-type
initial  ::= ':initial' field-type
 referenced by: field-init access: :access keyword
access   ::= ':access' keyword
 referenced by: field-init observable: :observable boolean
         ::= ':observable' boolean
 referenced by: field-init consumer: :consumer boolean
consumer ::= ':consumer' boolean
 referenced by: field-init producer: :producer boolean
producer ::= ':producer' boolean
 referenced by: field-init methods: :methods [ defpmethod ]
methods  ::= ':methods' '[' defpmethod* ']'
 referenced by: option defpmethod: ( defpmethod symbol cond-map args fn between-stmt )
         ::= '(' 'defpmethod' symbol cond-map? args fn? between-stmt* ')'
 referenced by: methods transitions: :transitions { transition }
         ::= ':transitions' '{' transition* '}'
 referenced by: option transition: keyword trans-map
         ::= keyword trans-map
 referenced by: transitions cond-map: { cond }
cond-map ::= '{' cond* '}'
 referenced by: defpmethod trans-map: { trans }
         ::= '{' trans* '}'
 referenced by: transition cond: doc pre post opt-bounds cost reward controllable primitive display-name probability
cond     ::= doc
           | pre
           | post
           | opt-bounds
           | cost
           | reward
           | controllable
           | primitive
           | display-name
           | probability
 referenced by: cond-map trans: doc pre post opt-bounds cost reward probability
trans    ::= doc
           | pre
           | post
           | opt-bounds
           | cost
           | reward
           | probability
 referenced by: trans-map propositions: :propositions [ prop-search ]
         ::= ':propositions' '[' prop-search* ']'
 referenced by: option pre: :pre keyword cond-expr
pre      ::= ':pre' ( keyword | cond-expr )
 referenced by: cond trans post: :post keyword cond-expr
post     ::= ':post' ( keyword | cond-expr )
 referenced by: cond trans display-name: :display-name string
         ::= ':display-name' string
 referenced by: cond fn: ask assert choose choose-whenever delay dotimes maintain optional parallel sequence slack-parallel slack-sequence soft-parallel soft-sequence tell try unless when whenever method-fn
fn       ::= ask
           | assert
           | choose
           | choose-whenever
           | delay
           | dotimes
           | maintain
           | optional
           | parallel
           | sequence
           | slack-parallel
           | slack-sequence
           | soft-parallel
           | soft-sequence
           | tell
           | try
           | unless
           | when
           | whenever
           | method-fn
 referenced by: choice defpmethod dotimes enter leave maintain optional parallel sequence slack-parallel slack-sequence soft-parallel soft-sequence try unless when whenever ask: ( ask cond-expr opt-bounds )
ask      ::= '(' 'ask' cond-expr opt-bounds? ')'
 referenced by: fn assert: ( assert cond-expr opt-bounds )
assert   ::= '(' 'assert' cond-expr opt-bounds? ')'
 referenced by: fn choice: ( choice choice-opt fn )
choice   ::= '(' 'choice' choice-opt* fn ')'
 referenced by: choose choose-whenever choose: ( choose choose-opt choice )
choose   ::= '(' 'choose' choose-opt* choice+ ')'
 referenced by: fn choose-whenever: ( choose-whenever choose-opt choice )
         ::= '(' 'choose-whenever' choose-opt* choice+ ')'
 referenced by: fn delay: ( delay delay-opt )
delay    ::= '(' 'delay' delay-opt* ')'
 referenced by: fn dotimes: ( dotimes natural fn )
dotimes  ::= '(' 'dotimes' natural fn ')'
 referenced by: fn maintain: ( maintain cond-expr opt-bounds fn )
maintain ::= '(' 'maintain' cond-expr opt-bounds? fn ')'
 referenced by: fn optional: ( optional fn-opt fn )
optional ::= '(' 'optional' fn-opt* fn ')'
 referenced by: fn parallel: ( parallel fn-opt fn )
parallel ::= '(' 'parallel' fn-opt* fn+ ')'
 referenced by: fn sequence: ( sequence fn-opt fn )
sequence ::= '(' 'sequence' fn-opt* fn+ ')'
 referenced by: fn slack-parallel: ( slack-parallel fn-opt fn )
         ::= '(' 'slack-parallel' fn-opt* fn+ ')'
 referenced by: fn slack-sequence: ( slack-sequence fn-opt fn )
         ::= '(' 'slack-sequence' fn-opt* fn+ ')'
 referenced by: fn soft-parallel: ( soft-parallel fn-opt fn )
         ::= '(' 'soft-parallel' fn-opt* fn+ ')'
 referenced by: fn soft-sequence: ( soft-sequence fn-opt fn )
         ::= '(' 'soft-sequence' fn-opt* fn+ ')'
 referenced by: fn tell: ( tell cond-expr )
tell     ::= '(' 'tell' cond-expr ')'
 referenced by: fn try: ( try opt-bounds fn ( catch fn ) )
try      ::= '(' 'try' opt-bounds? fn '(' 'catch' fn ')' ')'
 referenced by: fn unless: ( unless cond-expr opt-bounds fn )
unless   ::= '(' 'unless' cond-expr opt-bounds? fn ')'
 referenced by: fn when: ( when cond-expr opt-bounds fn )
when     ::= '(' 'when' cond-expr opt-bounds? fn ')'
 referenced by: fn whenever: ( whenever cond-expr opt-bounds fn )
whenever ::= '(' 'whenever' cond-expr opt-bounds? fn ')'
 referenced by: fn method-fn: ( symbol-ref method-opt argval )
         ::= '(' symbol-ref method-opt* argval* ')'
 referenced by: fn between-stmt: between between-ends between-starts
         ::= between
           | between-ends
           | between-starts
 referenced by: defpmethod between: ( between keyword keyword between-opt )
between  ::= '(' 'between' keyword keyword between-opt+ ')'
 referenced by: between-stmt between-ends: ( between-ends keyword keyword between-opt )
         ::= '(' 'between-ends' keyword keyword between-opt+ ')'
 referenced by: between-stmt between-starts: ( between-starts keyword keyword between-opt )
         ::= '(' 'between-starts' keyword keyword between-opt+ ')'
 referenced by: between-stmt between-opt: opt-bounds cost-le reward-ge
         ::= opt-bounds
           | cost-le
           | reward-ge
 referenced by: between between-ends between-starts fn-opt fn-opt: between-opt label
           | label
 referenced by: choose-opt delay-opt optional parallel sequence slack-parallel slack-sequence soft-parallel soft-sequence choose-opt: fn-opt exactly min max
         ::= fn-opt
           | exactly
           | min
           | max
 referenced by: choose choose-whenever delay-opt: fn-opt controllable
         ::= fn-opt
           | controllable
 referenced by: delay method-opt: opt-bounds label cost reward controllable
         ::= opt-bounds
           | label
           | cost
           | reward
           | controllable
 referenced by: method-fn choice-opt: opt-bounds label cost reward probability guard enter leave
         ::= opt-bounds
           | label
           | cost
           | reward
           | probability
           | guard
           | enter
           | leave
 referenced by: choice opt-bounds: :bounds bounds
         ::= ':bounds' bounds
 referenced by: ask assert between-opt choice-opt cond maintain method-opt trans try unless when whenever label: :label keyword
label    ::= ':label' keyword
 referenced by: choice-opt fn-opt method-opt probability: :probability number-ref
         ::= ':probability' number-ref
 referenced by: choice-opt cond trans cost: :cost number-ref
cost     ::= ':cost' number-ref
 referenced by: choice-opt cond method-opt trans reward: :reward number-ref
reward   ::= ':reward' number-ref
 referenced by: choice-opt cond method-opt trans cost-le: :cost<= number-ref
cost-le  ::= ':cost<=' number-ref
 referenced by: between-opt reward-ge: :reward>= number-ref
         ::= ':reward>=' number-ref
 referenced by: between-opt guard: :guard cond-expr
guard    ::= ':guard' cond-expr
 referenced by: choice-opt controllable: :controllable boolean
         ::= ':controllable' boolean
 referenced by: cond delay-opt method-opt primitive: :primitive boolean
         ::= ':primitive' boolean
 referenced by: cond min: :min integer
min      ::= ':min' integer
 referenced by: choose-opt max: :max integer
max      ::= ':max' integer
 referenced by: choose-opt exactly: :exactly integer
exactly  ::= ':exactly' integer
 referenced by: choose-opt enter: :enter fn
enter    ::= ':enter' fn
 referenced by: choice-opt leave: :leave fn
leave    ::= ':leave' fn
 referenced by: choice-opt number-ref: number lvar-ctor symbol-ref
         ::= number
           | lvar-ctor
           | symbol-ref
 referenced by: cost cost-le probability recency reward reward-ge lvar-ctor: ( lvar string lvar-init )
         ::= '(' 'lvar' ( string lvar-init? )? ')'
 referenced by: bounds expr field-type number-ref lvar-init: literal bounds-literal
         ::= literal
           | bounds-literal
 referenced by: lvar-ctor pclass-ctor: ( symbol pclass-ctor-arg pclass-ctor-option )
         ::= '(' symbol pclass-ctor-arg* pclass-ctor-option* ')'
 referenced by: field-type pclass-ctor-arg: string expr pclass-arg-keyword boolean symbol-ref
         ::= string
           | expr
           | pclass-arg-keyword
           | boolean
           | symbol-ref
 referenced by: pclass-ctor pclass-ctor-option: id plant-part interface
         ::= id
           | plant-part
           | interface
 referenced by: pclass-ctor pclass-arg-keyword: keyword
         ::= keyword
 referenced by: pclass-ctor-arg reserved-pclass-ctor-keyword: :id :interface :plant-part stop-token
         ::= ( ':id' | ':interface' | ':plant-part' ) stop-token
 no referencesid: :id argval
id       ::= ':id' argval
 referenced by: pclass-ctor-option plant-part: :plant-part argval
         ::= ':plant-part' argval
 referenced by: pclass-ctor-option interface: :interface argval
         ::= ':interface' argval
 referenced by: pclass-ctor-option bounds: bounds-literal lvar-ctor
           | lvar-ctor
 referenced by: opt-bounds bounds-literal: [ expr expr :infinity ]
         ::= '[' expr ( expr | ':infinity' ) ']'
 referenced by: bounds lvar-init symbol-ref: symbol .
         ::= symbol ( '.' symbol )*
 referenced by: argval cond-operand expr-argval field-type method-fn mode-ref number-ref pclass-ctor-arg symbol: [A-Z] [a-z] [A-Z] [a-z] [0-9] -
symbol   ::= [A-Za-z] [A-Za-z0-9#x2D]*
 referenced by: args defpclass defpmethod dep field inherit pclass-ctor symbol-ref reserved-symbol: reserved-string stop-token
         ::= reserved-string stop-token
 no referencesreserved-string: and ask assert between between-ends between-starts catch choice choose choose-whenever defpclass defpmethod defproposition delay dotimes false implies lvar maintain mode-of not optional or parallel sequence slack-parallel slack-sequence soft-parallel soft-sequence tell true try unless when whenever
         ::= 'and'
           | 'ask'
           | 'assert'
           | 'between'
           | 'between-ends'
           | 'between-starts'
           | 'catch'
           | 'choice'
           | 'choose'
           | 'choose-whenever'
           | 'defpclass'
           | 'defpmethod'
           | 'defproposition'
           | 'delay'
           | 'dotimes'
           | 'false'
           | 'implies'
           | 'lvar'
           | 'maintain'
           | 'mode-of'
           | 'not'
           | 'optional'
           | 'or'
           | 'parallel'
           | 'sequence'
           | 'slack-parallel'
           | 'slack-sequence'
           | 'soft-parallel'
           | 'soft-sequence'
           | 'tell'
           | 'true'
           | 'try'
           | 'unless'
           | 'when'
           | 'whenever'
 referenced by: reserved-symbol stop-token: whitespace . ( ) [ ] { }
         ::= whitespace
           | '.'
           | '('
           | ')'
           | '['
           | ']'
           | '{'
           | '}'
 referenced by: reserved-keyword reserved-pclass-ctor-keyword reserved-symbol literal: boolean string keyword number
           | string
           | keyword
           | number
 referenced by: cond-operand field-type lvar-init expr-argval: string expr safe-keyword boolean mode-ref symbol-ref
         ::= string
           | expr
           | safe-keyword
           | boolean
           | mode-ref
           | symbol-ref
 no referencesargval: string number safe-keyword boolean mode-ref symbol-ref
argval   ::= string
           | number
           | safe-keyword
           | boolean
           | mode-ref
           | symbol-ref
 referenced by: id interface method-fn plant-part safe-keyword: keyword
         ::= keyword
 referenced by: argval expr-argval reserved-keyword: :label :bounds :cost :reward :controllable stop-token
         ::= ( ':label' | ':bounds' | ':cost' | ':reward' | ':controllable' ) stop-token
 no referenceskeyword: : [A-Z] [a-z] [0-9] : * . _ -
keyword  ::= ':' [A-Za-z0-9:*._#x2D]+
 referenced by: access between between-ends between-starts defproposition label literal mode-enum mode-init mode-ref pclass-arg-keyword post pre prop-search safe-keyword transition boolean: true false
boolean  ::= 'true'
           | 'false'
 referenced by: argval consumer controllable expr-argval literal observable pclass-ctor-arg primitive producer string: " [^"] "
string   ::= '"' [^"]* '"'
 referenced by: argval dep display-name doc expr-argval icon literal lvar-ctor pclass-ctor-arg version expr: number lvar-ctor ( multiply-expr divide-expr add-expr subtract-expr )
expr     ::= number
           | lvar-ctor
           | '(' ( multiply-expr | divide-expr | add-expr | subtract-expr ) ')'
 referenced by: add-expr bounds-literal divide-expr expr-argval multiply-expr pclass-ctor-arg subtract-expr multiply-expr: * expr
         ::= '*' expr+
 referenced by: expr divide-expr: / expr
         ::= '/' expr+
 referenced by: expr add-expr: + expr
add-expr ::= '+' expr+
 referenced by: expr subtract-expr: - expr
         ::= '-' expr+
 referenced by: expr number: float integer
number   ::= float
           | integer
 referenced by: argval expr literal number-ref float: - [0-9] . [0-9] . [0-9] E + - [0-9]
float    ::= '-'? ( [0-9]+ . | [0-9] . [0-9]+ E [+#x2D] ) [0-9]+
 referenced by: number integer: - [0-9]
integer  ::= '-'? [0-9]+
 referenced by: exactly max min number natural: [0-9]
natural  ::= [0-9]+
 referenced by: dotimes whitespace: ; . ,
         ::= ( [, ]+ | ';' .* )+
 referenced by: stop-token   ... generated by RR - Railroad Diagram Generator R R