Qualsiasi lingua in cui ogni istanza di classe è anche una classe?

Question

Qualsiasi lingua in cui ogni istanza di classe è anche una classe?

#1 da (5 voti)
#2 da (0 voti)
#3 da (0 voti)

1

Prendendo spunto dai prototipi Javascript, ho avuto l'idea di un linguaggio in cui ogni istanza può essere utilizzata come classe.

Prima di reinventare potenzialmente la ruota, vorrei chiedere se esiste già un linguaggio che usa questo concetto:

//To declare a Class, extend the base class (in this case, Type)
Type(Weapon,{price:0});

//Same syntax to inherit; simply extend the parent:
Weapon(Sword,{price:3});
Weapon(Axe,{price:4});

Sword(Katana,{price:7});
Sword(Dagger,{price:3});

//And the same to create an instance:
Katana(myKatana,{nickname:"Leon"});
myKatana.price; // 7
myKatana.nickname; // Leon

// An operator to return children of a class;
Sword_; // [Katana, Dagger]

// An operator to return array of descendants;
Sword__; // [Katana, Dagger, myKatana]

// An operator to return array of parents;
Sword^; // Weapon

// Arrays can be used as elements
Sword__.price += 1; //increases price of Sword's descendants by 1
mySword.price; //8

// And to access specific element (using its name instead of index)
var name = "mySword"
Katana_[name]; // [mySword]
Katana_[name].nickname; // Leon

Questo tipo di approccio è già stato studiato / implementato?

object-oriented programming-languages class

posta Dokkat 20.03.2012 - 23:23

fonte

3 risposte

Leggi altre domande sui tag object-oriented programming-languages class

Quale struttura di raccolta dovrei usare per il raggruppamento parametrico ordinando in c #? Standard web nascosti dietro Google "custom searchEngines"?

score 5 · Answer 1

JavaScript può già farlo senza lo zucchero della sintassi.

Esempio dal vivo

Nota che la sintassi è significativamente più brutta. Dovrebbe essere possibile scrivere un DSL su JavaScript che utilizza la sintassi

//To declare a Class, extend the base class (in this case, Type)
var Weapon = create(Object.prototype, { 
    price: 0,
    name: "Weapon"
})

//Same syntax to inherit; simply extend the parent:
var Sword = create(Weapon, { 
    price: 3,
    name: "Sword"
})
var Axe = create(Weapon, { 
    price: 4,
    name: "Axe"
})

var Katana = create(Sword, { 
    price: 7,
    name: "Katana"
})
var Dagger = create(Sword, { 
    price: 3,
    name: "Dagger"
})

//And the same to create an instance:
var myKatana = create(Katana, { 
    nickname: "Leon",
    name: "myKatana"
})
console.log(myKatana.price) // 7
console.log(myKatana.nickname) // Leon

// An operator to return children of a class;
console.log(children(Sword)) // [Katana, Dagger]

// An operator to return array of descendants;
console.log(descendants(Sword)) // [Katana, Dagger, myKatana]

// An operator to return array of parents;
console.log(Object.getPrototypeOf(Sword)); // Weapon

// Arrays can be used as elements
descendants(Sword).forEach(function (proto) {
    if (proto.hasOwnProperty("price")) proto.price += 1
})
console.log(myKatana.price) //8

// And to access specific element (using its name instead of index)
var name = "myKatana"
console.log(children(Katana)[name]) // [mySword]
console.log(children(Katana)[name].nickname) // Leon

function create(proto, props) {
    Object.keys(props).forEach(function (key) {
        props[key] = { 
            value: props[key],
            writable: true,
            configurable: true,
            enumerable: true
        }
    })
    var instance = Object.create(proto, props)
    if (!proto.hasOwnProperty("__children__")) {
        proto.__children__ = []
    }
    proto.__children__.push(instance)
    proto.__children__[props.name.value] = instance
    return instance
}

function children(proto) {
    return proto.__children__
}

function descendants(proto) {
    return proto.__children__.reduce(function (memo, value) {
        memo.push(value)
        if (value.hasOwnProperty("__children__")) {
            memo = memo.concat(descendants(value))
        }
        return memo
    }, [])
}

score 0 · Answer 2

Beh, non ho visto un linguaggio esattamente come il tuo, ma l'ereditarietà del prototipo esiste in JavaScript, per esempio. Che mi sembra di soddisfare la tua "ogni istanza di classe è anche una classe". A meno che i tuoi requisiti siano più specifici di quello.

score 0 · Answer 3

Non sono sicuro al 100% che sia una corrispondenza esatta per la tua descrizione, ma in base ai tuoi esempi questo sembra abbastanza vicino alla lingua io .

Più specificamente, poiché crei sempre nuove "sottoclassi" in io clonando un oggetto esistente, puoi sempre trattare ogni "sottoclasse" come un tipo distinto su cui basare le istanze.

Per ulteriori informazioni, si spera che chiariscano, questa sezione dei documenti è probabilmente la più rilevante:

link