Rupin
A conlang with minimal grammar

Started: Mar., 1999
Last Update: Mar. 15, 1999

This is a very preliminary outline of the grammar of Rupin. A constructed language using the smallest possible grammar.

Rupin, explores a different way to determine what role a particluar word plays in a sentence. The concept of "parts of speech" is done away with. Instead, some words have associated with them certain "links" or "slots" that must be connected or filled before an utterance can be considered complete. Each slot has an assigned function that must be fulfilled by anything that occupies that slot.

Conceptually a word could be classified by the pattern of slots that it has, and each such pattern might be called a "part of speech" and given a unique name like "transitive verb". A given word could then be called a transitive verb if its pattern of slots matched the pattern called "transitive verb". At its root, therefore, Rupin does not actually do away with parts of speech. Instead it does away with the necessity of fitting each word into a class called a part of speech. This frees up words to function in new and "non-standard" ways in a sentence. A newly coined word is not constrained to be of a particular pre-defined part of speech. Instead, it may, by the way its slots are defined, function in a novel way not possible for "standard" parts of speech.

In essence, while Rupin does not actually do away with parts of speech, it does do away with the need to ever talk about parts of speech when discussing, teaching, or learning Rupin. Their existence can be safely ignored.

The complete definition of Rupin consists of the glossary, and seven simple rules of grammar. It's best to just skim the rules and then jump ahead to the examples.

  1. The glossary, in addition to providing the definition of the words, provides a "slot list" for each word.
  2. The slot list shows what slots, if any, must be filled to complete an utterence using that word.
  3. Each slot must be filled with another word and its attendant slot list, until no more slots remain to be filled.
  4. When a word has more than one slot a comma is placed between the filled slots.
  5. If all slots are filled then the utterance so created is a declarative sentence.
  6. If one or more slots are filled with interogatives then the statement is asking the listener to fill in the unfilled slots. This is how questions are formed in Rupin.
  7. If one or more slots are intentionally left empty this is an incomplete statement that implies an invitation to further discussion of the subject.

The above eight rules constitute the complete grammar of Rupin.

Word formation rules

  1. The basic meaning of a word is carried by its root.
  2. The basic meaning of a word can be altered by a prefix. A glossary of prefixes describes how each alters the basic meaning of the word. ( as in "sensitive" -> "insensitive" )
  3. If the same basic word is to be used with two different slot lists then a suffix is appended to one of them so that the two can be distiquished. The basic word then inherits the slot list of the suffix. A glossary of suffixes describes the slot list for each suffix.

Examples

To demonstrate just how simple this all is, we'll go over a few examples. To begin with, lets examine the application of these rules by using English words. The glossary might include these four entries: (Since these are ordinary English words, we won't bother defining them.) 

    ball [ - ball ]
    gives [<what> <to whom> <who> gives]
    John [ - John ]
    Mary [ - Mary ]

Three of these four words have no slots. The remaining word, "gives" has the slot list "[ <what> <to whom> <who> gives ]". This word and its list can also be shown diagramatically: 

                    gives
                      |
            +---------+----------+
            |         |          |
          <what>  <to whom>     <who>

A sentence in Rupin is constructed by replacing each token in the slot list with an actual word: 

    <what> <to whom> <who> gives --> "Ball Mary John gives."

It is also possible to have words which have seperable afixes. For example, we might define the word "gives" in this manner: 

    gives [<what> to <to whom> <who> gives]

Here, the word "to" is taken to be part of the word "gives". This has the advantage of marking certain arguments with keywords to identify their role. The sentence then becomes: 

    <what> to <to whom> <who> gives --> "Ball to Mary John gives."

Now let's examine a more complex example (in English): 

    "Mary was happy that John had finally thrown away that big ugly brown beach ball
      that she hated so much."

Here are the relevant glossary entries: 

    enso...happy [ <why>, enso <who> happy ]
    throw away [ <what did>, <who> throw away ]
    much [ <what> much ]
    hated [ <what was>, <by who> hated ]
    big [ <what> big ]
    brown [ <what> brown ]
    ugly [ <what> ugly ]
    she [ <who>* she ] (*if slot is left empty, assume same slot filler
      as last occurance of "she")
    finally [ <what> finally ]

Notice the entry for the "word" enso...happy. This is a two-word structure that might also be listed as two separate words, where "enso" is a conjunction that joins a cause to an effect. Here is the Rupin diagram of the sentence: 

             happy
               |
       +-------+---enso--------+
       |                       |
     <who>                   <why>
      she                   finally
       |                       |
     <who>                   <what>
     Mary                  Throw Away
                               |
              +----------------+---------+
              |                          |
            <who>                      <what>
            John                        much
                                         |
                                         |
                                       <what>
                                        hated
                                         |
                         +---------------+-------+
                         |                       |
                       <who>                   <what>
                        she                     brown
                         |                       |
                       <who>                   <what>
                        Mary                    ugly
                                                 |
                                               <what>
                                                big
                                                 |
                                               <what>
                                              beach ball

By traversing the tree, deepest node first, we see that this is equivalent to the Rupin sentence: 

    Beach ball big ugly brown, Mary she hated much, John threw away finally, enso she happy.

Notice how he word "she" is given a value for its slot the first time it is mentioned in the sentence, but not the second time. The diagram gives "Mary she" in both cases. The second instance, "she" without "Mary", could be thought of as a pronoun, except that this same mechanism can be used for "value holders" other than pronouns.

... to be continued, revised, expanded, etc., as time allows.

Because Rupin uses Reverse Polish Notation (or RPN, and hence the name "RuPiN") it is ideally suited to be a converstional langauge for communicating with computers. At the present time writing a computer program that can converse fluently in a natural language remains out of reach. Creating a program that can converse in Rupin, however, would be almost trivial.

Comments, suggestions and criticisms are welcome. fiziwig@gmail.com Gary Shannon, 3/15/99