Metadata-Version: 1.1
Name: phi
Version: 0.2.1
Summary: Phi is a library for fluent functional programming in Python which includes a DSL + facilities to create libraries that integrate with it.
Home-page: https://github.com/cgarciae/phi
Author: Cristian Garcia
Author-email: cgarcia.e88@gmail.com
License: MIT
Download-URL: https://github.com/cgarciae/phi/tarball/0.2.1
Description: # Phi
        Python is a very nice language that favors readability but its not very strong at functional programming and this often leads to repetitive code. Phi eases your functional programming experience in Python by providing the following modules
        
        * [dsl](https://cgarciae.github.io/phi/dsl.m.html): a neat way to compose computations + more.
        * [lambdas](https://cgarciae.github.io/phi/lambdas.m.html): easy way to create quick lambdas with a mathematical flavor.
        * [builder](https://cgarciae.github.io/phi/builder.m.html): an extensible class that enables you to integrate other libraries into the DSL through a [fluent](https://en.wikipedia.org/wiki/Fluent_interface) API.
        * [patch](https://cgarciae.github.io/phi/patch.m.html): this module contains some helpers that enable you to integrate a complete existing module or class into the DSL be registering its methods/functions into a [Builder](https://cgarciae.github.io/phi/builder.m.html#phi.builder.Builder).
        
        ## Documentation
        Check out the [complete documentation](https://cgarciae.github.io/phi/index.m.html).
        
        ## Installation
        
            pip install phi==0.2.1
        
        
        #### Bleeding Edge
        
            pip install git+https://github.com/cgarciae/phi.git@develop
        
        ## Status
        * Version: **0.2.1**.
        * Current effort: Documentation (> 60%). Please create an issue if documentation is unclear, its of great priority for this library.
        * Milestone: reach 1.0.0 after docs completed + feedback from the community.
        
        
        ## Getting Started
        The global `phi.P` object exposes most of the API and preferably should be imported directly. The most simple thing the DSL does is function composition:
        
            
            from phi import P
            
            f = P.Make(
              lambda x: x + 1,
              lambda x: x * 2,
              lambda x: x + 3
            )
            
            assert 11 == f(3)
        
        
        The above computation is equivalent to
        
            
            lambda x: (x + 1) * 2 + 3
        
        
        `P.Make` can compile any valid expression of the DSL into a function, what you are seeing here is the compilation of the `*args` tuple. Check out the documentation of the [dsl](https://cgarciae.github.io/phi/dsl.m.html).
        
        Now lets rewrite the previous using `P`'s [lambdas](https://cgarciae.github.io/phi/lambdas.m.html) capabilities
        
            
            from phi import P
            
            f = P.Make(
              P + 1,
              P * 2,
              P + 3
            )
            
            assert 11 == f(3)
        
        
        **Pipe**
        
        You can also pipe a value directly into an expression with `P.Pipe`
        
            
            from phi import P
            
            assert 11 == P.Pipe(
              3,
              P + 1,
              P * 2,
              P + 3
            )
        
        
        ### Branching
        Sometimes we have do separate computations, this is where branching comes in. It is expressed via a list (iterable in general) where each element is a different computational path and a list is returned by the Branch element:
        
            
            import phi import P
            
            assert [0, 4] == P.Pipe(
              1,
              P + 1,
              [
                P * 2
              ,
                P - 2
              ]
            )
        
        
        The above computation equivalent to
        
            
            lambda x: [(x + 1) * 2, (x + 1) - 2]
        
        
        As you the the `[...]` element is compiled to a function that returns a list of values. Check out the documentation of the [dsl](https://cgarciae.github.io/phi/dsl.m.html) for more information.
        
        ## Nice Examples
        
            
            from phi import P, Obj
            
            text = "1 22 33"
            
            avg_word_length = P.Pipe(
                text,
                Obj.split(" "), # ['1', '22', '333']
                P.map(len), # [1, 2, 3]
                P.sum() / P.len() # sum([1,2,3]) / len([1,2,3]) == 6 / 3 == 2
            )
            
            assert 2 == avg_word_length
        
        
Keywords: functional programming,DSL
Platform: UNKNOWN
