INDEX

abs(integer) - > integer                                                    Integer Type

abs(real) -> real                                                               Real Type 

accept (boolean)                                                              Filters 

argument (term, integer) -> term                                    Inspecting Compound Terms

arity (term) -> integer                                                      Inspecting Compound Terms

arrays                                                                               Arrays

array(type, size)                                                               Array Creation

assignments                                                                     Assignments and Variables

backtracking                                                                     Backtracking 

blocks                                                                               Blocks

boolean type                                                                    Boolean Type

built-in definitions                                                           Built-in Definitions

categories                                                                        Categories

character set                                                                    Character Set

character type                                                                  Character Type

character (integer) -> character                                      Character Type 

collections                                                                       Collections

components                                                                     Components

copy (object1)  -> object1;                                               Object Types

definitions                                                                        Definitions

definition rules                                                                 Definition Rules 

descriptors                                                                       Descriptors 

enumeration types                                                           Enumeration Types

equivalent types                                                               Equivalent Types 

evaldef                                                                              Evaldef Function

exception(boolean, text)                                                  Exceptions

external interfaces                                                           External Interfaces 

foreign declarations                                                         External Interfaces

function definitions                                                          Function Definitions 

functor(term) -> symbol                                                   Inspecting Compound Terms

generic components                                                         Generic Components 

higher-order definitions                                                    Higher-order Definitions 

identifiers                                                                          Identifiers 

if boolean  then                                                                 Conditionals 

increase                                                                             Increase array

integer type                                                                       Integer Type

integer(character) -> integer                                             Character Type

integer(real) -> integer                                                      Real Type

integer(text) -> integer                                                      Text to integer conversion

intrinsic                                                                              Type Variables

invalid (object1) -> boolean;                                             Object Types

isinteger(text) -> boolean                                                  Text to integer test

isreal(text) -> boolean                                                       Text to real test

keywords                                                                            Identifiers

literals                                                                                Literals  

lists                                                                                    Lists 

log(text) -> nothing                                                            Log operations

logln(text) -> nothing                                                         Log operations

log(entity1) -> nothing                                                       Log operations

logln(entity1) -> nothing                                                    Log operations

mod(integer, integer) -> integer                                        Integer Type

name definitions                                                                Name Definitions

no (type-expression) -> empty-stream;                            Object Types

null (type-expression) -> null-value;                                 Object Types

object types                                                                       Object Types

operation definitions                                                         Operation Definitions

operators                                                                           Operators 

patterm matching                                                              Pattern Matching

quantifiers                                                                         Quantifiers 

quantifier propagation                                                      Quantifiers Propagation  

ready                                                                                 Repetitions 

real(integer) -> real                                                          Real Type

real(text) -> real                                                               Text to real conversion

real type                                                                            Real Type

recursive definitions                                                         Recursive Definitions 

refdef                                                                                Refdef Function

reject (boolean)                                                                Filters

repeat                                                                               Repetitions 

result(expression)                                                            Returning Results

return(expression)                                                            Returning Results 

same (object1, object1) -> boolean;                                Object Types

set_argument (term, integer, term) -> nothing                Inspecting Compound Terms

size(array)                                                                         Getting the Array Size

sqrt(real)                                                                           Real Type

streams                                                                             Streams 

subtypes                                                                           Subtypes

symbol type                                                                      Symbols 

symbol(text) -> symbol                                                     Symbols 

terms                                                                                Terms

text                                                                                   Text 

text(character) -> text                                                      Character to text conversion

text(integer) -> text                                                          Integer to text conversion

text(integer, width = integer) -> text                                Integer to limited text conversion

text(real) -> text                                                               Real to text conversion

text(real, width = integer) -> text                                     Real to limited text conversion

text(real, width, fraction) -> text                                      Real to formatted text conversion

text(symbol) -> text                                                          Symbols 

truncate                                                                            Truncate array  

types                                                                                 Types 

type conversions                                                               Type Conversions

type expressions                                                               Type Conversions

type propagation                                                               Type Propagation  

type variables                                                                    Type Variables

use directive                                                                      Use Directives 

valid (object1)  -> boolean;                                               Object Types

var                                                                                      Assignments and Variables

variables                                                                            Assignments and Variables

when boolean                                                                    Conditionals 

_ArrayPtr(array(entity1)) -> CarrayPtr                               Arrays in C

_Cstring(text)  -> CstringPtr                                               Strings in C

_text(CstringPrt) - > text                                                    Strings in C

 

            
Introduction

Home | Highlights of Elisa | Integrating Different Paradigms | Getting Started with Elisa | Demo's  | What is Domain Orientation | Bibliography | Copyright | News | Contact | Contents

Language Description:

Lexical Elements | Basic Data Types and Expressions | Definitions | Streams | Backtracking | Statements and Special Expressions | Arrays | Lists | Descriptors | Components | Collections | Generic Components | Terms | Categories | Types | Built-in Definitions | Higher-order Definitions | External Interfaces | Index 

Data Structures: Sequences | Examples involving Lists | Trees | Graphs | Searching State Spaces | Language Processing | Knowledge Representations
Domain Modeling:

Domain Modeling | Concepts | Domain Definitions | Domain Operations | Domain Implementations | Systems | Case study: an Order processing system | Case study: an Airport Support system | Domain Orientation versus Object Orientation

Design Patterns:

Introduction | Abstract Factory | Builder | Factory Method | Prototype | Singleton | Adapter | Bridge | Composite | Decorator | Facade | Flyweight | Proxy | Chain of Responsibility | Command | Interpreter | Iterator | Mediator | Memento | Observer | State | Strategy | Template Method | Visitor 

 

click tracking

 

Send me your comments

 

This page was last modified on 23-05-2012 15:01:29   

free hit counter