_{Official ZPE/YASS documentation}YASS formal specification

varsym
  $


⟨math_symb⟩
  +
  -
  /
  *
  %


⟨comparator⟩
  <
  >
  <=
  >=
  !=
  ==


⟨logical_operator⟩
  ||  
  &&
  OR
  AND


⟨concatenate⟩
  &


⟨comma⟩
  ,
  ;


⟨type⟩
  string
  integer
  real
  boolean
  list
  function
  object


⟨identifier⟩
  _?[A-z][A-z0-9_]*


⟨import⟩
  import ⟨identifier⟩
  import ⟨identifier⟩ as ⟨identifier⟩


⟨body⟩
  ⟨import⟩
  ⟨assign⟩
  ⟨function⟩
  ⟨if⟩
  ⟨for⟩
  ⟨for_to⟩
  ⟨for_each⟩
  ⟨until⟩
  ⟨while⟩
  ⟨when⟩
  ⟨lambda_call⟩
  ⟨function_call⟩
  ⟨try⟩
  ⟨object_accessor⟩
  ⟨increment⟩
  ⟨decrement⟩
  ⟨structure⟩
  ⟨breakpoint⟩


⟨breakpoint⟩
  #breakpoint#


⟨variable⟩
  varsym⟨identifier⟩
  ⟨identifier⟩


⟨increment⟩
  ++⟨variable⟩
  ⟨variable⟩++


⟨decrement⟩
  --⟨variable⟩
  ⟨variable⟩--


⟨undefined⟩
  undefined


⟨null⟩
  null


⟨boolean⟩
  true
  false


⟨integer⟩
  ((-?[1-9]+)
  [0-9][0-9]*)(E[0-9]+)?


⟨double⟩
  (-?[0-9]+((\\.)[0-9]+))(E(-?)[0-9]+)?


⟨hex⟩
  0x[0-9A-f]+


⟨octal⟩
  0[1-7][0-7]*


⟨string⟩
  ".*"
  '.*'


⟨list⟩
  [⟨actual_parameters⟩]


⟨map⟩
  [⟨map_pairs⟩]


⟨internal_doc⟩
  << (.*) >>


⟨concatenation⟩
  ⟨string⟩ ⟨concatenate⟩ ⟨string⟩
  ⟨string⟩ ⟨concatenate⟩ ⟨concatenation⟩


⟨value⟩
  ⟨concatenation⟩
  ⟨string⟩
  ⟨integer⟩
  ⟨double⟩
  ⟨boolean⟩
  ⟨null⟩
  ⟨list⟩
  ⟨map⟩
  ⟨hex⟩
  ⟨octal⟩
  ⟨object⟩
  ⟨lambda1⟩
  ⟨lambda2⟩
  ⟨lambda_function⟩
  ⟨increment⟩
  ⟨decrement⟩
  ⟨internal_doc⟩


⟨count⟩
  count( ⟨value⟩ )


⟨cast⟩
  cast( ⟨value⟩, ⟨type⟩ )


⟨match_inner⟩
  ⟨value⟩ => ⟨value⟩ ⟨match_inner⟩
  ⟨value⟩ => ⟨value⟩, ⟨match_inner⟩
  ⟨value⟩ => ⟨value⟩
  ε


⟨match_expression⟩
  match( ⟨value⟩ : ⟨match_inner⟩ )


⟨power⟩
  ⟨value⟩ ^ ⟨value⟩


⟨construct_body⟩
  ⟨body⟩ ⟨construct_body⟩
  ε


⟨formal_parameters⟩
  ⟨variable⟩, ⟨formal_parameters⟩
  ⟨variable⟩
  ⟨type⟩ ⟨variable⟩, ⟨formal_parameters⟩
  ⟨type⟩ ⟨variable⟩
  ⟨variable⟩ ...
  ε


⟨lambda1⟩
  function ( ⟨formal_parameters⟩ ) ⟨construct_body⟩
  function ( ⟨formal_parameters⟩ ) {⟨construct_body⟩}


⟨lambda2⟩
  ( ⟨formal_parameters⟩ ) => ⟨construct_body⟩
  ( ⟨formal_parameters⟩ ) => {⟨construct_body⟩}


⟨function_type⟩
  : ⟨type⟩
  ε


⟨function⟩
  function ⟨identifier⟩ ( ⟨formal_parameters⟩ ) ⟨function_type⟩ ⟨construct_body⟩ end function
  function ⟨identifier⟩ ( ⟨formal_parameters⟩ ) ⟨function_type⟩ {⟨construct_body⟩}


⟨function_call⟩
  ⟨identifier⟩ ( ⟨actual_parameters⟩ )


⟨lambda_call⟩
  ⟨variable⟩ ( ⟨actual_parameters⟩ )


⟨term⟩
  ⟨identifier⟩
  ⟨variable⟩
  ⟨increment⟩
  ⟨decrement⟩
  ⟨value⟩
  ⟨lambda_call⟩
  ⟨function_call⟩
  ⟨object_accessor⟩
  ⟨power⟩
  ⟨match_expression⟩
  ⟨count⟩
  ⟨cast⟩
  ( ⟨term⟩ )


⟨ternary_op⟩
  ⟨expr_inner⟩ ? ⟨value⟩ : ⟨value⟩


⟨optional_value⟩
  ⟨expr_inner⟩ ?? ⟨value⟩


⟨expr_inner⟩
  ⟨term⟩ ⟨math_symb⟩ ⟨term⟩
  ⟨term⟩ ⟨comparator⟩ ⟨term⟩
  ⟨term⟩ ⟨logical_operator⟩ ⟨term⟩
  ⟨term⟩ ⟨concatenate⟩ ⟨term⟩
  ⟨term⟩
  ε


⟨expression⟩
  ⟨expr_inner⟩
  ⟨ternary_op⟩
  ⟨optional_value⟩
  ε


⟨index⟩
  ⟨expression⟩ [⟨expression⟩]


⟨map_pairs⟩
  ⟨expression⟩ => ⟨expression⟩, ⟨map_pairs⟩
  ⟨expression⟩ => ⟨expression⟩
  ε


⟨actual_parameters⟩
  ⟨expression⟩, ⟨actual_parameters⟩
  ⟨expression⟩
  ε


⟨assign_variable⟩
  let ⟨variable⟩
  ⟨variable⟩
  ⟨const⟩


⟨assign⟩
  ⟨assign_variable⟩ = ⟨expression⟩
  ⟨assign_variable⟩ = new ⟨identifier⟩ ( ⟨expression⟩ )
  ⟨assign_variable⟩ = create new ⟨identifier⟩ record
  ⟨assign_variable⟩ = new ⟨identifier⟩ record
  let ⟨variable⟩ be ⟨expression⟩
  declare ⟨variable⟩ as ⟨type⟩ = ⟨expression⟩


⟨includes⟩
  includes ⟨string⟩


⟨if⟩
  if ( ⟨expression⟩ ) ⟨construct_body⟩ ⟨else_if⟩ end if
  if ( ⟨expression⟩ ) {⟨construct_body⟩} ⟨else_if⟩


⟨else_if⟩
  elseif ( ⟨expression⟩ ) ⟨construct_body⟩ ⟨else_if⟩
  elseif ( ⟨expression⟩ ) {⟨construct_body⟩} ⟨elseif⟩
  ⟨else⟩


⟨else⟩
  else ( ⟨expression⟩ ) ⟨construct_body⟩
  else ( ⟨expression⟩ ) {⟨construct_body⟩}
  ε


⟨when⟩
  when ( ⟨variable⟩ ) ⟨is⟩ ⟨otherwise⟩ end when
  when ( ⟨variable⟩ ) { ⟨is⟩ ⟨otherwise⟩ }


⟨is⟩
  is ⟨value⟩ do ⟨construct_body⟩ ⟨is⟩
  is ⟨value⟩ ⟨construct_body⟩ ⟨is⟩
  ε


⟨otherwise⟩
  otherwise do ⟨construct_body⟩
  otherwise ⟨construct_body⟩
  ε


⟨for_increment⟩
  ⟨integer⟩
  ⟨expression⟩


⟨for_variable⟩
  ⟨variable⟩
  ⟨assign⟩


⟨for⟩
  for ( ⟨for_variable⟩ ⟨comma⟩ ⟨expression⟩ ⟨comma⟩ ⟨for_increment⟩ ) ⟨construct_body⟩ end for
  for ( ⟨for_variable⟩ ⟨comma⟩ ⟨expression⟩ ⟨comma⟩ ⟨for_increment⟩ ) {⟨construct_body⟩}


⟨for_to⟩
  for ( ⟨integer⟩ to ⟨integer⟩ ) ⟨construct_body⟩ end for
  for ( ⟨integer⟩ to ⟨integer⟩ ) {⟨construct_body⟩}


⟨break_when⟩
  break when ⟨variable⟩ is ⟨expression⟩
  ε


⟨as_expression⟩
  ⟨expression⟩ as ⟨variable⟩
  ⟨expression⟩ as ⟨variable⟩ => ⟨variable⟩


⟨for_each_as⟩
  for each ( ⟨as_expression⟩ ⟨break_when⟩ ) ⟨construct_body⟩ end for
  for each ( ⟨as_expression⟩ ⟨break_when⟩ ) {⟨construct_body⟩}


⟨for_each_in⟩
  for each ( ⟨variable⟩ in ⟨expression⟩ ⟨break_when⟩ ) ⟨construct_body⟩ end for
  for each ( ⟨variable⟩ in ⟨expression⟩ ⟨break_when⟩ ) {⟨construct_body⟩}


⟨for_each⟩
  ⟨for_each_as⟩
  ⟨for_each_in⟩


⟨until⟩
  loop until ( ⟨expression⟩ ) ⟨construct_body⟩ end loop
  loop until ( ⟨expression⟩ ) {⟨construct_body⟩}


⟨while⟩
  while ( ⟨expression⟩ ) ⟨construct_body⟩ end while
  while ( ⟨expression⟩ ) ⟨construct_body⟩


⟨try⟩
  try ⟨construct_body⟩ ⟨catch⟩ end try
  try {⟨construct_body⟩} ⟨catch⟩


⟨catch⟩
  catch ( ⟨variable⟩ ) ⟨construct_body⟩
  catch ( ⟨variable⟩ ) {⟨construct_body⟩}
  ε


⟨object_inner⟩
  ⟨identifier⟩ : ⟨value⟩ [, ⟨object_inner⟩]
  ⟨string⟩ : ⟨value⟩ [, ⟨object_inner⟩]


⟨object⟩
  {⟨object_inner⟩}
  { }


⟨object_accessor⟩
  ⟨variable⟩ -> ⟨object_accessor⟩
  ⟨variable⟩ -> ⟨variable⟩
  ⟨variable⟩ -> ⟨function_call⟩
  ⟨variable⟩ -> ⟨lambda_call⟩


⟨inherits⟩
  inherit ⟨identifier⟩
  ε


⟨namespace⟩
  namespace ⟨identifier⟩
  ε


⟨structure_inner⟩
  ⟨variable⟩
  ⟨assign⟩
  ⟨function⟩
  ε


⟨structure_id⟩
  structure
  struct
  class


⟨structure⟩
  ⟨structure_id⟩ ⟨identifier⟩ ⟨inherits⟩ ⟨namespace⟩ ⟨structure_inner⟩ end structure
  ⟨structure_id⟩ ⟨identifier⟩ ⟨inherits⟩ { ⟨namespace⟩ ⟨structure_inner⟩ }


⟨record_inner⟩
  ⟨type⟩ ⟨identifier⟩ = ⟨expression⟩
  ε


⟨record⟩
  record ⟨identifier⟩ {⟨record_inner⟩}
  record ⟨identifier⟩ is {⟨record_inner⟩}
  record structure ⟨identifier⟩ {⟨record_inner⟩}