Taaluketti
This page is in a very early stage of development.
Taaluketti is like Gaaziketti in many respects.
Parsing markers and modification
Every word-token (i.e. individual occurrence of a word in a sentence) will take one of four parsing markers:
(null) gather one, modify next
-s gather one, do not modify next
-n gather two, modify next
-k gather two, do not modify next
Parsing markers are not treated as words – they are “spoken punctuation”. All other morphemes are treated as words except those which are sub-elements of a compound-word. (Compound words are treated as words. Compounds words are strings of morphemes which morphemes, if they were words, would be words of type [Pc] – see below.)
Parsing markers clarify the structure of modification relations within a sentence. Modification is a relationship between one individual word-token, and another.
Each word-token is modified by some number (possibly zero) of other word-tokens. No word-token modifies more than one word-token. No word-token modifies a word-token in another sentence. No word-token modifies itself. No word-token modifies a word-token to its left.
Phrases and classes of phrases
Modification is a relation between word-tokens. But what about higher phrasal etc. syntactic relations? Well, suppose you’ve got a chain of word-tokens each (except the first) being modified just by its predecessor? Well, you assume a “((wx)y)z” type of phrasal pattern. Always. This is because each word is in fact a functor, and the words that modify it are the heads of the phrases which are its arguments. Functors always pick up arguments from their left (the opposite of standard mathematical notation).
A functor f together with its arguments forms a phrase, and f is said to be the head of that phrase.
When a functor modifies some other functor, this means that the phrase of which the modifying functor is the head is an argument of that other functor.
Phrases (including word-tokens, which are themselves phrases) may be classified into types (also called classes). Two basic types are the type [Ap], or adverbial phrase, and the type [S], or statement.
The notation “[x…x>y]” means that an item of the type [x...x>y] is a functor which takes any number of arguments of class x and, together with these arguments, forms a phrase of class y. So the class of the functor itself is [x…x>y]. In other words, if a functor f belongs to the class [x...x>y], any phrase of which it is the head is of the class [y]; and each of its arguments is of the class [x].
Words of the class [Ap…Ap>S] are called “predicate-cores”. We can use the symbol "[Pc]" as an abbreviation for "[Ap…Ap>S]". A predicate-core is a bit like a predicate in Loglan; however, it doesn’t have an order-based place-structure; and it doesn't have a fixed number of arguments. Syntactically speaking, a predicate-core can take any number of arguments (including 0) (even though some combinations of arguments might not make sense semantically speaking). Each of the arguments of a predicate-core will be an adverbial phrase [Ap]. The phrase thus formed will be a statement [S].
There are two kinds of adverbial phrase [Ap]. There are nominative adverbial phrases, which are just noun-phrases [Np]. And there are complex adverbial phrases, which consist of a noun-phrase followed by a postposition. Postpositions are functors which take a single argument of class [Np] and form a phrase of class [Ap], i.e. postpositions are of class [Np>Ap]. In summary: any noun-phrase is an adverbial phrase. And any phrase consisting of a single noun-phrase modifying a postposition is an adverbial phrase.
To make noun-phrases [Np], you’ve got a bunch of what are called noun-heads [Nh]. The commonest noun-head is le, meaning – roughly – ‘the’. A phrase of the form ‘Y le’ (‘Y’ being some phrase that is an argument of ‘le’) is a noun-phrase [Np], meaning ‘the (single) person/object x such that ‘x Y’ would be a true sentence’, i.e. ‘the x which satisfies ‘Y’ ’. If many Ys each modify le, then le denotes the x that satisfies all of those Ys.
