Are there any programming languages that make use of adjectives?

Question

Are there any languages where something like the following might be possible?

people = [ ... a list of people ...]
Person jake = Person("Jake", 165, ...)
jake is Tall
people.add(jake)
for Person person in people where Tall:
    // ... do something terrible to them
jake is not Tall // ... Jake no longer wishes to be tall

I hope that makes sense - basically, dynamic adjectives that affect something about an object's properties or methods.

Answer 1

Adjectives are really just attribute evaluation. Here's how I might handle it in JavaScript.

function PersonAdjectiveConstructor(person) {
    this.isTall = (person.height >= 6);
    this.isRich = (person.pocketMoney >= 1000000);
    this.isSmart = (person.iq > person.shoeSize);
    this.isInsufferable = ( this.tall && this.rich && this.smart );
    //formerly (for comment context):
    //this.isInsufferable = ( this.smart && this.rich && this.smart );
}

function PersonConstructor(personAttributes){

    for(var x in personAttributes){
        this[x] = personAttributes[x];
    }    

    var adjectives = new PersonAdjectiveConstructor(this);

    for(var x in adjectives){
        this[x] = adjectives[x];
    }
}

var bob = new PersonConstructor({ shoeSize:11, iq:12, height:6.25, pocketMoney:2000000 });

console.log(bob.isInsufferable);//true

Answer 2

Prolog and other logic programming languages do this. They have identifiers with lists of characteristics which are then queried to do computation. Inferences about relationships can also be made.

This example from Wikipedia shows how:

mother_child(trude, sally).

father_child(tom, sally).
father_child(tom, erica).
father_child(mike, tom).

sibling(X, Y)      :- parent_child(Z, X), parent_child(Z, Y).

parent_child(X, Y) :- father_child(X, Y).
parent_child(X, Y) :- mother_child(X, Y).

So you've described some family relations here. You can then ask Prolog a question about them:

?- sibling(sally, erica).
Yes

Answer 3

Inform 7 is a natural-language programming language, heavily geared towards writing interactive fiction.

It has a rich variety of ways to express and use adjectives:

• Simple two-state attributes: "John is sunburnt."
  • Inform will automatically understand the opposite of this to be "not sunburnt". You can specify both labels though: "A person can be tall or short. John is tall."
• Enumerations (what Inform calls "kinds of value"): "Colour is a kind of value. The colours are red, green and blue. The box has a colour. The box is blue."
• Rule-based definitions for computing whether an adjective applies: "Definition: a thing is heavy if its weight is greater than 10kg." Alternatively: "Definition: a thing is heavy rather than light if its weight is greater than 10kg."

Having defined these adjectives, there are many ways to use them, and they're understood both by the compiler and by the runtime parser accepting user input. Some simple examples:

• Assign them to objects: "Now the box is red."
• Test for their presence: "If the person is short..."
• Discriminate between objects to which the same adjective could apply: "If the heaviest box is red..."

With apologies to the writers of Inform documentation for any examples I might unwittingly have borrowed. I imagine things like weight and colour crop up often :P

Answer 4

Applescript seems to be a good candidate.

Here are some examples, excerpt from AppleScript: Beginner's Tutorial:

tell application "Finder" to open the startup disk

tell application "Finder" to set the current view of the second Finder window to flow view

tell application "QuickTime Player" to set the current time of the front document to 94900

Answer 5

Your "adjectives" are basically just boolean attributes, which pretty much every programming language has, and your filter operatio is, well, a filter operation which any halfway decent collection framework has.

For example, in Ruby:

class Object
  def is(*attrs)
    attrs.each do |attr| define_singleton_method(:"#{attr}?") do true end end
  end

  def isnt(*attrs)
    attrs.each do |attr| define_singleton_method(:"#{attr}?") do nil end end
  end
end

Person = Struct.new(:name)

jake = Person.new('Jake')
bill = Person.new('Bill')

jake.is(:tall, :mean)
bill.isnt(:tall)
bill.is(:mean)

people = [jake, bill]

people.select(&:tall?)
# => [#<struct Person name="Jake">]

people.select(&:mean?)
# => [#<struct Person name="Jake">, #<struct Person name="Bill">]

jake.isnt(:mean)

people.select(&:mean?)
# => [#<struct Person name="Bill">]

Maybe if you describe the actual problem you are having, you will get better answers, but for now, standard collection operations and a simple boolean attribute are plenty enough; there doesn't seem to be anything that requires sophisticated inference, backtracking, unification or anything like that.

Answer 6

Ok ruby answer:

module Traity
  def initialize
    @traits = {}
  end
  def method_missing trait
    @traits[trait]
  end
  def give_trait trait
      @traits[trait] = true
  end
  def take_trait trait
      @traits[trait] = false
   end
end

class Tom
   include Traity
end

 t = Tom.new
 t.give_trait :tall
 puts t.tall
 t.take_trait :tall
 puts t.tall

Answer 7

I think that you could view modifiers on declarations as adjectives.

For instance:

    static int foo;

says "We declare foo to be a static int". The word static an adjective, both in the Java context and in the English language.

---

Another example is Java annotations.

Note that since annotations can be user-defined, you have user-defined adjectives.

---

Java is a statically compiled language so it doesn't have dynamic adjectives in the broadest sense. However, you could generalize this "analysis" to any (dynamic) language with these language features.

I'm not convinced it is particularly useful though. The mere possibility of adjectival constructs is not sufficient. You also need significant (application specific) support to make the constructs do something useful. (For instance, in Java you need either application specific annotation processors or reflective code in the application to examine annotations at runtime.)

Answer 8

Firstly, that looks like Python.

Secondly, things like Tall aren't necessarily reflexive. Lets assume as a part of our syntax:

• is can be an infix operator that and sets an object attribute, eg. Jake is Tall makes Jake.Tall True
• is can be a prefix operator that queris the precence of an attribute.
• Being over 185cm is tall

So lets begin:

Jake <= Person(name="Jake")
Jake is Tall
print(is Jake Tall)
>>> True

All is well, but this introduces problems.

print(Jake.height)

We know Jake is tall, but how tall is he?

Even again:

Jake <= Person(name="Jake",height=199)
Jake is Tall
print(is Jake Tall)

What do we print here? Now, we've said Jake is less than 200cm, so he isn't Tall, but he've also explicitly stated that he is tall. We can start to introduce logic so that when we call Tall against a person we check the Tall state or the height attribute, but the logic incongruencies are difficult.

What you can do is similar to what Python does with its is statement, and use it to check a state, rather than set it.

So we could go:

Jake <= Person(name="Jake",height=199)
if Jake is Tall {
    print("How is the weather up there?")
} else {
    print("Need a ladder?")
}
>>> Need a ladder?

This syntax could then just be a shorthand of Jake.isTall or any number of attribute checkers.

Answer 9

From some of your comments, I think Scala's Traits are a good candidate. They are basically interfaces which can contain implemented methods and can be used in lots of nice ways.

For example having a trait and a class:

trait Foo {
  def bar = println("I'm a thing that's Foo, which means I can Bar")
}
class Doodle {}

Will let you execute a series of statements:

var foodoodle = new Doodle with Foo
foodoodle.bar

Which executes bar, printing "I'm a thing that's Foo, which means I can Bar".

This kind of addresses your comment about a "Winged" property giving an object a fly() method.