lambda.yaml

#
# CEKF - VM supporting amb
# Copyright (C) 2022-2024  Bill Hails
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.
#

config:
    name: lambda
    description: Plain lambda structures generated by lambda conversion.
    parserInfo: true
    includes:
    - utils.h
    limited_includes:
    - bigint.h
    - tc.h
    - tc_debug.h
    - minlam_functions.h

structs:
    LamLam:
        meta:
            brief: A lambda expression
            description: >-
                If isLazy is true,
                all arguments are expected to be thunked (lazy).
        data:
            args: SymbolList
            exp: LamExp
            isLazy: bool=false

    LamPrimApp:
        meta:
            brief: A primitive operation application
        data:
            type: LamPrimOp
            exp1: LamExp
            exp2: LamExp
            replacement: LamExp=NULL

    LamSequence:
        meta:
            brief: A sequence of lambda expressions e.g. (begin ...)
        data:
            exp: LamExp
            next: LamSequence

    LamArgs:
        meta:
            brief: Actual arguments to a LamApply.
        data:
            exp: LamExp
            next: LamArgs

    LamApply:
        meta:
            brief: A function application.
        data:
            function: LamExp
            args: LamArgs
            isBuiltin: bool=false

    LamLookUp:
        meta:
            brief: A lookUp in a nameSpace
            description: >-
                Represents the evaluation of an expression
                in a different nameSpace.
        data:
            nsId: int
            nsSymbol: HashSymbol
            exp: LamExp

    LamLookUpSymbol:
        meta:
            brief: A lookUp of a symbol (constructor) in a nameSpace.
        data:
            nsId: int
            nsSymbol: HashSymbol
            symbol: HashSymbol

    LamConstant:
        meta:
            brief: A constant type constructor with no arguments.
        data:
            name: HashSymbol # the name of the constructor
            tag: int         # the tag of the constructor

    LamConstruct:
        meta:
            brief: A constructor application
        data:
            name: HashSymbol # the name of the constructor
            tag: int         # the tag of the constructor
            args: LamArgs    # the remaining arguments to make-vec

    LamDeconstruct:
        meta:
            brief: A deconstruction of a constructor
            description: >-
                Used to extract fields from a constructed value.
        data:
            name: HashSymbol # name of the constructor being deconstructed
            nsId: int        # nameSpace of the constructor being deconstructed
            vec: int         # offset of the field in the vector
            exp: LamExp      # expression being deconstructed

    LamTupleIndex:
        meta:
            brief: An index into a tuple
        data:
            vec: int         # offset of the field in the untagged tuple vector
            size: int        # size of the tuple
            exp: LamExp      # expression being accessed

    LamMakeVec:
        meta:
            brief: A vector constructor
            description: >-
                This structure represents the internal construction of a
                type instance (represented as a vector) from a list of arguments.
        data:
            nArgs: int
            args: LamArgs

    LamIff:
        meta:
            brief: An if-then-else expression
        data:
            condition: LamExp
            consequent: LamExp
            alternative: LamExp

    LamCond:
        meta:
            brief: A conditional expression with multiple cases.
            description: >-
                Used internally by the generated TPMC code, the cases can
                be either integers (matcing type constructors) or characters
                (matching literal characters). The type of the value must match
                the type of the cases.
        data:
            value: LamExp
            cases: LamCondCases

    LamIntCondCases:
        meta:
            brief: Integer conditional cases
            description: >-
                Used internally by the generated TPMC for matching type constructor ids.
        data:
            constant: MaybeBigInt
            body: LamExp
            next: LamIntCondCases

    LamCharCondCases:
        meta:
            brief: Character conditional cases
            description: >-
                Holds a list of character conditional cases
                generated by the TPMC for matching literal characters.
        data:
            constant: character
            body: LamExp
            next: LamCharCondCases

    LamMatch:
        meta:
            brief: An integer matching expression
            description: >-
                Matches an integer index against multiple lists of cases. Each list
                of cases is associated with a body expression to be executed on match.
                Again this is generated by the TPMC.
        data:
            index: LamExp
            cases: LamMatchList

    LamMatchList:
        meta:
            brief: A list of pattern matching cases
            description: >-
                One set of cases in a LamMatch.
        data:
            matches: LamIntList
            body: LamExp
            next: LamMatchList

    LamIntList:
        meta:
            brief: A list of integers
            description: >-
                The list of integers in a LamMatchList.
                Includes a namespace id and name (why?).
        data:
            item: int
            name: HashSymbol
            nsId: int
            next: LamIntList

    LamLet:
        meta:
            brief: A let expression
        data:
            bindings: LamBindings
            body: LamExp

    LamLetRec:
        meta:
            brief: A letrec expression
        data:
            bindings: LamBindings
            body: LamExp

    LamLetStar:
        meta:
            brief: A let* expression
        data:
            bindings: LamBindings
            body: LamExp

    LamBindings:
        meta:
            brief: Bindings in a let or letrec expression
        data:
            var: HashSymbol
            val: LamExp
            next: LamBindings

    LamContext:
        meta:
            brief: A context for lambda expressions
        data:
            frame: LamInfoTable
            aliases: LamAliasTable
            macros: SymbolSet
            parent: LamContext

    LamAmb:
        meta:
            brief: An amb expression
        data:
            left: LamExp
            right: LamExp

    LamPrint:
        meta:
            brief: A print expression
            description: >-
                This structure represents a print expression that outputs
                the value of an expression to the console.
        data:
            exp: LamExp
            printer: LamExp=NULL

    LamTypeOf:
        meta:
            brief: A typeOf expression
        data:
            exp: LamExp
            typeString: LamExp=NULL # assgned by the type checker

    LamTypeDefs:
        meta:
            brief: Type definitions in a lambda expression
            description: >-
                This structure holds type definitions.
                It is prepended to Each letrec and any
                typeDefs in the letrec are hoisted into this section.
        data:
            typeDefs: LamTypeDefList
            body: LamExp

    LamTypeDefList:
        meta:
            brief: A list of type definitions
            description: >-
                contained by a LamTypeDefs structure.
        data:
            typeDef: LamTypeDef
            next: LamTypeDefList

    LamTypeDef:
        meta:
            brief: A single type definition
        data:
            type: LamTypeSig # re-use
            constructors: LamTypeConstructorList

    LamTypeConstructorList:
        meta:
            brief: A list of type constructors forming the body of a typedef.
        data:
            constructor: LamTypeConstructor
            next: LamTypeConstructorList

    LamTypeSig:
        meta:
            brief: A type signature
            description: >-
                This structure represents a type signature that includes the
                name of the type and its argument type variables.
        data:
            name: HashSymbol
            args: LamTypeSigArgs

    LamTypeTags:
        meta:
            brief: Tags for a type constructor
            description: >-
                This structure holds tags that are associated with a type
                in the type constructor info metadata.
        data:
            tag: HashSymbol
            next: LamTypeTags

    LamTypeSigArgs:
        meta:
            brief: Argument type variables for a type signature
        data:
            name: HashSymbol
            next: LamTypeSigArgs

    LamTypeConstructor:
        meta:
            brief: A type constructor as part of a typedef.
        data:
            name: HashSymbol
            type: LamTypeSig
            args: LamTypeConstructorArgs

    LamTypeConstructorArgs:
        meta:
            brief: Formal arguments for a type constructor
        data:
            arg: LamTypeConstructorType
            next: LamTypeConstructorArgs

    LamTypeFunction:
        meta:
            brief: A type function as a formal argument to a type constructor
        data:
            name: LamLookUpOrSymbol
            args: LamTypeConstructorArgs

    LamTypeConstructorInfo:
        meta:
            brief: Information about a type constructor
        data:
            name: HashSymbol
            nsId: int
            type: LamTypeConstructor
            tags: LamTypeTags
            needsVec: bool # does this need to be a vector?
            arity: int # number of arguments to this constructor
            size: int # number of alternatives
            index: int # index into list of alternatives

enums:
    LamPrimOp:
        meta:
            brief: Primitive operations
        data:
            - ADD
            - SUB
            - MUL
            - DIV
            - MOD
            - GCD
            - LCM
            - CANON
            - POW
            - EQ
            - NE
            - GT
            - LT
            - GE
            - LE
            - CMP
            - VEC

unions:
    LamExp:
        meta:
            brief: A lambda expression
        data:
            amb: LamAmb
            apply: LamApply
            args: LamArgs # so that ANF normalize can be uniformly typed
            back: void_ptr
            bigInteger: MaybeBigInt
            bindings: LamBindings # so that ANF normalize can be uniformly typed
            callCC: LamExp
            character: character
            cond: LamCond
            constant: LamConstant
            construct: LamConstruct
            constructor: LamTypeConstructorInfo
            deconstruct: LamDeconstruct
            env: void_ptr
            error: void_ptr
            iff: LamIff
            lam: LamLam
            let: LamLet
            letRec: LamLetRec
            letStar: LamLetStar
            lookUp: LamLookUp
            makeTuple: LamArgs
            makeVec: LamMakeVec
            match: LamMatch
            nameSpaces: LamNameSpaceArray
            prim: LamPrimApp
            print: LamPrint
            sequence: LamSequence
            stdint: int
            tag: LamExp
            tupleIndex: LamTupleIndex
            typeDefs: LamTypeDefs
            typeOf: LamTypeOf
            var: HashSymbol

    LamLookUpOrSymbol:
        meta:
            brief: A lookUp or symbol in a nameSpace
            description: >-
                Represents either a lookUp of a symbol in a
                nameSpace or a symbol in the current nameSpace.
        data:
            symbol: HashSymbol
            lookUp: LamLookUpSymbol

    LamCondCases:
        meta:
            brief: Cases for a LamCond
        data:
            integers: LamIntCondCases
            characters: LamCharCondCases

    LamTypeConstructorType:
        meta:
            brief: A type constructor type
            description: >-
                Defines the different types of arguments that can
                be passed to a type constructor.
        data:
            integer: void_ptr
            character: void_ptr
            var: HashSymbol
            function: LamTypeFunction
            tuple: LamTypeConstructorArgs

    LamInfo:
        meta:
            brief: Information about a symbol
        data:
            typeConstructorInfo: LamTypeConstructorInfo
            nameSpaceInfo: LamContext
            nsId: int

hashes:
    LamInfoTable:
        meta:
            brief: Map from symbols to information about them
            description: >-
                This table holds information about symbols in the current context.
        data:
            entries: LamInfo

    LamAliasTable:
        meta:
            brief: Map from symbols to their types in the body of a type constructor.
        data:
            entries: LamTypeConstructorType

    LamExpTable:
        meta:
            brief: Map from symbols to lambda expressions
            description: >-
                This table holds lambda expressions that are associated with
                symbols in the current context, used for macro arguments where
                the expressions are passed in unevaluated.
        data:
            entries: LamExp

arrays:
    LamNameSpaceArray:
        meta:
            brief: A list of nameSpaces
            description: >-
                This array holds the bodies of nameSpaces that are currently
                in scope.  The ubiquitous `ns_id` is an index into this array.
        data:
            entries: LamExp

primitives: !include primitives.yaml

external:
- !include tc.yaml
- !include utils.yaml