Metadata-Version: 2.1
Name: tx-functional
Version: 0.1.2
Summary: A pickleable generic functional programming library
Home-page: https://github.com/RENCI/tx-functional
Author: Hao Xu
Author-email: xuhao@renci.org
License: MIT
Description: [![Build Status](https://travis-ci.com/RENCI/tx-functional.svg?branch=master)](https://travis-ci.com/RENCI/tx-functional)
        
        # tx-functional
        Generic functional programming library for Python
        
        The goal of this is
         * Close to Haskell.
         * Work with mypy
         * Pickleable
        
        We choose functions in uncurried form because mypy doesn't support type variable that only appear in return type of a function signature.
        
        ## classes
        
        ### Functor
        
        The `Functor` class is defined in `tx.functional.functor`.
        It takes in a `_map` argument. A functor `F` is a higer-kinded type `* -> *`. 
        A functor is defined by a `map` function
        ```
        map: (S -> T, F[S]) -> F[T]
        ```
        
        ### Applicative
        
        The `Applicative` class is defined in `tx.functional.applicative`.
        It takes in `_map`, `_pure`, and `_ap`. An applicative `F` is a functor.
        An applicative is defined by additional `pure` and `ap` functions
        ```
        pure: S -> F[S]
        ap: (F[S -> T], F[S]) -> F[T]
        ```
        
        ### Monad
        
        The `Monad` class is defined in `tx.functional.monad`.
        It takes in `_pure` and `_bind`. A monad `F` is an applicative and a functor.
        A monad is defined by an additional `bind` function
        ```
        bind: (F[S], S -> F[T]) -> F[T]
        ```
        
        ### Traversable
        
        The `Traversable` class is defined in `tx.functional.traversable`.
        It takes in `_sequenceA`. A traversable `F` is a functor. 
        A traversable is defined by an additional `sequenceA` function
        ```
        sequenceA: F[G[S]] -> G[F[S]]
        ```
        where `G` is an applicative
        
        ## instances
        
        ### Maybe
        `Maybe` is defined in `tx.functional.maybe`. It has two constructors, `Just` and `_Nothing`. An object `Nothing` is defined.
        
        We should always use `== Nothing` to test equality and not `is Nothing`.
        
        The `Functor` instance `maybe_functor`, `Applicative` instance `maybe_applicative`, and `Monad` instance `maybe_monad` are defined. 
        
        ```
        Just(1)
        Nothing
        maybe_applicative.pure(1)
        a.bind(lambda x: Nothing)
        a.map(lambda x: 1)
        ```
        
        ### Either 
        `Either` is defined in `tx.functional.either`.  It has two constructors, `Left` and `Right`. 
        
        The `Functor` instance `either_functor`, `Applicative` instance `either_applicative`, and `Monad` instances `either_monad` are defined.
        
        ```
        Left(1)
        Right(1)
        either_applicative.pure(1)
        a.bind(lambda x: Left(1))
        a.map(lambda x: 1)
        ```
        
        ### List
        The python builtin types are used. The `Functor` instance `list_functor` and `Traversable` instance `list_traversable` are defined in `tx.functional.list`.
        
        The `list_traversable` instance is a function that takes in an applicative.
        
        ```
        list_traversable(maybe_applicative).sequenceA([Just(1)])
        ```
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.6
Description-Content-Type: text/markdown
