pe’kelkapak aoef ‘eflál ska soslap folo thekelkakof osa paak.

100 followers!

I now have 100 followers on this blog! I should do something to celebrate! Anyone have any requests/ suggestions?

Pekalit pronouns & indices

Pekalit’s has only three classic pronouns, which can take perfectly regular case markings like other nouns. There is no distinction of number, gender, animacy, or anything else — just person.

  • ta, first person (I, me, we, us)
  • sjo, second person (you)
  • kje, third person (he, she, it, they)

This can lead to confusion.

There is a second type of pronominal system in place, referred to as indexing. Indices are simply numerals (ki = one, tje = 2, etc) which take an “index marker” (-l). Indices can be assigned to nouns or pronouns, and, after they are assigned, function as (pro-)pronouns within the sentence, ditching the index marker to take case instead.

For example, 

kjet¹ kil¹ njasj kje² tjel² pin tjet² patatokeh.
3-NOM¹ CL¹ see-TR 3-ACC² CL² and CL-NOM² smile-IN
'he¹ saw him² and he² smiled.'

Indices also codify all other information that was attached to the original noun phrase.

kjet¹ kil¹ pjalap¹ motasj kje² tjel². kit¹ patah.
3-NOM¹ CL¹ many-ADJ meet-TR 3-ACC² CL². CL-NOM¹ happy-IT
'They¹ met him². They¹ were pleased.'

lot¹ kil¹ pjalap¹ patap¹ la motasj lo² tjel² pjip² tolop² i. 
kit¹ tolop kih.

person¹ CL¹ many happy DEF meet person² CL² few sad INDEF. 
CL¹ sad become.
'The many¹ happy¹ people¹ met a few² sad² people². 
'The many¹ happy¹ people¹ (/[they]¹) became sad.'

(and then the people previously known as happy…)

The ‘many happy people’ example could have been written without the use of any indices, and the pronoun kjet could have taken kit's place in the second clause. However, both constructions are grammatical, and if the story of the many happy people was to go on, the indices would become useful. 

It is important to note that indices are not exclusively third-person, and can also mark second and even first-person groups, in order to set them apart; for instance, to differentiate between inclusive and exclusive ‘we’.

tat kalih tok tat kil tjep tjosj talek, pe tat tjel pjalap!
kit kjarisj roki! tjet pe!
1 say past 1¹ CL¹ two¹ go future, NEG 1² CL² many²!
CL¹ have plan! CL² NEG!
'I said that we¹ (two¹) would go, not us² (many²)!
'[We]¹ have a plan! [We]² don't!'

requiresheavywizardry:

Haedus Toolbox SCA, Manual

Introduction

The Haedus Toolbox SCA was designed to address one specific and pernicous problem with other sound-change applier programs in common use withing the conlang community, namely that single sounds often need to be represented by two or mor characters, whether that is ‘ts’, ‘tʰ’, or ‘qʷʰ’. This relieves the user from having to artificially re-order rules because ‘p > b’ happens to also affect ‘pʰ’ even when the intent of the user is for these to be distinct and segments. The SCA can infer the what sequences should be treated as unitary by attaching diacritics and modifier letters to a preceding base character. The user can also manually specify sequences that should be treated as atomic.

Running The SCA

To use the SCA, the user must provide a lexicon and rules file. In stand-alone operation, it can be run using the command

java -jar sca.jar LEXICON RULES OUTPUT

with the user providing paths for the worlist, rules, and output file. This can, of course, be placed into a batch or shell script for your convenience. However, running SCA through a terminal is recommended, so that any errors can be printed to the terminal. Later versions will permit the user to provide only the script, in which the input and output paths are specified

Scripts

Operation of the SCA is controlled through a script file while primarily contains rule definitions, but which also allows the user to define variables, reserve character sequences, and control segmentaton and normalization. Lists of things, like sources and targets in rules, the contents of sets inside conditions, variable definitions, and commands to reserve character sequences are all delimited by whitespace (the space character, or tab) and is quantity-insensitive, so you can use extra spaces, or tabs to make columns align, as you will see throughout the examples.

While whitespace is used to separate items in lists, padding around operators and delimiters is optional. As elsewhere the quantity is not important.

The following characters have special meanings in the SCA script language and cannot be used elsewhere: >, /, _, #, $, %, *, ?, +, !, (, ), {, }, ., =

Script files may contain comments, starting with %, either at the beginning of a line, or in-line.

Command

Apart from rules and variables, there are additional commands used to control segmenation and normalziation and reserve sequences to be treated as atomic. This is controlled by the following command, plus one of the listed flags

NORMALIZATION:

  • NFD Canonical decomposition (default)
  • NFC Canonical decomposition, followed by canonical composition
  • NFKD Compatibility decomposition
  • NFKC Compatibility decomposition followed by compatibility composition
  • NONE No normalization; input is not modified

SEGMENTATION:

  • TRUE By default, automatic segmentation is used
  • FALSE Treats each input character as atomic, except where characters are reserved by the use

Variables

The SCA allows for the definition of variables (and re-definition) on-the-fly, anywhere in the script. Variables definitions consist of a label, the assignment operator = and a space-separated list of values. For example:

TH = pʰ tʰ kʰ
T  = p  t  k
D  = b  d  g
W  = w  y  ɰ
N  = m  n
C  = TH T D W N r s

The values may contain other variable labels. There are no restrictions on variable naming - it is up to the user to avoid conflicts. However, when SCA parses a rule or variable definition, it searches for variables by finding the longest matching lable. If you have T, H, and TH defined as variables, a rule containing TH will always be understood to represent the variable TH, and not T followed by H.

If you wish to define longer variable names, you can use a non-reseved prefix like & or @, or wrap the name in square brackets.

The Rule Format

The syntax for rules is desinged to be similar to that used to describe sound changes in linguistics generally, and to support pattern matching using regular expressions.

This SCA uses > as the transformation operator, and separates the transformation and condition using /. The condition is not required and rules lacking a condition do not require the the / symbol. When the / symbol is present, the precondition-postcondition separator _ must appear exactly once.

Some basic rules are:

pʰ tʰ kʰ > f  θ  x
p  t  k  > b  d  g  / N_
p  t  k  > pʰ tʰ kʰ / _V

[Aspirata] > [Anaspirata]

The first part of the rule (before /) is the transform which may contain literals and variables, as well as sequences of both.

Note that if mutliple sounds converge (or are deleted), such as a merger of e and o with a, then the following are equivalent:

e o > a a
e o > a

Deletion

Segments can be deleted by transforming them to 0 (the character zero). This can be written as follows:

x h > 0

Just as with other transformations, if all segments are to be deleted, then the rule can be written as shown above. However, one can also write a zero along with other sounds as follows:

w s h > 0 h 0 / #_

Indices and Backreferences

The SCA permits the transform of rules to contain backreferences which can be very useful in writing rules for metathesis or total assimilation. For example

C = p t k
N = n m
CN > $2$1

allows us to easily represent metathesis, swapping N and C wherever N is found following C.

When SCA parses a rule, it keeps track of each variable in the source part of the transform and knows in the above example, that C is at index 1 and N is at index 2. The target part of the transform lets us refer back to this using the $ symbol and the index of the variable we wish to refer to.

We can actually go slightly further, however and use the indices on a different variable. In a slighly variation on the previous example, we can write

C = p t k
G = b d g
N = n m
CN > $2$G1

which does the same as the above, but also replaces any element of C with the corresponding element of G. So, if a word is atna, the rule will change it to anda.

This can also be used for some kinds of assimilation and dissimilation, such as simplifying clusters of plosives by changing the second to be the same as the first:

C = p t k
CC > $1$1

This will change a word like akpa to akka; in this case, it is actually equivalent to write CC > C$1

Condition Format

Most of the power of the Toolbox condition format lies in it’s ability to use ad-hoc sets, and regular expressions. The underscore character _ separates the precondition from the postcondition, so that the rule will be applied only when both sides of the condition match.

The / part of the rule can be left out if there is no condition: a > b is equivalent to a > b / _ and both are valid. A rule can have / and _ or neither, but a > b _ and a > b / are both invalid.

Regular Expression metacharacters

  • + matches the previous expression one or more times
  • * matches the previous expression zero or more times
  • ? matches the previous expression zero or one times
  • {} matches any of the list of expressions inside it
  • () used to group expressions
  • !matches anything that is NOT the following expression (NB: not implemented)
  • .matches any character (NB: not implemented)

Sets, delimited by curly braces {}, contain a list of space-separated subexpressions. These can be single characters, variables, or other regular expressions - anything allowed elsewhere in the condition. It’s not clear that this capability is of any real use, but it remains avaible if you happen to find a use for it. Some examples

{ a b c }
{ a b+ }
{ C a }
{ C(a)? x }
{ C{a b} x }

Take some care when writing rules that use ? or *. Because these allow a condition to match zero times, any condition consisting solely of _X? or X*_ will match no matter what. This is because, logically, _X? is equivalent to _X OR _. Further, X?_Y? does not just allow the rule to match both X_ or _Y, but also _, and any rule matching _ will be applied everywhere

Joint Conditions

Another piece of advanced functionality supported by this SCA is the capacity to combine mulitple conditions in one rule using OR. For example, if the same transformation occurs under multiple conditions, they can be joined together:

o e > a / X_ OR _Y % change e and o to a when preceded by X or followed by Y

recommend me conlang blogs!

fluxdeluxe:

so now that I am Definitely For Real This Time gonna spend my winter term conlanging, I need some people to bounce things off 

(yes I’m on CONLANG-L but they scare me)

specifically I am looking for people with knowledge of both music theory and linguistics. if you are such a human please throw yourself in my direction

this is my conlang blog! feel free to throw ideas at me, i love discussing conlangs and i have a BA in linguistics. if you’re looking for a community, you could try conworkshop.info

þrēnoc töla.

anatomy of the head in Semberek

anatomy of the head in Semberek

phonetic transliteration of the irish verse of siúil a rún into keiphyos script.

siúil, siúil, siúil a rúnsiúil go sochar, agus siúil go ciúin.siúil go doras agus éalaigh liomis go dte tú mo mhúirnín slán…

phonetic transliteration of the irish verse of siúil a rún into keiphyos script.

siúil, siúil, siúil a rún
siúil go sochar, agus siúil go ciúin.
siúil go doras agus éalaigh liom
is go dte tú mo mhúirnín slán…

baalimaj iqei lu ljj buqa, piw iqei fukula koihmit lu wei zimik il.

i came out to have a good time, and honestly i’m feeling so attacked right now

dedalvs:

This is a useful tool for conlangers who are looking to craft a lexicon and don’t want to simply relexify their own language.

very useful!