Metadata-Version: 1.1
Name: mio-lang
Version: 0.0.4
Summary: A Toy Programming Language written in Python
Home-page: http://bitbucket.org/prologic/mio-lang/
Author: James Mills
Author-email: James Mills, prologic at shortcircuit dot net dot au
License: MIT
Download-URL: http://bitbucket.org/prologic/mio-lang/downloads/
Description: .. _Python Programming Language: http://www.python.org/
        .. _How To Create Your Own Freaking Awesome Programming Language: http://createyourproglang.com/
        .. _Marc-Andre Cournoye: http://macournoyer.com/
        .. _PyPi Page: http://pypi.python.org/pypi/mio-lang
        .. _Project Website: https://bitbucket.org/prologic/mio-lang/
        .. _Downloads Page: https://bitbucket.org/prologic/mio-lang/downloads
        
        
        mio is a minimalistic IO programming language written in the
        `Python Programming Language`_ based on MIo (*a port from Ruby to Python*)
        in the book `How To Create Your Own Freaking Awesome Programming Language`_ by
        `Marc-Andre Cournoye`_.
        
        This project is being developed for educational purposes only and should serve as
        a teaching tool for others wanting to learn how to implement your own programming
        language (*albeit in the style of Smalltalk, Io, etc*). Many thanks go to `Marc-Andre Cournoye`_
        and his wonderful book which was a great refresher and overview of the overall processing
        and techniques involved in programming language design and implementation. Thanks also go to the
        guys in the ``#io`` channel on the FreeNode IRC Network specifically **jer** nad **locks**
        for their many valuable tips and help.
        
        The overall goal for this project is to create a fully useable and working programming language
        implementation of a langauge quite similar to `Io <http://iolanguage.com>`_ with heavy influence
        from `Python <http://python.org>`_ (*because Python is awesome!*). This has already largely been
        achived in the current version. See the `RoadMap <http://mio-lang.readthedocs.org/en/latest/roadmap.html>`_
        for what might be coming up next.
        
        
        Examples
        --------
        
        Factorial::
            
            Number fact = method(
                (self < 2) ifTrue(return self)
                return (self * ((self - 1) fact()))
            ))
        
        Hello World::
            
            print("Hello World!")
            
        
        Features
        --------
        
        - Homoiconic
        - Message Passing
        - Higher Order Messages
        - Higher Order Functions
        - Full support for Traits
        - Object Orienated Language
        - Written in an easy to understand language
        - Supports Imperative, Functional, Object Oriented and Behavior Driven Development styles.
        
        
        Installation
        ------------
        
        The simplest and recommended way to install mio is with pip.
        You may install the latest stable release from PyPI with pip::
        
            > pip install mio-lang
        
        If you do not have pip, you may use easy_install::
        
            > easy_install mio-lang
        
        Alternatively, you may download the source package from the
        `PyPI Page`_ or the `Downloads page`_ on the `Project Website`_;
        extract it and install using::
        
            > python setup.py install
        
        You can also install the
        `latest-development version <https://bitbucket.org/prologic/mio-lang/get/tip.tar.gz#egg=mio-lang>`_ by using ``pip`` or ``easy_install``::
            
            > pip install mio-lang==dev
        
        or::
            
            > easy_install mio-lang==dev
        
        
        For further information see the `mio documentation <http://mio-lag.readthedocs.org/>`_.
        
        
        Changes
        -------
        
        
        mio 0.0.4
        .........
        
        - Moved the implementation of ``super`` to the mio std. lib
        - Only set ``_`` as the last result in the Root object (*the Lobby*)
        - Added support for ``()``, ``[]`` and ``{}`` special messages that can be used to define syntactic suguar for lists, dicts, etc.
        - Implemented ``Dict`` object type and ``{a=1, b=2}`` syntactic sugar to the builtint (*mio std. lib*) ``dict()`` method.
        - Refactored the ``File`` object implementation and made it's repr more consistent with other objects in mio.
        - Fixed keyword argument support.
        - Fixed a few minor bugs in the ``Message`` object and improved test coverage.
        - Added ``?`` as a valid operator and an implementation of ``Object ?message`` in the mio std. lib.
        - Fixed a bug with ``Range``'s internal iterator causing ``Range asList`` not to work.
        - Fixed a bug with ``Object foreach`` and ``continue``.
        - **Achived 100% test coverage!**
        - Implemented ``*args`` and ``**kwargs`` support for methods and blocks.
        - Removed ``Object`` methods ``print``, ``println``, ``write`` and ``writeln`` in favor of the new builtin ``print`` function in the mio std. lib
        - Added an implemenation of ``map`` to the mio std. lib
        - Fixed a bug with the parser where an argument's previous attribute was not getting set correctly.
        - Reimplemented ``not`` in the mio std. lib and added ``-=``, ``*=`` and ``/=`` operators.
        - Added a ``Object :foo`` (*primitive*) method using the ``:`` operator. This allows us to dig into the host object's internal methods.
        - Added an implementation of ``abs`` builtin using the primitive method.
        - Changed the ``import`` function to return the imported module (*instead of ``None``*) so you can bind imported modules to explicitly bound names.
        - Added ``from`` an alias to ``import`` and ``Module import`` so you can do:
        
        ::
            
            bar = from(foo) import(bar)
            
        - Fixed some minor bugs in ``Object foreach`` and ``Object while`` where a ReturnState was not passed up to the callee.
        - Added implementations of ``all`` and ``any`` to the mio std. lib.
        - Added this.mio (The Zen of mio ala Zen of Python)
        - Added List insert method and internal __len__.
        - Moved the implementations of the ``Importer`` and ``Module`` objects to the host language (*Python*).
        - Added support for modifying the ``Importer`` search path.
        - Restructured the mio std. library and moved all bootstrap modules into ./lib/bootstrap
        - Added (almost) Python-style string literal support. Triple Quote, Double, Quote, Single Quote, Short and Long Strings
        - Added support for exponents with number literals.
        - Added internal ``tomio`` and ``frommio`` type converion function.
        - Added an ``FFI`` implementation that hooks directly into the host language (*Python*).
        - Implemented the ``antigravity`` module in mio.
        - Added support for exposing builtin functions as well in the FFI.
        - Simplified the two examples used in the docs and readme and write a simple bash script to profile the factorial example.
        - Changed the calling semantics so that calls to methods/blocks are explicitly made with ``()``.
        - Added a new internal attribute to ``Object`` called ``binding`` used to show the binding of a bound object in repr(s).
        
        
        mio 0.0.3 (*2013-10-20*)
        ........................
        
        - Improved test coverage
        - Improved the ``Range`` object
        - Fixed the scoping of ``block`` (s).
        - Fixed the ``write`` and ``writeln`` methods of ``Object`` to not join arguments by a single space.
        - Don't display ``None`` results in the REPL.
        - Improved the ``__repr__`` of the ``File`` object.
        - Added ``open`` and ``with`` builtins to the mio standard library.
        - Implemented a basic import system in the mio standard library.
        - Implemented ``Dict items`` method.
        
        
        mio 0.0.2 (*2013-10-19*)
        ........................
        
        - Include lib as package data
        - Allow mio modules to be loaded from anywhere so mio can be more usefully run from anywhere
        - Added bool type converion
        - Improved the documentation and added docs for the grammar
        - Changed Lobby object to be called Root
        - Added an -S option (don't load system libraries).
        - Added unit test around testing for last value with return
        - Refactored Message.eval to be non-recursive
        - Set _ in the context as the last valeu
        - Implemented Blocks and Methods
        - Fixed return/state issue by implementing Object evalArg and Object evalArgAndReturnSelf in Python (not sure why this doesn't work in mio itself)
        - Implemented Object evalArgAndReturnNone
        
        
        mio 0.0.1 (*2013-10-19*)
        ........................
        
        - Initial Release
        
Keywords: toy programming language io mio message
Platform: POSIX
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Natural Language :: English
Classifier: Operating System :: MacOS :: MacOS X
Classifier: Operating System :: POSIX :: Linux
Classifier: Programming Language :: Python :: 2.7
Classifier: Topic :: Software Development :: Assemblers
Classifier: Topic :: Software Development :: Code Generators
Classifier: Topic :: Software Development :: Compilers
Classifier: Topic :: Software Development :: Debuggers
Classifier: Topic :: Software Development :: Interpreters
