68 lines
2.6 KiB
Plaintext
68 lines
2.6 KiB
Plaintext
@c This document is part of the TAME manual.


@c Copyright (C) 20142023 Ryan Specialty, LLC.


@c Permission is granted to copy, distribute and/or modify this document


@c under the terms of the GNU Free Documentation License, Version 1.3 or


@c any later version published by the Free Software Foundation; with no


@c Invariant Sections, no FrontCover Texts, and no BackCover Texts.


@c A copy of the license is included in the section entitled ``GNU Free


@c Documentation License''.




@node Core Concepts


@chapter Core Concepts


@helpwanted




@cindex declarative, programming


@cindex imperative, programming


@tame is a @dfn{declarative} programming language@mdash{


}it @emph{describes} how a program ought to behave rather than


explicitly telling a computer the steps needed to make it work


(@dfn{imperative}).


@tame is a calculator at heart,


so code written in its language describes mathematical operations.


Definitions fall primarily under two categories:




@table @strong


@cindex classifications


@item Classifications


Higherorder logic used to classify data and predicate calculations,


controlling program flow.




@cindex calculations


@item Calculations


Mathematical operations motivated by linear algebra.


@end table




@tame also supports abstracting calculations into @dfn{functions},


which permits the use of recursion for solving problems that are


difficult to fit into an algebraic model.


The language is Turingcomplete.




@cindex metalanguage


@cindex domainspecific language


@tame itself is a @dfn{domainspecific language} (DSL)@mdash{


}it was designed for use in comparative insurance rating systems.


However,


it couldn't possibly know all useful abstractions that may be needed


in the future;


the domain for which @tame was designed encompasses many


subdomains as well.


To accommodate future needs,


@tame is also a @dfn{metalanguage}@mdash{


}a language that can be used to program itself.


The core language is based upon broad mathematical foundations


that offer great flexibility.


Its expressive template system allows the creation of abstractions


that are indistinguishable from core language features,


and templates have powerful introspective capabilities that allow


for many useful types of code generation.


Essentially,


@tame allows the creation of subDSLs.




Code is written in @tame without regard to order of execution@mdash{


}the linker will figure that out for you.


This simplifies the development of systems with complex graphs of


dependencies.




@todo{This chapter is a placeholder.


More to come.}
