/* (c) https://github.com/MontiCore/monticore */
package de.monticore.types;

/* This is a MontiCore stable grammar.
 * Adaptations -- if any -- are conservative. */

import de.monticore.types.*;

/**
 * This grammar introduces additional structural types
 * as known partially from modern programming languages, like Kotlin.
 *
 * Union types: A|B
 * Intersection types: A&B
 * Tuple types: (A, B)
 * Bracket types: (A)  (i.e. actually a tuple with a single argument
 *          which is regarded to be isomporhic to its argument)
 *
 * These structural types simplify the definitipon of new types 
 * as results of functions, grouping values, providing alternatives
 * results, etc.
 *
 * In a union type A|B value v is either of type A or B 
 * and only the operations apply, that are shared by both.
 * In an intersection type A&B value v is necessarily member of both 
 * types, which is only possible if common subclasses exist, then
 * all operations of A or B can be applied to v. 
 *
 * The above types are actually type constructors with two (or several)
 * types as arguments and special typing rules.
 *
 * This modularity of types and associated expressions greatly eases
 * the reuse of type structures in languages.
 *
 * This grammar is part of a hierarchy of types, which can be found
 * under
 *   https://github.com/MontiCore/monticore/blob/dev/monticore-grammar/
 *                 src/main/grammars/de/monticore/types/Types.md
 *
 */
 
component grammar MCStructuralTypes
          extends MCBasicTypes {

  /** ASTMCUnionType represents union types.
   *
   * Values of a union type are of (at least one of) the types in the union.
   * Example:
   * String|int   var1 = "Person";
   * String|int   var2 = 3;
   */
  MCUnionType implements MCType <140> =
    left:MCType "|" right:MCType
  ;

  /** ASTMCIntersectionType represents intersection types.
   *
   * Values of an intersection type are of all the types in the intersection.
   * Example:
   * (Assuming Car and Boat are not in a subtyping relationship, but share 
   * a common subclass AmphibianVehicle)
   * AmphibianVehicle amphibianVehicle = ...;
   * Car      c = amphibianVehicle;
   * Boat     b = amphibianVehicle;
   * Car&Boat a = amphibianVehicle;
   */
  MCIntersectionType implements MCType <160> =
    left:MCType "&" right:MCType
  ;

  /** ASTMCTupleType represents tuple types.
   * Tuple types have at least two elements.
   *
   * Values of a tuple type are a tuple of values 
   * Example:
   * (float, int) vec2 = (1.1f, -2);
   */
  MCTupleType implements MCType <30> =
    "(" MCType "," (MCType || ",")+ ")"
  ;

  /** ASTMCBracketType represents a type written in parentheses.
   *
   * The type is the type written inside the parentheses, e.g.,
   * (A | B) is the same type as A | B
   * (((A))) is the same type as A
   */
  MCBracketType implements MCType <300> =
    "(" MCType ")"
  ;

}