Metadata-Version: 1.1
Name: flowpython
Version: 0.1.1
Summary: Additional Grammar Compatible to CPython
Home-page: https://github.com/thautwarm/flowpython
Author: Thautwarm
Author-email: twshere@outlook.com
License: MIT License
Description: 
        Additional Grammar Compatible to CPython 
        ==========================================
        
        VERSION
        ----------
        flowpy  == 0.1
        
        CPython == 3.6.2
        
        
        Requirement
        ------------
        CPython == 3.6
        
        C/C++ Compiler 
        
        - My version was built on clang-3.8.1/GCC-6.3.0 on linux-deepin
        
        
        Grammar
        ------------
        
        **with quite few new additional keywords here**
        
        * **Where Syntax**
        
            .. code:: python
        
                (test) where:
                    statements
                ...
                # "test" is the top one of expressions in Python Grammar.
        
        - Take a look at here:
            the **where** blocks would be **executed before the expression at the head**, 
            but it should be **located at the end**.
        - Q :Why did I bring "where" syntax into Python?
        - A :For **combining the expressions and statements** in Python and enhanced the readability of procedure. 
        
        - See the following codes:
        
            .. code:: python
        
                # 圆柱面积 / surface area of a cylinder 
                from math import pi
                r = 1  # the radius
                h = 10 # the height
        
                S = (2*S_top + S_side) where:
                    S_top  = pi*r**2
                    S_side = C * h where:
                        C = 2*pi*r
        
        - And where syntax makes it possible for **Lambda** in Python to do everything **def** can do.
        
            .. code:: python
        
                # multi-row lambda in python
            
                lambda x:  someFunc(x) where:
                    def someFunc(var):
                       pass
            
                lambda x:  ret where:
                    def someFunc(var):
                       ...
                    ret = someFunc(x)
            
        However, in Flowpython, there are some other way more interesting supplied to define a "lambda" than "lambda x: f(x)" :
        
        * **Lambda Syntax**
        
            .. code:: python
        
                # Lambda
        
                lambda x,y,z : lambda a,b,c : x*a + y*b + z*c
                # which equals to 
                .x,y,z -> .a,b,c ->  x*a + y*b + z*c
                # which equals to 
                as-with x,y,z def as a,b,c def x*a + y*b + z*c
        
                #look at this example:
            
                as-with x def as y def as z def x+y+z
                # which equals to 
                as-with x def as-with y def as-with z def x+y+z
        
        And we know that there are some powerful tools in some FP languages, like 
        
        * **Pattern matching**
        
            .. code:: python
        
                condic +[<] 1:
                    case a:2   => 
                        assert a == 1 and a < 2
                    +(.x->type(x))
                    case a:int =>
                        assert a == 1 and type(a) == int
                condic 1:
                    +(.x->2*x)
                    case a:3   => 
                        assert a == 1 and a*2 == 3
                    +[is not]
                    case a:2   =>
                        assert a == 1 and a is not 2
                    otherwise  =>
                        ...
                
                # new syntax: matching filter
                condic[] [1,2,3] :
                    +(type) 
                    case (*a,b)->a:list =>
                        assert type(a) == list
                    otherwise           =>
                        assert False,"emmmm"
        
                
        More about Pattern Matching to see `TestFile <https://github.com/thautwarm/flowpython/blob/master/test/test_patm.py>`_
        And `Distribute History <https://github.com/thautwarm/flowpython/blob/master/ReadMe.md#powerful-pattern-matching>`_
        
        Another useful tool in Flowpython is **Arrow Transform**, which enhances the readability greatly and makes it possible 
        to **Avoid Prolix Parentheses**.  
        
        * **Arrow Transform**
            
            .. code:: python
        
                range(100) -> reduce(.x,y->x+y, _) -> print(_) where:
                    from functools import reduce
        
                [1,2,3] -> map(.x->x+1, _) -> list(_) -> print(_)
        
        Read `Arrow Transform  <https://github.com/thautwarm/flowpython/blob/master/ReadMe.md#arrow-transform>`_ to get a konwledge of this grammar.
        
                    
            
        Revision
        ------------
        
        More `Distribution History <https://github.com/thautwarm/flowpython/blob/master/ReadMe.md>`_  here.
        
        - date: 2017-07-28
            * **where**  syntax 
        
            **with-in-with-def** => **with-in-with-break**
        
        - date: 2017-07-29
            * fix **test if else test**
        
            * **where** syntax 
                * **with-in-with-def** => **where - syntax**
        
            * **lambda**
                * add two new methods to define "lambda".
        
        - date: 2017-08-06
            * **switch-case-otherwise**
        - date: 2017-08-07
            * **fix-keyword**
            * **switch-case-otherwise -> condic-case-otherwise**
            * See `fix-keyword-contradictions <https://github.com/thautwarm/flowpython/blob/master/ReadMe.md#fix-keyword-conflictions>`_
        
        - date: 2017-08-09
            * **add-pattern-matching-syntax**
            * See `Powerful Pattern Matching <https://github.com/thautwarm/flowpython/blob/master/ReadMe.md#powerful-pattern-matching>`_
        - date: 2017-08-10
            * **add-arrow-transform(strict form of lambda)**
            * See `Arrow Transform <https://github.com/thautwarm/flowpython/blob/master/ReadMe.md#arrow-transform>`_
            * add a new syntax to pattern matching : `Matching Filter <https://github.com/thautwarm/flowpython/blob/master/ReadMe.md#matching-filter>`_
        
        
        HowToGetFlowPy
        --------------
        
        **For Windows User**
            - You'd better use Visual Studio to make the Python project, and it must be the easiest thing in the world, I think.
            
            - I have tried with **Cygwin** but finally failed. 
        
        **For Linux User**
        
        Firstly, you should have a C/C++ compiler like: 
            
            - https://gcc.gnu.org/
            
            - http://releases.llvm.org/
        
        To give some advice, you can easily get C/C++ compiler with    
            
            - **MinGW/Cygwin** on **windows** (Failed, please have a try with Visual Studio)
        
            - **sudo apt-get install gcc/clang** on **Ubuntu/Debian/Deepin** (maybe it also works for MacOS).
        
        And then you should have a CPython distribution like Python-3.6.2, like:
            
            - https://www.python.org/
        
        And then you should replace the files of the standard CPython distribution with Flowpython.
        
        If you change the variable of **pythonDistPath** in the file **config.py** with  the path of your Python distribution, 
        
        just run this command:
        
        .. code:: shell
        
            ./conf commit -v try_flowPython
        
        Everyting about Flowpython can be found in the directory "/flowpy".
        
        Finally open the CMD/Terminal at the root of CPython distribution,
        
        run the following commands:
            
        .. code:: shell
        
            ./configure CC=<your C/C++ compiler>
            make regen-gramamr
            make regen-ast
            make
            ./python
        
        If you change the variable of **pythonDistPath** in the file **config.py** with  the path of your Python distribution, 
        
        just run this command:
        
        .. code:: shell
        
            ./conf make -m all
            
        And then you can enjoy Flowpython!
        
        
        For Developers
        ---------------
        
        I wrote config.py as the project-manage tool of Flowpython.
        
        It assembled the following modules:
            - make
            - git
            - customer version controler 
            - debug&unittest
        
        It can be used like these way:
        
        .. code:: shell
        
                ./conf commit -v <version_name>
                ./conf recover 
                ./conf test 
                ./conf make -m clean
                ./conf make -m ast
                ...
        
        It seems to be kind of complicated but it's quite easy to understand and operate in fact.
        
        
        
        
        
        
        
        
        
        
        
        
        
Keywords: gramamr,ast,readability
Platform: windows
Platform: linux
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: Implementation :: CPython
