Giter Club home page Giter Club logo

heterarchy's Introduction

heterarchy

Cooperative multiple inheritance for CoffeeScript, à-la Python.

Adds multiple inheritance support to CoffeeScript (and JavaScript). It uses the C3 linearization algorithm as described in the famous Dylan paper.

Example

The library handles multiple inheritance and chains calls to super in a linear order, solving the diamond problem and allowing for cooperative methods. For example, the following class heterarchy:

Can be implemented with the following code.

{multi} = require 'heterarchy'

class A
    method: -> "A"

class B extends A
    method: -> "B > #{super}"

class C extends A
    method: -> "C > #{super}"

class D extends multi B, C
    method: -> "D > #{super}"

Calling method on a D instance would return the string D > B > C > A showing the class linearization.

Documentation

API

Tests

Installation

This is a standard Node.JS module. One may install the library with:

npm install heterarchy

Usage in the browser

After cloning or downloading the repository you can build all necessary files with

make

This will create heterarchy.js in the lib/ folder. Including that file in the browser will result in a global heterarchy variable that contains the normally exported functions.

Since the library requires underscorejs you must include it before heterarchy. The functions that are used from underscorejs are (in case you don't need the entire library):

head, tail, map, find, some, without, isEmpty,
every, memoize, reject, isEqual, reduce

Example

<script type="text/javascript" src="path/to/underscore.js"></script>
<script type="text/javascript" src="path/to/browser.heterarchy.js"></script>
<script type="text/javascript" src="my_app.coffee"></script>

where my_app.coffee could be

class A
    method: -> "A"

class B extends A
    method: -> "B > #{super}"

class C extends A
    method: -> "C > #{super}"

# note the heterarchy namespace
class D extends heterarchy.multi B, C
    method: -> "D > #{super}"

Contributors

This library is maintained by Juanpe Bolivar, with the help of these outstanding contributors:

  • Jim Neuedorf @jneuendorf

    Added support for class methods, global exports in the browser and fixed various issues.

License

Heterarchy is Free Software and is distributed under the MIT license (see LICENSE).

Copyright (c) 2013, 2015 Juan Pedro Bolivar Puente [email protected]

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

heterarchy's People

Contributors

arximboldi avatar jneuendorf avatar vendethiel avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar

heterarchy's Issues

class method inheritance bug

Hi,

apparently the tests I wrote for the class method inheritance (using super) are not sufficient.
Here is an example where the instance methods work correctly but the class methods do not:

class Widget
    @getDefaultProperties: () ->
        console.log "Widget"
        return {}
    getDefaultProperties: () ->
        console.log "Widget"
        return {}

class MoveableWidget extends Widget
class ResizeableWidget extends Widget
class MoveableResizableWidget extends heterarchy.multi MoveableWidget, ResizeableWidget

class ConfigurableWidget extends Widget
class HideableWidget extends ConfigurableWidget
    @getDefaultProperties: () ->
        console.log "HideableWidget"
        props = super()
        props.hidden = false
        return props
    getDefaultProperties: () ->
        console.log "HideableWidget"
        props = super()
        props.hidden = false
        return props

class TextWidget extends heterarchy.multi MoveableResizableWidget, HideableWidget
    @getDefaultProperties: () ->
        console.log "TextWidget"
        props = super()
        props.text = ""
        return props
    getDefaultProperties: () ->
        console.log "TextWidget"
        props = super()
        props.text = ""
        return props

console.log (new TextWidget).getDefaultProperties() # {"hidden":false,"text":""}
console.log TextWidget.getDefaultProperties() # {"text":""}

inheritance of properties not correct

Hi,

when enumerable properties are defined on a class's prototype they are not correctly inherited.
The problem is the generate function.
In case of data descriptors no errors occur but the descriptor be dropped (since only the value will be copied).
In case of accessor descriptors errors can occurs (for example if the getter calls something on this) because

for own key, val of obj
  ...

is compiled to

for (key in obj) {
  if (!hasProp.call(obj, key)) continue;
  val = obj[key];
  ...
}

and val = obj[key] will trigger the getter to be evaluated with the prototype as context instead of the instance.

Object.getOwnPropertyDescriptor(obj, propName) can be used to determine if an attribute is a defined property or not.
This should be used in both loops - maybe like this:

for own key of next
  descriptor = Object.getOwnPropertyDescriptor(next, key)
  if not descriptor?
    value = next[key]
    @[key] = reparent next, @, value
  else
    # I don't know if this really does it
    Object.defineProperty @, key, descriptor

I am not quite sure if Object.defineProperty @, key, descriptor does the job.
However, if the descriptor contains get: () -> this.something or get: () -> this.doSomething() (or a setter) the function body is evaluated when property is accessed so I think everything is fine because at that time heterarchy should have taken care of everything, right?

I guess properties on the class itself behave similarly.

See https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor

documentation is wrong

The example given in your documentation is wrong.

{multi} = require 'heterarchy'

class A
    method: -> "A"

class B extends A
    method: -> "B > #{super}"

class C extends A
    method: -> "C > #{super}"

class D extends multi B, C
    method: -> "D > #{super}"

Calling method on a D instance does not return the string D > C > B > A.
Instead it returns D > B > C > A.

introspection: base classes

As of now, it is impossible to find the base class(es) of a subclass. The existing introspection functions mro, inherited and hierarchy cannot be used for task (if I am right).
In another project of mine I need this feature for generating a UML class diagram.

It would be nice to have a __bases__ attribute at least on those classes classes that extend multi(...).

The bases only get passed into the multi function so I guess the bases must be attached there are passed along.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.