Esistono linguaggi di programmazione che fanno uso di aggettivi?

Gli aggettivi sono in realtà solo una valutazione degli attributi. Ecco come potrei gestirlo 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

Prolog e altri linguaggi di programmazione logica fanno questo. Hanno identificatori con liste di caratteristiche che vengono poi interrogate per fare calcoli. Si possono anche fare delle inferenze sulle relazioni.

Questo esempio di Wikipedia mostra come:

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).

Quindi hai descritto alcune relazioni familiari qui. Puoi quindi chiedere a Prolog una domanda su di loro:

?- sibling(sally, erica).
Yes

Inform 7 è un linguaggio di programmazione in linguaggio naturale, strongmente orientato alla scrittura di narrativa interattiva.

Ha una grande varietà di modi per esprimere e usare gli aggettivi:

• Attributi a due stati semplici: "John è bruciato dal sole".
  • Inform saprà automaticamente che l'opposto di questo è "non bruciato dal sole". Puoi tuttavia specificare entrambe le etichette: "Una persona può essere alta o bassa. John è alto."
• Enumerazioni (ciò che Inform chiama "tipi di valore"): "Il colore è un tipo di valore.I colori sono il rosso, il verde e il blu.La scatola ha un colore.La scatola è blu."
• Definizioni basate su regole per calcolare se si applica un aggettivo: "Definizione: una cosa è pesante se il suo peso è maggiore di 10 kg." In alternativa: "Definizione: una cosa è piuttosto pesante di luce se il suo peso è superiore a 10 kg. "

Avendo definito questi aggettivi, ci sono molti modi per usarli e sono compresi sia dal compilatore che dal parser di runtime che accetta l'input dell'utente. Alcuni semplici esempi:

• Assegna loro gli oggetti: "Ora la casella è rossa."
• Verifica la loro presenza: "Se la persona è corta ..."
• Discriminare tra gli oggetti a cui potrebbe essere applicato lo stesso aggettivo: "Se la casella più pesante è rossa ..."

Con le scuse agli autori della documentazione di Inform per ogni esempio che potrei aver preso in prestito inconsapevolmente. Immagino cose come peso e colore che spuntano spesso: P

Applescript sembra essere un buon candidato.

Ecco alcuni esempi, estratti da 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

I tuoi "aggettivi" sono fondamentalmente solo attributi booleani, che praticamente ogni linguaggio di programmazione ha, e il tuo operatio di filtro è, beh, un'operazione di filtro che ha qualsiasi framework di raccolta decente.

Ad esempio, 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">]

Forse se descrivi il problema attuale che stai avendo, otterrai risposte migliori, ma per ora le operazioni di raccolta standard e un semplice attributo booleano sono sufficienti; non sembra che ci sia qualcosa che richiede inferenza sofisticata, backtracking, unificazione o qualcosa del genere.

Risposta ruby ok:

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

In primo luogo, sembra Python.

In secondo luogo, cose come Tall non sono necessariamente riflessive. Assumiamo come parte della nostra sintassi:

• is può essere un operatore infisso che imposta un attributo oggetto, ad es. Jake is Tall rende Jake.Tall True
• is può essere un operatore di prefisso che verifica la precisione di un attributo.
• Essere sopra i 185 cm è alto

Quindi iniziamo:

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

Tutto va bene, ma questo introduce problemi.

print(Jake.height)

Sappiamo che Jake è alto, ma quanto è alto?

Ancora una volta:

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

Che cosa stampiamo qui? Ora, abbiamo detto che Jake è inferiore a 200 cm, quindi non è alto, ma ha anche dichiarato esplicitamente di essere alto. Possiamo iniziare a introdurre la logica in modo che quando chiamiamo Tall contro una persona controlliamo lo stato Tall o l'attributo height , ma le incongruenze logiche sono difficili.

Quello che puoi fare è simile a ciò che Python fa con la sua dichiarazione is , e usarlo per controllare uno stato, piuttosto che impostarlo.

Quindi potremmo andare:

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?

Questa sintassi potrebbe quindi essere solo una scorciatoia di Jake.isTall o qualsiasi numero di correttori di attributi.

Da alcuni dei tuoi commenti, penso che i Tratti di Scala siano un buon candidato. Sono fondamentalmente interfacce che possono contenere metodi implementati e possono essere utilizzate in molti modi carini.

Ad esempio avere un tratto e una classe:

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

Ti consente di eseguire una serie di istruzioni:

var foodoodle = new Doodle with Foo
foodoodle.bar

Che esegue la barra, stampando "Sono una cosa che è Foo, il che significa che posso Bar".

Questo tipo di indirizzo il tuo commento su una proprietà "Winged" che fornisce un oggetto a un metodo fly ().

Penso che potresti visualizzare i modificatori sulle dichiarazioni come aggettivi.

Ad esempio:

    static int foo;

dice "Dichiariamo foo come static int ". La parola static un aggettivo, sia nel contesto Java che nella lingua inglese.

Un altro esempio sono le annotazioni Java.

Da notare che poiché le annotazioni possono essere definite dall'utente, hai degli aggettivi definiti dall'utente.

Java è un linguaggio compilato staticamente, quindi non ha aggettivi dinamici nel senso più ampio. Tuttavia, è possibile generalizzare questa "analisi" a qualsiasi lingua (dinamica) con queste funzionalità linguistiche.

Non sono convinto che sia particolarmente utile però. La semplice possibilità di costrutti aggettivali non è sufficiente. È inoltre necessario un supporto significativo (specifico per le applicazioni) per fare in modo che i costrutti facciano qualcosa utile . (Ad esempio, in Java sono necessari processori di annotazione specifici dell'applicazione o codice riflettente nell'applicazione per esaminare le annotazioni in fase di esecuzione.)