# ASL Language Examples

This file provides **ASL examples per grammar element**, designed as a knowledge base for LLM prompting and retrieval.

## Package + Import + System

```asl
// Minimal package/system
Package demo.minimal
System CoreSystem : Application
```

```asl
// Package with imports and richer system metadata
Package demo.sales
Import demo.shared.*
Import demo.billing.TaxRules
System SalesSystem "Sales Core" : Application:Application_Web [
    isReusable
    vendor "Acme Inc"
    version "1.0.0"
    tag(name "domain" value "sales")
    description "Sales platform core"
]
```

```asl
// Test suite style system
Package demo.tests
System ProductionSystem : Application

Package demo.testsuite
Import demo.tests.ProductionSystem
System RegressionSuite : Application [
    isTestSuite
    systemUnderTest ProductionSystem
    description "Automated regression suite"
]
```

---

## Tags, Dates, Percentages, and Generic Attribute Values

```asl
Package demo.values
System ValueSystem : Application [
    tag(name "release" value "2026-Q1")
    tag(name "qualityGate")
]

DataEntity e_Sprint : Master [
    attribute sprintNo : Integer
    attribute focus : String(100)
]

Data d_SprintData : e_Sprint := [
    [sprintNo, focus]
    [1, "Core Infrastructure"]
    [2, "Payments"]
]
```

```asl
// Date and percentage in Data rows (AttributeValue supports Date and Percentage)
Package demo.date
System DateSystem : Application

DataEntity e_Metrics : Master [
    attribute day_ : Date
    attribute completion : Decimal
]

Data d_Metrics : e_Metrics := [
    [day_, completion]
    [15-Jan-2026, 75%]
    [16-Jan-2026, 82.5%]
]
```

---

## Type Extension Elements

```asl
Package demo.extensions
System ExtSystem : Application

SystemType DomainSystem
SystemSubType Domain_Web
MetricType StoryPoints
ActorType Partner
ActiveEventType Webhook
ActiveTaskType Robot
ActiveFlowType Pipeline
UseCaseType EntityArchive
ActionType at_Approve
DataEntityType Ledger
DataEntitySubType Historical
DataEntityClusterType LedgerCluster
DataAttributeType UUID
ForeignKeyOnDeleteType SOFT_DELETE

UIContainerType Sidebar
UIContainerSubType Sidebar_Secondary
UIComponentType Kanban
UIComponentSubType Kanban_Board
UIWireframeType WFC_Timeline
UIComponentPartType Widget
UIComponentPartSubType Widget_Filter
UIActionType Sync
UIPortDefinitionType Routed
UIThrowingEventType NavigateBack
UISystemEventType Heartbeat
UIActionEventType Recovery
UIElementEventType Hover
UIElementEventSubType Hover_Enter

ContextDimensionDeviceType Kiosk
ScreenSizeCategoryType XXLarge
NetworkConnectivityType SATCOM
ContextDimensionSensorType Gyroscope
SensorStatusType Degraded
StereotypeType Compliance
```

---

## Stereotype

```asl
Package demo.stereotype
System StereotypeSystem : Application

stereotype secureData "Secure Data" : DataEntity [
    tag(name "classification" value "restricted")
    description "Marks sensitive data entities"
]
```

---

## Context + Context Dimensions

```asl
Package demo.context
System ContextSystem : Application

Actor a_User : User [
    description "Primary application user"
]

ContexDevice d_Phone : Smartphone [
    cpuRam 4096 Kb
    cpuProcessor 2400000 KHz
    battery 80 %
    screenDiagonalSize 640 pt
    screenSizeCategory Normal
    screenPixelSize 1080 x 2400 px
    screenDensity 440 dpi
    networkConnectivity WIFI
    description "Modern phone device profile"
]

ContexSensor s_GPS : Localization [
    status Active
]

Context c_MobileOnline [
    actor a_User
    device d_Phone
    sensor s_GPS
    tag(name "profile" value "mobile-online")
    description "Mobile context with network and localization"
]

ContextVariable cv_ConnectivityState [
    tag(name "source" value "runtime")
    description "Holds current connectivity state"
]
```

---

## Active Behavior Elements (Event, Task, TaskFlow)

```asl
Package demo.active
System ActiveSystem : Application

Event ev_OrderPlaced : Receive [
    isInitial
    description "Order request arrives"
]

Event ev_OrderDone : Send [
    isFinal
]

Task t_ValidateOrder : User [
    description "User validates order"
]

Task t_ChargePayment : Service [
    partOf mandatory t_ValidateOrder
]

TaskFlow tf_OrderPipeline : Sequence [
    activeElements ev_OrderPlaced, t_ValidateOrder, t_ChargePayment, ev_OrderDone
    description "Happy path event/task flow"
]
```

---

## DataEnumeration

```asl
Package demo.enums
System EnumSystem : Application

DataEnumeration enum_Status "Order Status" values(
    New,
    Processing "In Processing",
    Completed,
    Cancelled
) [
    tag(name "domain" value "orders")
    description "Order lifecycle states"
]
```

---

## DataEntity + Attributes + Constraints + Formulas

```asl
Package demo.entities
System DataSystem : Application

DataEntity e_Customer : Master [
    attribute customerId : Integer [constraints(PrimaryKey NotNull Unique) description "Primary customer key"]
    attribute email : Email [constraints(NotNull Unique)]
    attribute creditScore : Integer [constraints(Check(ScoreRange "creditScore >= 0 and creditScore <= 1000"))]
    constraints(showAs(email))
    description "Customer master"
]

DataEntity e_Order : Transaction [
    attribute orderId : Integer [constraints(PrimaryKey NotNull)]
    attribute customerRef : Integer [constraints(ForeignKey(e_Customer toField e_Customer.customerId onDelete CASCADE))]
    attribute amount : Decimal(10.2)
    attribute vat : Decimal [formula arithmetic(amount * "0.23")]
    attribute totalWithVat : Decimal [formula arithmetic(amount + vat)]
    attribute lineCount : Integer [formula details:count(e_Order)]
    attribute totalAmount : Decimal [formula details:sum(e_Order.amount)]
]
```

```asl
// Advanced constraints coverage (ManyToMany, Derived, multiplicity, DataEntityConstraint variants)
Package demo.constraints
System ConstraintSystem : Application

DataEntity e_Student : Master [
    attribute studentId : Integer [constraints(PrimaryKey NotNull)]
    attribute name_ : String(80)
]

DataEntity e_Course : Master [
    attribute courseId : Integer [constraints(PrimaryKey NotNull)]
    attribute title : String(120)
]

DataEntity e_Enrollment : Transaction [
    attribute studentId : Integer [constraints(ForeignKey(e_Student toField e_Student.studentId onDelete CASCADE))]
    attribute courseId : Integer [constraints(ForeignKey(e_Course toField e_Course.courseId onDelete CASCADE))]
]

DataEntity e_GradeBook : Transaction [
    attribute gradeId : Integer [constraints(PrimaryKey NotNull)]
    attribute score : Integer [constraints(multiplicity "1" NotNull Check(ScoreValid "score >= 0 and score <= 100"))]
    attribute passed : Boolean [constraints(Derived(score >= "60"))]
    attribute courses : Integer [constraints(ManyToMany(e_Course throughEntity e_Enrollment throughSourceField e_Enrollment.studentId throughTargetField e_Enrollment.courseId))]
    constraints(ReadOnly Encrypted Check(InternalRule "gradeId > 0"))
]
```

```asl
// DataEnumeration type in attributes
Package demo.attrtypes
System AttrTypeSystem : Application

DataEnumeration enum_Level values(Low, Medium, High)

DataEntity e_Risk : Master [
    attribute level : DataEnumeration enum_Level
]
```

---

## DataEntityCluster

```asl
Package demo.cluster
System ClusterSystem : Application

DataEntity e_Order : Transaction
DataEntity e_OrderItem : Transaction
DataEntity e_Payment : Transaction
DataEntity e_Product : Master

DataEntityCluster ec_OrderDomain "Order Domain" : Transaction [
    main e_Order
    child e_OrderItem [uses e_Product]
    child e_Payment
    uses e_Product
    tag(name "bounded-context" value "commerce")
    description "Order aggregate-like cluster"
]
```

---

## Data (tabular instances)

```asl
Package demo.data
System DataRowsSystem : Application

DataEntity e_Product : Master [
    attribute sku : String(30)
    attribute name_ : String(120)
    attribute price : Decimal(10.2)
]

Data d_SeedProducts : e_Product := [
    [sku, name_, price]
    ["P-100", "Starter Pack", 49.90]
    ["P-200", "Business Pack", 99.00]
    ["P-300", "Enterprise Pack", 199.50]
] [
    tag(name "seed" value "true")
    description "Initial product catalog"
]
```

---

## Action Types + Use Cases

```asl
Package demo.usecases
System UseCaseSystem : Application

Actor a_User : User
Actor a_Admin : User

DataEntity e_Ticket : Transaction [
    attribute id_ : Integer
    attribute title : String(120)
]

ActionType at_Submit
ActionType at_Assign

UseCase uc_CreateTicket : EntityCreate [
    actorInitiates a_User
    actorParticipates a_Admin
    dataEntity e_Ticket
    precondition "User is authenticated"
    postcondition "Ticket is stored"
    actions aCreate, at_Submit
    extensionPoints ep_Assignment ["Assign owner"]
    description "Create support ticket"
]

UseCase uc_AssignTicket : EntityUpdate [
    actorInitiates a_Admin
    dataEntity e_Ticket
    actions at_Assign
]

UseCase uc_CreateAndAssign : EntityUpdate [
    actorInitiates a_Admin
    includes uc_CreateTicket, uc_AssignTicket
    extends uc_CreateTicket onExtensionPoint ep_Assignment
    description "Composite orchestration use case"
]
```

---

## IncludeAll and IncludeElement

```asl
Package demo.source
System SourceSystem : Application [
    description "System exposing reusable elements"
]

DataEnumeration enum_Sharing values(Open_, Restricted)

DataEntity e_SharedEntity : Master [
    attribute id_ : Integer
]

DataEntityCluster ec_Sharing : Master [
    main e_SharedEntity
]

UseCase uc_SharedUseCase : EntityRead [
    actorInitiates a_SourceActor
    dataEntity e_SharedEntity
]

Actor a_SourceActor : User

Event ev_SharingEvent : Receive
Task t_SharingTask : Service
TaskFlow tf_SharingFlow : Sequence [
    activeElements ev_SharingEvent, t_SharingTask
]
```

```asl
Package demo.consumer
Import demo.source.SourceSystem
System ConsumerSystem : Application [
    description "System that consumes source elements"
]

IncludeAll fromSystem SourceSystem [
    description "Pull all source elements"
]

Include DataEntity fromSystem SourceSystem element e_SharedEntity [
    updateFields "nameAlias" with "Imported Shared Entity"
    tag(name "import-mode" value "explicit")
]

Include Actor fromSystem SourceSystem element a_SourceActor
Include DataEnumeration fromSystem SourceSystem element enum_Sharing
Include DataEntityCluster fromSystem SourceSystem element ec_Sharing
Include ActiveEvent fromSystem SourceSystem element ev_SharingEvent
Include ActiveTask fromSystem SourceSystem element t_SharingTask
Include ActiveFlow fromSystem SourceSystem element tf_SharingFlow
```

---

## UI Model Elements

```asl
Package demo.ui
System UISystem : Application

DataEntity e_User : Master [
    attribute id_ : Integer
    attribute name_ : String(80)
    attribute email : Email
]

Context c_Desktop

UIContainer ui_MainWindow : Window:Window_Modeless [
    isLandmark
    isDefault
    component cmp_UserList : List:List_Table [
        isScrollable
        "Users"
        "Browse system users"
        activationExpression "true"
        dataBinding e_User [
            visualizationAttributes e_User.name_, e_User.email
            searchAttributes e_User.name_, e_User.email
            sortAttributes e_User.name_
            conditionalExpression "name_ != null"
            orderBy e_User.name_ ASC
        ]
        recursiveNestedDataBinding e_User [
            visualizationAttributes e_User.name_
            sortAttributes e_User.name_
            conditionalExpression "name_ != null"
            orderBy e_User.name_ ASC
        ]
        dataFlowTo cmp_UserDetails withParameters (selectedId -> targetId)

        part p_Filter : Field:Field_Input:WFC_Text [
            String(80)
            defaultValue ""
            activationExpression "true"
            dataBinding e_User [
                visualizationAttributes e_User.name_
            ]
            dataAttributeBinding e_User.name_
            description "Search filter"
        ]

        event ev_OpenDetails : Submit:Submit_Read [
            interactionFlowExpression "open details"
            activationExpression "id_ > 0"
        ]

        selectedId
        description "User listing component"
    ]

    component cmp_UserDetails : Details:Form_Simple [
        "User Details"
        "Selected user info"
        targetId
        description "Destination component for data flow"
    ]

    action act_Sync : Server [
        event ev_SyncNormal : Normal [
            interactionFlowExpression "sync users"
            activationExpression "true"
        ]
        description "Synchronize data"
    ]

    event ev_TimerRefresh : Time [
        interactionFlowExpression "periodic refresh"
        activationExpression "true"
        triggeringExpressions "every 30 seconds"
    ]

    throwingEvent te_NavigateDetails : Jump [
        interactionFlowExpression "go details"
        activationExpression "true"
        navigationFlowTo cmp_UserList
    ]

    description "Main shell"
]

uiPortDefinition pd_Default : NotSpecified [
    description "Explicit UIPortDefinition example"
]
```

---

## UI Parameters and Parameter Bindings

```asl
Package demo.uiparams
System UIParamSystem : Application

UIContainer ui_Master : Window [
    navigationFlowTo cmp_Detail withParameters (userId -> selectedUserId)
    component cmp_Detail : Details [
        selectedUserId "Selected User"
    ]
    userId "User Identifier"
]
```

---

## UI Expressions

```asl
Package demo.uiexpr
System UIExprSystem : Application

Context c_NativeMobile

UIContainer ui_Conditional : Window [
    activationExpression "role == 'admin'"
]

UIContainer ui_ContextAware : Window [
    activationExpression validContext c_NativeMobile
]

UIContainer ui_WithBodyExpr : Window [
    activationExpression "custom-eval" [
        language "js"
        body "return user != null && user.active === true;"
    ]
]
```

---

## Views and Themes (System Sets)

```asl
Package demo.views
System ViewSystem : Application

Actor a_User : User
DataEntity e_Order : Transaction
UseCase uc_MakeOrder : EntityCreate []
UseCase uc_ReadOrder : EntityRead [
    actorInitiates a_User
    dataEntity e_Order
]

View v_UseCaseOverview : UseCaseView [
    uc_ReadOrder, uc_MakeOrder
    description "Focused use case projection"
]

Theme t_OrderOps : UseCaseTheme [
    uc_ReadOrder, e_Order
    description "Order operations theme"
]
```

---

## Include Element UpdateFields

```asl
Package demo.updatefields
Import demo.source.SourceSystem
System UpdateFieldSystem : Application

Include UseCase fromSystem SourceSystem element uc_SharedUseCase [
    updateFields "description" with "Customized imported use case", "nameAlias" with "Shared Reader"
]
```

---

## Expressions (boolean/comparison/membership/ternary)

```asl
Package demo.expressions
System ExprSystem : Application

DataEntity e_Score : Master [
    attribute score : Integer
    attribute status_ : String(20)
    attribute level_ : Integer
    attribute final_ : Integer [formula arithmetic(if score >= "60" then level_ else " 0")]
    attribute eligibility_ : Integer [formula arithmetic(if (score >= "60" && status_ == "Active") then "1" else "0")]
    attribute inBucket_ : Integer [formula arithmetic(if score in ["10", "20", "30"] then "1" else "0")]
]
```

---

## Complete Integrated Example

```asl
Package demo.complete
Import demo.shared.*
System FullSystem "Integrated Demo" : Application:Application_Web [
    isReusable
    vendor "Contoso"
    version "2.3.1"
    tag(name "domain" value "support")
    description "Integrated ASL example"
]

// Type extension
ActionType at_Escalate

// Context actor
Actor a_Requester : User
Actor a_Agent : User

// Data model
DataEnumeration enum_TicketStatus values(New_, Open_, Closed_)

DataEntity e_Ticket : Transaction [
    attribute id_ : Integer [constraints(PrimaryKey NotNull)]
    attribute title : String(120) [constraints(NotNull)]
    attribute status_ : DataEnumeration enum_TicketStatus
]

// Use case
UseCase uc_CreateTicket : EntityCreate [
    actorInitiates a_Requester
    actorParticipates a_Agent
    dataEntity e_Ticket
    actions aCreate, at_Escalate
    description "Create and optionally escalate ticket"
]

// Active behavior
Event ev_Submitted : Receive [isInitial]
Task t_Process : Service
Event ev_Closed : Send [isFinal]
TaskFlow tf_TicketLifecycle : Sequence [
    activeElements ev_Submitted, t_Process, ev_Closed
]

// UI + system set
UIContainer ui_TicketMain : Window [
    component cmp_Tickets : List [
        dataBinding e_Ticket [
            visualizationAttributes e_Ticket.title, e_Ticket.status_
        ]
    ]
]

View v_Main : UseCaseView [
    uc_CreateTicket
]
```

---