## raw-syntax.api
# Compiled by:
# src/lib/compiler/front/parser/parser.sublib# Here we define the raw syntax produced
# by the Mythryl parser
#
# src/lib/compiler/front/parser/yacc/mythryl.grammar
#
# and consumed by the typechecker, rooted at
# src/lib/compiler/front/typer/main/translate-raw-syntax-to-deep-syntax-g.pkg#
# -- which in turn returns deep syntax, defined in
#
# src/lib/compiler/front/typer-stuff/deep-syntax/deep-syntax.api# src/lib/compiler/front/typer-stuff/deep-syntax/deep-syntax.pkg#
# Nothing subtle here -- just a simple tree
# representation of Mythryl surface syntax.
#
# SOURCE CODE REGIONS:
# For debugging purposes, it is necessary to
# associate source file addresses (i.e., line
# and column numbers) with the various parts of
# the syntax tree.
#
# Rather than burden every syntax tree node type
# with this information, we segregate it in
# SOURCE_CODE_REGION_* nodes, one per union.
#
# This lets us achieve some separation of concerns
# between source-file annotations and the rest of
# the syntax tree semantics.
### "I love mathematics ... principally
### because it is beautiful, because
### man has breathed his spirit of play
### into it, and because it has given him
### his greatest game -- the encompassing
### of the infinite."
###
### -- Rozso Peter
api Raw_Syntax {
Fixity;
Symbol; # = symbol::Symbol
infixleft: Int -> Fixity;
infixright: Int -> Fixity;
Literal = multiword_int::Int;
# To mark positions in files:
#
Source_Code_Position = Int;
Source_Code_Region = (Source_Code_Position, Source_Code_Position);
#
# 2009-04-10 CrT: Above were opaque, but that made it difficult to synthesize raw syntax trees.
# Symbolic path:
#
Path = List( Symbol );
Fixity_Item(X)
=
{ item: X,
fixity: Null_Or( Symbol ),
source_code_region: Source_Code_Region
};
Package_Cast X
= NO_PACKAGE_CAST
| WEAK_PACKAGE_CAST X
| STRONG_PACKAGE_CAST X
| PARTIAL_PACKAGE_CAST X
;
Fun_Kind
= PLAIN_FUN
| METHOD_FUN # Nonstandard
| MESSAGE_FUN # Nonstandard
;
Package_Kind
= PLAIN_PACKAGE
| CLASS_PACKAGE # Nonstandard
| CLASS2_PACKAGE # Nonstandard
;
Raw_Expression
# Core expressions are those which don't
# involve module stuff like packages, apis
# and generics. Core expressions are about
# bread and butter variables, constants,
# addition, if-then-else etc etc:
#
= VARIABLE_IN_EXPRESSION Path # Variable.
| IMPLICIT_THUNK_PARAMETER Path # #x
| INT_CONSTANT_IN_EXPRESSION Literal # Integer.
| UNT_CONSTANT_IN_EXPRESSION Literal # Unsigned int literal.
| FLOAT_CONSTANT_IN_EXPRESSION String # Floating point coded by its string.
| STRING_CONSTANT_IN_EXPRESSION String # String.
| CHAR_CONSTANT_IN_EXPRESSION String # Char.
| FN_EXPRESSION List( Case_Rule ) # Anonymous function definition.
| RECORD_SELECTOR_EXPRESSION Symbol # Selector of a record field.
| PRE_FIXITY_EXPRESSION List( Fixity_Item( Raw_Expression ) ) # Expressions before fixity parsing.
| APPLY_EXPRESSION { function: Raw_Expression, argument: Raw_Expression } # Function application.
| OBJECT_FIELD_EXPRESSION { object: Raw_Expression, field: Symbol } # object->field.
| CASE_EXPRESSION { expression: Raw_Expression, rules: List( Case_Rule ) } # Case expression.
| LET_EXPRESSION { declaration: Declaration, expression: Raw_Expression } # Let expression.
| SEQUENCE_EXPRESSION List( Raw_Expression ) # Sequence of expressions.
| RECORD_IN_EXPRESSION List ((Symbol, Raw_Expression)) # Record.
| LIST_EXPRESSION List( Raw_Expression ) # [list, in, square, brackets]
| TUPLE_EXPRESSION List( Raw_Expression ) # Tuple (derived form).
| VECTOR_IN_EXPRESSION List( Raw_Expression ) # Vector.
| TYPE_CONSTRAINT_EXPRESSION { expression: Raw_Expression, constraint: Any_Type } # Type constraint.
| EXCEPT_EXPRESSION { expression: Raw_Expression, rules: List( Case_Rule ) } # Exception handler.
| RAISE_EXPRESSION Raw_Expression # Raise an exception.
| AND_EXPRESSION (Raw_Expression, Raw_Expression) # 'and' (derived form).
| OR_EXPRESSION (Raw_Expression, Raw_Expression) # 'or' (derived form).
| WHILE_EXPRESSION { test: Raw_Expression, expression: Raw_Expression } # 'while' (derived form).
| IF_EXPRESSION { test_case: Raw_Expression, # If-then-else (derived form).
then_case: Raw_Expression,
else_case: Raw_Expression
}
| SOURCE_CODE_REGION_FOR_EXPRESSION (Raw_Expression, Source_Code_Region) # For error messages.
also
Case_Rule
# Rules for case functions and exception handlers:
#
= CASE_RULE { pattern: Case_Pattern,
expression: Raw_Expression
}
also
Case_Pattern
# Here we define patterns for 'case'
# statements. These are also used in
# 'fun' function definitions and in
# 'except' statements, both of which
# incorporate disguised case statements:
#
= WILDCARD_PATTERN # Empty pattern.
| VARIABLE_IN_PATTERN Path # Variable pattern.
| INT_CONSTANT_IN_PATTERN Literal # Integer literal.
| UNT_CONSTANT_IN_PATTERN Literal # Unsigned integer literal.
| STRING_CONSTANT_IN_PATTERN String # String literal.
| CHAR_CONSTANT_IN_PATTERN String # Character literal.
| LIST_PATTERN List( Case_Pattern ) # [list, in, square, brackets]
| TUPLE_PATTERN List( Case_Pattern ) # Tuple.
| PRE_FIXITY_PATTERN List( Fixity_Item( Case_Pattern ) ) # Patterns prior to fixity parsing.
| APPLY_PATTERN { constructor: Case_Pattern, argument: Case_Pattern } # Constructor unpacking.
| TYPE_CONSTRAINT_PATTERN { pattern: Case_Pattern, type_constraint: Any_Type } # Type constraint.
| VECTOR_PATTERN List( Case_Pattern ) # Vector.
| OR_PATTERN List( Case_Pattern ) # '|'-pattern.
| AS_PATTERN { variable_pattern: Case_Pattern,
expression_pattern: Case_Pattern # 'as' expressions.
}
| RECORD_PATTERN { definition: List( ((Symbol, Case_Pattern)) ),
is_incomplete: Bool # Record.
}
| SOURCE_CODE_REGION_FOR_PATTERN (Case_Pattern, Source_Code_Region) # For error msgs etc.
also
Package_Expression
# Here we define 'package'- (i.e., module-) -valued
# expressions. We may reference a pre-existing package
# by name, define one by explicitly listing its elements,
# modify an exising one via api constraint, or
# generate a new one via generic expansion:
#
= PACKAGE_BY_NAME Path # Variable package.
| PACKAGE_DEFINITION Declaration # Defined package.
| CALL_OF_GENERIC (Path, List ((Package_Expression, Bool))) # Application (user-generated).
| INTERNAL_CALL_OF_GENERIC (Path, List ((Package_Expression, Bool))) # Application (compiler-generated).
| LET_IN_PACKAGE (Declaration, Package_Expression) # 'let' in package.
| PACKAGE_CAST (Package_Expression, Package_Cast( Api_Expression )) # Weak/strong/partial package cast to api.
| SOURCE_CODE_REGION_FOR_PACKAGE (Package_Expression, Source_Code_Region) # For error msgs etc.
also
Generic_Expression
# Here we define 'generic'-valued expressions.
# Much as with packages, we may reference a
# pre-existing generic by name, define one by
# explicitly listing its parameters and body,
# or generate a new one via higher-order generic
# expansion:
#
= GENERIC_BY_NAME (Path, Package_Cast( Generic_Api_Expression )) # Generic variable.
| LET_IN_GENERIC (Declaration, Generic_Expression)
| GENERIC_DEFINITION { # Explicit generic definition.
parameters: List ((Null_Or( Symbol ), Api_Expression)),
body: Package_Expression,
constraint: Package_Cast( Api_Expression )
}
| CONSTRAINED_CALL_OF_GENERIC ( Path, # Application.
List ((Package_Expression, Bool)), # Parameter (s).
Package_Cast( Generic_Api_Expression )) # Api constraint.
| SOURCE_CODE_REGION_FOR_GENERIC (Generic_Expression, Source_Code_Region) # For debugging msgs etc.
also
Api_Expression
# Here we define 'api'-valued expressions.
# Currently we can only reference a pre-existing
# api by name, or else define one by
# explicitly listing its elements, although
# allowing apis to take parameters is a
# common and easy extension, I'm told:
#
= API_BY_NAME Symbol # Api variable.
| API_WITH_WHERE_SPECS (Api_Expression, List( Where_Spec )) # Api with 'where' spec.
| API_DEFINITION List( Api_Element ) # Defined api.
| SOURCE_CODE_REGION_FOR_API (Api_Expression, Source_Code_Region) # For debugging msgs etc.
also
Where_Spec
# Define the '... where ...' clauses which
# may be appended to api constraints:
#
= WHERE_TYPE (List( Symbol ), List( Typevar ), Any_Type)
| WHERE_PACKAGE (List( Symbol ), List( Symbol ))
also
Generic_Api_Expression
# generic-api valued expressions.
# Once again, we can define one explicitly
# or reference a pre-defined one by name:
#
= GENERIC_API_BY_NAME Symbol # Generic api variable.
| GENERIC_API_DEFINITION { # Generic api definition.
parameter: List( (Null_Or( Symbol ), Api_Expression)),
result: Api_Expression
}
| SOURCE_CODE_REGION_FOR_GENERIC_API (Generic_Api_Expression, # For error messages etc.
Source_Code_Region)
also
Api_Element
# Here we define the various things that
# can appear inside a api definition:
#
= GENERICS_IN_API List ((Symbol, Generic_Api_Expression)) # Generic.
| VALUES_IN_API List ((Symbol, Any_Type)) # Value.
| EXCEPTIONS_IN_API List ((Symbol, Null_Or( Any_Type )) ) # Exception.
| PACKAGE_SHARING_IN_API List( Path ) # Package sharing.
| TYPE_SHARING_IN_API List( Path ) # Type sharing.
| IMPORT_IN_API Api_Expression # Include specifier.
| PACKAGES_IN_API List ( (Symbol, # Package.
Api_Expression,
Null_Or( Path )) )
| TYPES_IN_API ( ( List ( ( Symbol, # Type.
List( Typevar ),
Null_Or( Any_Type ))
),
Bool)
)
| VALCONS_IN_API { sumtypes: List( Sumtype ),
with_types: List( Named_Type )
}
| SOURCE_CODE_REGION_FOR_API_ELEMENT (Api_Element, Source_Code_Region) # For error messages etc.
also
Declaration
#
# Here we define the declarations which may
# appear in 'stipulate' statements and package
# definitions:
#
= VALUE_DECLARATIONS ((List( Named_Value ), List( Typevar )) ) # Values.
| FIELD_DECLARATIONS ((List( Named_Field ), List( Typevar )) ) # OOP 'field' declarations. (nonstandard)
| EXCEPTION_DECLARATIONS List( Named_Exception ) # Exception.
| PACKAGE_DECLARATIONS List( Named_Package ) # Packages.
| TYPE_DECLARATIONS List( Named_Type ) # Type declarations.
| GENERIC_DECLARATIONS List( Named_Generic ) # Generics.
| API_DECLARATIONS List( Named_Api ) # APIs.
| GENERIC_API_DECLARATIONS List( Named_Generic_Api ) # generic apis.
| LOCAL_DECLARATIONS (Declaration, Declaration) # Local declarations.
| SEQUENTIAL_DECLARATIONS List( Declaration ) # Sequences of declarations.
| INCLUDE_DECLARATIONS List( Path ) # 'include's of other packages.
| OVERLOADED_VARIABLE_DECLARATION (Symbol, Any_Type, List(Raw_Expression), Bool) # Operator overloading.
| FIXITY_DECLARATIONS { fixity: Fixity, ops: List( Symbol ) } # Operator fixities.
| FUNCTION_DECLARATIONS (List Named_Function, List Typevar) # Mutually recursive functions.
| NADA_FUNCTION_DECLARATIONS (List Nada_Named_Function, List Typevar) # Mutually recursive functions.
| RECURSIVE_VALUE_DECLARATIONS ( (List( Named_Recursive_Value ), # Recursive values.
List( Typevar ))
)
| SUMTYPE_DECLARATIONS { sumtypes: List( Sumtype ), # BAR | ZOT part of Foo = BAR | ZOT.
with_types: List( Named_Type )
}
| SOURCE_CODE_REGION_FOR_DECLARATION (Declaration, Source_Code_Region) # For error messages etc.
| PRE_COMPILE_CODE String # Support for #DO set_control "FOO" "BAR"<eol>
also
Named_Field
#
# OOP 'field' declarations (nonstandard)
#
= NAMED_FIELD { name: Symbol,
type: Any_Type,
init: Null_Or( Raw_Expression )
}
| SOURCE_CODE_REGION_FOR_NAMED_FIELD (Named_Field, Source_Code_Region)
also
Named_Value
#
# Your everyday vanilla 'let' namings.
# The 'lazy' flag is in support of an
# experimental extension:
#
= NAMED_VALUE { pattern: Case_Pattern,
expression: Raw_Expression,
is_lazy: Bool
}
| SOURCE_CODE_REGION_FOR_NAMED_VALUE (Named_Value, Source_Code_Region)
also
Named_Recursive_Value
#
# Namings for the 'let rec ...' construct:
#
= NAMED_RECURSIVE_VALUE { variable_symbol: Symbol,
fixity: Null_Or( (Symbol, Source_Code_Region) ),
expression: Raw_Expression,
null_or_type: Null_Or( Any_Type ),
is_lazy: Bool
}
| SOURCE_CODE_REGION_FOR_RECURSIVELY_NAMED_VALUE (Named_Recursive_Value, Source_Code_Region)
also
Named_Function
#
# Handle 'fun f X (x)=x | f Y (y)=y | ...' constructs,
# one pattern_clause per alternative:
#
= NAMED_FUNCTION
{ kind: Fun_Kind,
pattern_clauses: List( Pattern_Clause ),
is_lazy: Bool,
null_or_type: Null_Or(Any_Type)
}
| SOURCE_CODE_REGION_FOR_NAMED_FUNCTION (Named_Function, Source_Code_Region)
also
Pattern_Clause
#
= PATTERN_CLAUSE
{ patterns: List( Fixity_Item( Case_Pattern ) ),
result_type: Null_Or( Any_Type ),
expression: Raw_Expression
}
also
Nada_Named_Function
#
# Handle 'fun f X (x)=x | f Y (y)=y | ...' constructs,
# one Nada_Pattern_Clause per alternative:
#
= NADA_NAMED_FUNCTION ((List( Nada_Pattern_Clause ), Bool))
| SOURCE_CODE_REGION_FOR_NADA_NAMED_FUNCTION (Nada_Named_Function, Source_Code_Region)
also
Nada_Pattern_Clause
#
= NADA_PATTERN_CLAUSE { pattern: Case_Pattern,
result_type: Null_Or( Any_Type ),
expression: Raw_Expression
}
also
Named_Type
#
= NAMED_TYPE { name_symbol: Symbol,
definition: Any_Type,
typevars: List( Typevar )
}
| SOURCE_CODE_REGION_FOR_NAMED_TYPE (Named_Type, Source_Code_Region)
also
Sumtype
#
= SUM_TYPE { name_symbol: Symbol,
typevars: List( Typevar ),
right_hand_side: Sumtype_Right_Hand_Side,
is_lazy: Bool
}
| SOURCE_CODE_REGION_FOR_UNION_TYPE (Sumtype, Source_Code_Region)
also
Sumtype_Right_Hand_Side
#
# The first case handles vanilla union type definitions,
# the second case handles 'Foo == abc::Bar' ones:
= VALCONS List( (Symbol, Null_Or( Any_Type )) )
| REPLICAS List( Symbol )
also
Named_Exception
#
= NAMED_EXCEPTION { exception_symbol: Symbol, # Explicit exception definition.
exception_type: Null_Or( Any_Type )
}
| DUPLICATE_NAMED_EXCEPTION { exception_symbol: Symbol, # Defined by equality.
equal_to: Path
}
| SOURCE_CODE_REGION_FOR_NAMED_EXCEPTION (Named_Exception, Source_Code_Region)
also
Named_Package
#
= NAMED_PACKAGE { name_symbol: Symbol,
definition: Package_Expression,
constraint: Package_Cast( Api_Expression ),
kind: Package_Kind
}
| SOURCE_CODE_REGION_FOR_NAMED_PACKAGE (Named_Package, Source_Code_Region)
also
Named_Generic
#
= NAMED_GENERIC { name_symbol: Symbol,
definition: Generic_Expression
}
| SOURCE_CODE_REGION_FOR_NAMED_GENERIC (Named_Generic, Source_Code_Region)
also
Named_Api
#
= NAMED_API { name_symbol: Symbol,
definition: Api_Expression
}
| SOURCE_CODE_REGION_FOR_NAMED_API (Named_Api, Source_Code_Region)
also
Named_Generic_Api
#
= NAMED_GENERIC_API { name_symbol: Symbol,
definition: Generic_Api_Expression
}
| SOURCE_REGION_FOR_NAMED_GENERIC_API (Named_Generic_Api, Source_Code_Region)
also
Typevar
#
= TYPEVAR Symbol
| SOURCE_CODE_REGION_FOR_TYPEVAR (Typevar, Source_Code_Region)
also
Any_Type
#
= TYPEVAR_TYPE Typevar # Type variable.
| TYPE_TYPE (List( Symbol ), List( Any_Type )) # Type constructor.
| RECORD_TYPE List ((Symbol, Any_Type)) # Record.
| TUPLE_TYPE List( Any_Type ) # Tuple.
| SOURCE_CODE_REGION_FOR_TYPE (Any_Type, Source_Code_Region); # For error messages etc.
}; # Api Raw_Syntax
## Copyright 1992 by AT&T Bell Laboratories
## Subsequent changes by Jeff Prothero Copyright (c) 2010-2015,
## released per terms of SMLNJ-COPYRIGHT.