Python module for composing computations
Project description
Functional Python
For better computation composing in Python
Goals
- To bring the ability of composing computations in the functional way
- Make my life easier
No Goals
- Exact clone of Haskell
- Blazing fast / super efficient
Python is Already Amazing, Why Bother?
- Because I can
- Python may be amazing in some field, but sucks from the functional perspective
Python Sucks, Why Bother?
- Because I can
- Python is still used in my work place
Install
With pip:
pip install fppy
Control:
Functor fpy.control.functor
Given Functors f
, g
:
__fmap__ :: f a -> (a -> b) -> f b
__ntrans__ :: f a -> (f a ~> g b) -> g b
Operators:
|
=__fmap__
&
=__ntrans__
Functions:
fmap
=__fmap__
NTrans (Natrual Transform) fpy.control.natural_transform
Given Functors f
, g
:
__trans__ :: f a ~> g b
Applicative : Functor fpy.control.applicative
No new trait comparing to functor, liftA2
is defined using fmap
Monad : Applicative fpy.control.monad
Given Monad m
:
__bind__ :: m a -> (a -> m b) -> m b
Operators:
>>
=__bind__
Do Notation:
@do(Monad)
enables do notation in the decorated function, where the explicitreturn
statement will be treated asret
from the givenMonad
type, if noreturn
statement is given, the last element on the stack will be returned.name <- computation
binds the computation to the following block, calling the__bind__
method of the monad object returned fromcomputation
with the namename
.(name1, name2, ..., namen) <- computation
works in the similar way as the single name binding, this applys the binding function to the tuple contained within the monad object instead of calling the function directly.name1, name2, ..., namen <- computation
same as above
Data
Maybe : Monad fpy.data.maybe
Types:
Maybe[T]
Just[T] : Maybe[T]
Nothing[T] : Maybe[T]
Functions:
isJust :: Maybe[T] -> bool
isNothing :: Maybe[T] -> bool
fromJust :: Maybe[T] -> T
fromMaybe :: T -> Maybe[T] -> T
maybe :: S -> (T -> S) -> Maybe[T] -> S
mapMaybe :: (T -> Maybe[S]) -> List[T] -> List[S]
Either : Monad fpy.data.either
Types:
Either[T]
Left[T] : Either[T]
Right[T] : Either[T]
Forgetful : Monad (Forgetful Functor) fpy.data.forgetful
Types:
Under[T]
Under
similar to Haskell'sIdentity
monad
Cont : Monad fpy.data.cont
Types:
Cont[T, R]
Functions:
cont :: (A -> B) -> Cont[A, B]
runCont :: Cout[B, C] -> C
Functions:
Given functor f
:
forget: NTrans[F, B, Under, T] :: f b ~> Under[T]
Utility Functions fpy.data.function
id_ :: T -> T
const :: T -> A -> T
flip :: (B -> A -> T) -> A -> B -> T
fix :: (A -> A) -> A
on :: (B -> B -> T) -> (A -> B) -> A -> A -> T
Slightly Dependent Utilities
-- not so well typed
NArg :: Nat -> Type
NArg (S Z) = A
NArg (S n) = A -> (NArg n)
NTpl :: (n:Nat) -> (NArg n) -> Type
NTpl (S Z) A =( A,)
NTpl (S n) (A -> NArg n) = cons A (NTpl n (NArg n))
constN :: (n:Nat) -> A -> (NArg n) -> A
uncurryN :: (n:Nat) -> args:(NArg n) -> A -> ((NTpl n args) -> A)
Composable
Composable fpy.composable.composable
__compose__
Operators:
^
=__compose__
Transparent fpy.composable.transparent
__underlying__
Delegate an attribute access to an underlying object
Function fpy.composable.function
Types:
func : Composable
SignatureMismatchError
NotEnoughArgsError
Collections fpy.composable.collections
Types:
Seq : func
Map : func
Functions:
transN(n, f, it) := it[n] = f(it[n])
getN(n, it) := it[n]
setN(n, v, it) := it[n] = v
eqN(n, it, x) := it[n] == x
mapN(n, fn, lsts) := map(fn, zip(lst1, lst2 ... lstn))
of_(v1 ... vn) := _ in (v1 ... vn)
is_(t) := isinstance(_, t)
and_(a, b) := a(_) and b(_)
or_(a, b) := a(_) or b(_)
to(dst, src) := dst(src)
apply(fn) := fn(*a, **k)
fwd_ = Under.ret
Predefined Vars:
trans0
trans1
get0
get1
set0
set1
eq0
eq1
mp1
mp2
Parsec
Parsec fpy.parsec.parsec
Types:
parser[S, T] :: [S] -> Either [S] ([T] * [S])
Operators:
*
=parser.timeN
+
=parser.concat
|
=parser.choice
>>
=parser.parseR
<<
=parser.parseL
Functions:
one :: (S -> bool) -> parser[S, S]
neg :: (S -> bool) -> parser[S, S]
just_nothing :: parser[S, T]
pmaybe :: parser[S, T] -> parser[S, T]
many :: parser[S, T] -> parser[S, T]
many1 :: parser[S, T] -> parser[S, T]
ptrans :: parser[S, T] -> (T -> Y) -> parser[S, Y]
peek :: parser[S, T] -> parser[S, T]
skip :: parser[S, T] -> parser[S, T]
pseq :: [S] -> parser[S, T]
inv :: parser[S, T] -> parser[S, T]
Dependencies
License
GPL3+
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
fppy-0.0.18.post6.tar.gz
(33.3 kB
view details)
Built Distribution
File details
Details for the file fppy-0.0.18.post6.tar.gz
.
File metadata
- Download URL: fppy-0.0.18.post6.tar.gz
- Upload date:
- Size: 33.3 kB
- Tags: Source
- Uploaded using Trusted Publishing? No
- Uploaded via: twine/6.1.0 CPython/3.13.2
File hashes
Algorithm | Hash digest | |
---|---|---|
SHA256 | 480ad7a39a99ae2f3c90e24f259a4036ab544edd96a2be47efe8cc468fd67afe |
|
MD5 | c745b87f875e3efb75aaf83b243178d6 |
|
BLAKE2b-256 | 4dd20e47db3d7cdb8defb45df2ba592d8fbd68e602205f593cc2f94e895f813d |
File details
Details for the file fppy-0.0.18.post6-py3-none-any.whl
.
File metadata
- Download URL: fppy-0.0.18.post6-py3-none-any.whl
- Upload date:
- Size: 42.1 kB
- Tags: Python 3
- Uploaded using Trusted Publishing? No
- Uploaded via: twine/6.1.0 CPython/3.13.2
File hashes
Algorithm | Hash digest | |
---|---|---|
SHA256 | dd2a3791db57dabf54ca3ed9af02c8c1e62a4d8e39a16f9521b0b89c1a3c8cf3 |
|
MD5 | 3ae7591103eafb618f609387aa950c21 |
|
BLAKE2b-256 | 6bbf763d7265c9368f912eed6e5d3403261e95d882934b02b16826996b6bf392 |