%global _empty_manifest_terminate_build 0
Name: python-PyMonad
Version: 2.4.0
Release: 1
Summary: Data structures and utilities for monadic style functional programming.
License: BSD-3-Clause
URL: https://github.com/jasondelaat/pymonad
Source0: https://mirrors.nju.edu.cn/pypi/web/packages/3b/4e/68803065743007b7dc000c543f45f6e407f8a1cbc673fdab016df3ca4b44/PyMonad-2.4.0.tar.gz
BuildArch: noarch
%description
These instructions will get you a copy of the project up and running
on your local machine for development and testing purposes.
1.1 Prerequisites
~~~~~~~~~~~~~~~~~
PyMonad requires Python 3.7+. If installing via ``pip`` then you
will also need `Pip `_ and `Wheel `_ installed. See those projects for
more information on installing them if necessary.
Potential contributors should additionally install `pylint `_ and
`pytype `_ to ensure their code adheres to common style conventions.
1.2 Installing
~~~~~~~~~~~~~~
1.2.1 From the Python Package Index (PyPI) with pip
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
From a command line run:
pip install PyMonad
1.2.2 Manual Build from PyPI
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Download the project files from
`https://pypi.org/project/PyMonad/#files `_ and from the project
directory run:
python setup.py install
If that doesn't work you may need to run the following instead.
python3 setup.py install
1.2.3 From github
^^^^^^^^^^^^^^^^^
Clone the project repository:
git clone https://github.com/jasondelaat/pymonad.git
Then from the project directory run ``setup.py`` as for the manual
build instructions above.
1.2.4 Example Usage
^^^^^^^^^^^^^^^^^^^
The following example imports the ``tools`` module and uses the
``curry`` function to define a curried addition function.
import pymonad.tools
@pymonad.tools.curry(2) # Pass the expected number of arguments to the curry function.
def add(x, y):
return x + y
# We can call add with all of it's arguments...
print(add(2, 3)) # Prints '5'
# ...or only some of them.
add2 = add(2) # Creates a new function expecting a single arguments
print(add2(3)) # Also prints '5'
1.2.5 Next Steps
^^^^^^^^^^^^^^^^
The PyMonad documentation is a work in progress. For tutorials,
how-to, and more head over to the `PyMonad Documentation Project `_.
If you'd like to contribute visit the documentation repository
`here `_.
1.3 Upgrading from PyMonad 1.3
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If you've used the 1.x versions of PyMonad you'll notice that
there are a few differences:
1.3.1 Curried functions
^^^^^^^^^^^^^^^^^^^^^^^
Currying functions in PyMonad version 1.x wrapped a function in
an instance of the Reader monad. This is no longer the case and
currying simply produces a new function as one might expect.
The signature of ``curry`` has changed slightly. The new ``curry``
takes two arguments: the number of arguments which need to be
curried and the function.
from pymonad.tools import curry
def add(x, y):
return x + y
curried_add = curry(2, add)
# add = curry(2, add) # If you don't need access to the uncurried version.
``curry`` is itself a curried function so it can be used more
concisely as a decorator.
from pymonad.tools import curry
@curry(2)
def add(x, y):
return x + y
1.3.2 Operators
^^^^^^^^^^^^^^^
Version 2 of PyMonad discourages the use of operators (>>, \\\*, and
&) used in version 1 so old code which uses them will
break. Operators have been removed from the default monad
implementation but are still available for users that still wish
to use them in the ``operators`` package. To use operators:
# Instead of this:
# import pymonad.maybe
# Do this:
import pymonad.operators.maybe
While it's unlikely operators will be removed entirely, it is
strongly suggested that users write code that doesn't require
them.
1.3.3 Renamed Methods
^^^^^^^^^^^^^^^^^^^^^
The ``fmap`` method has been renamed to simply ``map`` and ``unit`` is now called ``insert``.
from pymonad.maybe import Maybe
def add2(x):
return x + 2
m = (Maybe.insert(1)
.map(add2)
)
print(m) # Just 3
1.3.4 Applicative Syntax
^^^^^^^^^^^^^^^^^^^^^^^^
Previously applicative syntax used the ``&`` operator or the ``amap``
method. ``amap`` still exists but there's now another way to use
applicatives: ``apply().to_arguments()``
from pymonad.tools import curry
from pymonad.maybe import Maybe, Just
@curry(2)
def add(x, y):
return x + y
a = Just(1)
b = Just(2)
c = Maybe.apply(add).to_arguments(a, b)
print(c) # Just 3
If the function passed to ``apply`` accepts multiple arguments then
it *must* be a curried function.
1.3.5 New ``then`` method
^^^^^^^^^^^^^^^^^^^^^^^^^
The ``then`` method combines the functionality of both ``map`` and
``bind``. It first tries to ``bind`` the function passed to it and,
if that doesn't work, tries ``map`` instead. It will be slightly
less efficient than using ``map`` and ``bind`` directly but frees
users from having to worry about specifically which functions are
being used where.
from pymonad.tools import curry
from pymonad.maybe import Maybe, Just, Nothing
@curry(2)
def add(x, y):
return x + y
@curry(2)
def div(y, x):
if y == 0:
return Nothing
else:
return Just(x / y)
m = (Maybe.insert(2)
.then(add(2)) # Uses map
.then(div(4)) # Uses bind
)
print(m) # Just 1.0
1.3.6 Getting values out of ``Maybe`` and ``Either``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Previously, if you need to get a value out of a ``Maybe`` or an
``Either`` after a series of calculations you would have to access
the ``.value`` property directly. By the very nature of these two
monads, ``.value`` may not contain valid data and checking whether
the data is valid or not is the problem these monads are supposed
to solve. As of PyMonad 2.3.0 there are methods -- ``maybe`` and
``either`` -- for properly extracting values from these
monads.
Given a ``Maybe`` value ``m``, the ``maybe`` method takes a default
value, which will be returned if ``m`` is ``Nothing``, and a function
which will be applied to the value inside of a ``Just``.
from pymonad.maybe import Just, Nothing
a = Just(2)
b = Nothing
print(a.maybe(0, lambda x: x)) # 2
print(b.maybe(0, lambda x: x)) # 0
The ``either`` method works essentially the same way but takes two
functions as arguments. The first is applied if the value is a
``Left`` value and the second if it's a ``Right``.
from pymonad.either import Left, Right
a = Right(2)
b = Left('Invalid')
print(a.either(lambda x: f'Sorry, {x}', lambda x: x)) # 2
print(b.either(lambda x: f'Sorry, {x}', lambda x: x)) # Sorry, Invalid
1.4 Note on efficiency in versions <2.3.5
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In pymonad versions 2.3.4 and earlier, an error in the
implementation of ``then`` meant that some monad
types executed ``then`` with exponential complexity. As of version
2.3.5 this has been corrected. All monad types now execute ``then``
in linear time. A similar problem occured with the ``map`` and
``bind`` methods for the State monad which have also been fixed in
2.3.5
If you're using an earlier version of pymonad upgrading to 2.3.5
is highly recommended.
%package -n python3-PyMonad
Summary: Data structures and utilities for monadic style functional programming.
Provides: python-PyMonad
BuildRequires: python3-devel
BuildRequires: python3-setuptools
BuildRequires: python3-pip
%description -n python3-PyMonad
These instructions will get you a copy of the project up and running
on your local machine for development and testing purposes.
1.1 Prerequisites
~~~~~~~~~~~~~~~~~
PyMonad requires Python 3.7+. If installing via ``pip`` then you
will also need `Pip `_ and `Wheel `_ installed. See those projects for
more information on installing them if necessary.
Potential contributors should additionally install `pylint `_ and
`pytype `_ to ensure their code adheres to common style conventions.
1.2 Installing
~~~~~~~~~~~~~~
1.2.1 From the Python Package Index (PyPI) with pip
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
From a command line run:
pip install PyMonad
1.2.2 Manual Build from PyPI
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Download the project files from
`https://pypi.org/project/PyMonad/#files `_ and from the project
directory run:
python setup.py install
If that doesn't work you may need to run the following instead.
python3 setup.py install
1.2.3 From github
^^^^^^^^^^^^^^^^^
Clone the project repository:
git clone https://github.com/jasondelaat/pymonad.git
Then from the project directory run ``setup.py`` as for the manual
build instructions above.
1.2.4 Example Usage
^^^^^^^^^^^^^^^^^^^
The following example imports the ``tools`` module and uses the
``curry`` function to define a curried addition function.
import pymonad.tools
@pymonad.tools.curry(2) # Pass the expected number of arguments to the curry function.
def add(x, y):
return x + y
# We can call add with all of it's arguments...
print(add(2, 3)) # Prints '5'
# ...or only some of them.
add2 = add(2) # Creates a new function expecting a single arguments
print(add2(3)) # Also prints '5'
1.2.5 Next Steps
^^^^^^^^^^^^^^^^
The PyMonad documentation is a work in progress. For tutorials,
how-to, and more head over to the `PyMonad Documentation Project `_.
If you'd like to contribute visit the documentation repository
`here `_.
1.3 Upgrading from PyMonad 1.3
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If you've used the 1.x versions of PyMonad you'll notice that
there are a few differences:
1.3.1 Curried functions
^^^^^^^^^^^^^^^^^^^^^^^
Currying functions in PyMonad version 1.x wrapped a function in
an instance of the Reader monad. This is no longer the case and
currying simply produces a new function as one might expect.
The signature of ``curry`` has changed slightly. The new ``curry``
takes two arguments: the number of arguments which need to be
curried and the function.
from pymonad.tools import curry
def add(x, y):
return x + y
curried_add = curry(2, add)
# add = curry(2, add) # If you don't need access to the uncurried version.
``curry`` is itself a curried function so it can be used more
concisely as a decorator.
from pymonad.tools import curry
@curry(2)
def add(x, y):
return x + y
1.3.2 Operators
^^^^^^^^^^^^^^^
Version 2 of PyMonad discourages the use of operators (>>, \\\*, and
&) used in version 1 so old code which uses them will
break. Operators have been removed from the default monad
implementation but are still available for users that still wish
to use them in the ``operators`` package. To use operators:
# Instead of this:
# import pymonad.maybe
# Do this:
import pymonad.operators.maybe
While it's unlikely operators will be removed entirely, it is
strongly suggested that users write code that doesn't require
them.
1.3.3 Renamed Methods
^^^^^^^^^^^^^^^^^^^^^
The ``fmap`` method has been renamed to simply ``map`` and ``unit`` is now called ``insert``.
from pymonad.maybe import Maybe
def add2(x):
return x + 2
m = (Maybe.insert(1)
.map(add2)
)
print(m) # Just 3
1.3.4 Applicative Syntax
^^^^^^^^^^^^^^^^^^^^^^^^
Previously applicative syntax used the ``&`` operator or the ``amap``
method. ``amap`` still exists but there's now another way to use
applicatives: ``apply().to_arguments()``
from pymonad.tools import curry
from pymonad.maybe import Maybe, Just
@curry(2)
def add(x, y):
return x + y
a = Just(1)
b = Just(2)
c = Maybe.apply(add).to_arguments(a, b)
print(c) # Just 3
If the function passed to ``apply`` accepts multiple arguments then
it *must* be a curried function.
1.3.5 New ``then`` method
^^^^^^^^^^^^^^^^^^^^^^^^^
The ``then`` method combines the functionality of both ``map`` and
``bind``. It first tries to ``bind`` the function passed to it and,
if that doesn't work, tries ``map`` instead. It will be slightly
less efficient than using ``map`` and ``bind`` directly but frees
users from having to worry about specifically which functions are
being used where.
from pymonad.tools import curry
from pymonad.maybe import Maybe, Just, Nothing
@curry(2)
def add(x, y):
return x + y
@curry(2)
def div(y, x):
if y == 0:
return Nothing
else:
return Just(x / y)
m = (Maybe.insert(2)
.then(add(2)) # Uses map
.then(div(4)) # Uses bind
)
print(m) # Just 1.0
1.3.6 Getting values out of ``Maybe`` and ``Either``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Previously, if you need to get a value out of a ``Maybe`` or an
``Either`` after a series of calculations you would have to access
the ``.value`` property directly. By the very nature of these two
monads, ``.value`` may not contain valid data and checking whether
the data is valid or not is the problem these monads are supposed
to solve. As of PyMonad 2.3.0 there are methods -- ``maybe`` and
``either`` -- for properly extracting values from these
monads.
Given a ``Maybe`` value ``m``, the ``maybe`` method takes a default
value, which will be returned if ``m`` is ``Nothing``, and a function
which will be applied to the value inside of a ``Just``.
from pymonad.maybe import Just, Nothing
a = Just(2)
b = Nothing
print(a.maybe(0, lambda x: x)) # 2
print(b.maybe(0, lambda x: x)) # 0
The ``either`` method works essentially the same way but takes two
functions as arguments. The first is applied if the value is a
``Left`` value and the second if it's a ``Right``.
from pymonad.either import Left, Right
a = Right(2)
b = Left('Invalid')
print(a.either(lambda x: f'Sorry, {x}', lambda x: x)) # 2
print(b.either(lambda x: f'Sorry, {x}', lambda x: x)) # Sorry, Invalid
1.4 Note on efficiency in versions <2.3.5
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In pymonad versions 2.3.4 and earlier, an error in the
implementation of ``then`` meant that some monad
types executed ``then`` with exponential complexity. As of version
2.3.5 this has been corrected. All monad types now execute ``then``
in linear time. A similar problem occured with the ``map`` and
``bind`` methods for the State monad which have also been fixed in
2.3.5
If you're using an earlier version of pymonad upgrading to 2.3.5
is highly recommended.
%package help
Summary: Development documents and examples for PyMonad
Provides: python3-PyMonad-doc
%description help
These instructions will get you a copy of the project up and running
on your local machine for development and testing purposes.
1.1 Prerequisites
~~~~~~~~~~~~~~~~~
PyMonad requires Python 3.7+. If installing via ``pip`` then you
will also need `Pip `_ and `Wheel `_ installed. See those projects for
more information on installing them if necessary.
Potential contributors should additionally install `pylint `_ and
`pytype `_ to ensure their code adheres to common style conventions.
1.2 Installing
~~~~~~~~~~~~~~
1.2.1 From the Python Package Index (PyPI) with pip
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
From a command line run:
pip install PyMonad
1.2.2 Manual Build from PyPI
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Download the project files from
`https://pypi.org/project/PyMonad/#files `_ and from the project
directory run:
python setup.py install
If that doesn't work you may need to run the following instead.
python3 setup.py install
1.2.3 From github
^^^^^^^^^^^^^^^^^
Clone the project repository:
git clone https://github.com/jasondelaat/pymonad.git
Then from the project directory run ``setup.py`` as for the manual
build instructions above.
1.2.4 Example Usage
^^^^^^^^^^^^^^^^^^^
The following example imports the ``tools`` module and uses the
``curry`` function to define a curried addition function.
import pymonad.tools
@pymonad.tools.curry(2) # Pass the expected number of arguments to the curry function.
def add(x, y):
return x + y
# We can call add with all of it's arguments...
print(add(2, 3)) # Prints '5'
# ...or only some of them.
add2 = add(2) # Creates a new function expecting a single arguments
print(add2(3)) # Also prints '5'
1.2.5 Next Steps
^^^^^^^^^^^^^^^^
The PyMonad documentation is a work in progress. For tutorials,
how-to, and more head over to the `PyMonad Documentation Project `_.
If you'd like to contribute visit the documentation repository
`here `_.
1.3 Upgrading from PyMonad 1.3
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If you've used the 1.x versions of PyMonad you'll notice that
there are a few differences:
1.3.1 Curried functions
^^^^^^^^^^^^^^^^^^^^^^^
Currying functions in PyMonad version 1.x wrapped a function in
an instance of the Reader monad. This is no longer the case and
currying simply produces a new function as one might expect.
The signature of ``curry`` has changed slightly. The new ``curry``
takes two arguments: the number of arguments which need to be
curried and the function.
from pymonad.tools import curry
def add(x, y):
return x + y
curried_add = curry(2, add)
# add = curry(2, add) # If you don't need access to the uncurried version.
``curry`` is itself a curried function so it can be used more
concisely as a decorator.
from pymonad.tools import curry
@curry(2)
def add(x, y):
return x + y
1.3.2 Operators
^^^^^^^^^^^^^^^
Version 2 of PyMonad discourages the use of operators (>>, \\\*, and
&) used in version 1 so old code which uses them will
break. Operators have been removed from the default monad
implementation but are still available for users that still wish
to use them in the ``operators`` package. To use operators:
# Instead of this:
# import pymonad.maybe
# Do this:
import pymonad.operators.maybe
While it's unlikely operators will be removed entirely, it is
strongly suggested that users write code that doesn't require
them.
1.3.3 Renamed Methods
^^^^^^^^^^^^^^^^^^^^^
The ``fmap`` method has been renamed to simply ``map`` and ``unit`` is now called ``insert``.
from pymonad.maybe import Maybe
def add2(x):
return x + 2
m = (Maybe.insert(1)
.map(add2)
)
print(m) # Just 3
1.3.4 Applicative Syntax
^^^^^^^^^^^^^^^^^^^^^^^^
Previously applicative syntax used the ``&`` operator or the ``amap``
method. ``amap`` still exists but there's now another way to use
applicatives: ``apply().to_arguments()``
from pymonad.tools import curry
from pymonad.maybe import Maybe, Just
@curry(2)
def add(x, y):
return x + y
a = Just(1)
b = Just(2)
c = Maybe.apply(add).to_arguments(a, b)
print(c) # Just 3
If the function passed to ``apply`` accepts multiple arguments then
it *must* be a curried function.
1.3.5 New ``then`` method
^^^^^^^^^^^^^^^^^^^^^^^^^
The ``then`` method combines the functionality of both ``map`` and
``bind``. It first tries to ``bind`` the function passed to it and,
if that doesn't work, tries ``map`` instead. It will be slightly
less efficient than using ``map`` and ``bind`` directly but frees
users from having to worry about specifically which functions are
being used where.
from pymonad.tools import curry
from pymonad.maybe import Maybe, Just, Nothing
@curry(2)
def add(x, y):
return x + y
@curry(2)
def div(y, x):
if y == 0:
return Nothing
else:
return Just(x / y)
m = (Maybe.insert(2)
.then(add(2)) # Uses map
.then(div(4)) # Uses bind
)
print(m) # Just 1.0
1.3.6 Getting values out of ``Maybe`` and ``Either``
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Previously, if you need to get a value out of a ``Maybe`` or an
``Either`` after a series of calculations you would have to access
the ``.value`` property directly. By the very nature of these two
monads, ``.value`` may not contain valid data and checking whether
the data is valid or not is the problem these monads are supposed
to solve. As of PyMonad 2.3.0 there are methods -- ``maybe`` and
``either`` -- for properly extracting values from these
monads.
Given a ``Maybe`` value ``m``, the ``maybe`` method takes a default
value, which will be returned if ``m`` is ``Nothing``, and a function
which will be applied to the value inside of a ``Just``.
from pymonad.maybe import Just, Nothing
a = Just(2)
b = Nothing
print(a.maybe(0, lambda x: x)) # 2
print(b.maybe(0, lambda x: x)) # 0
The ``either`` method works essentially the same way but takes two
functions as arguments. The first is applied if the value is a
``Left`` value and the second if it's a ``Right``.
from pymonad.either import Left, Right
a = Right(2)
b = Left('Invalid')
print(a.either(lambda x: f'Sorry, {x}', lambda x: x)) # 2
print(b.either(lambda x: f'Sorry, {x}', lambda x: x)) # Sorry, Invalid
1.4 Note on efficiency in versions <2.3.5
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In pymonad versions 2.3.4 and earlier, an error in the
implementation of ``then`` meant that some monad
types executed ``then`` with exponential complexity. As of version
2.3.5 this has been corrected. All monad types now execute ``then``
in linear time. A similar problem occured with the ``map`` and
``bind`` methods for the State monad which have also been fixed in
2.3.5
If you're using an earlier version of pymonad upgrading to 2.3.5
is highly recommended.
%prep
%autosetup -n PyMonad-2.4.0
%build
%py3_build
%install
%py3_install
install -d -m755 %{buildroot}/%{_pkgdocdir}
if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
pushd %{buildroot}
if [ -d usr/lib ]; then
find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/lib64 ]; then
find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/bin ]; then
find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/sbin ]; then
find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
fi
touch doclist.lst
if [ -d usr/share/man ]; then
find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
fi
popd
mv %{buildroot}/filelist.lst .
mv %{buildroot}/doclist.lst .
%files -n python3-PyMonad -f filelist.lst
%dir %{python3_sitelib}/*
%files help -f doclist.lst
%{_docdir}/*
%changelog
* Fri May 05 2023 Python_Bot - 2.4.0-1
- Package Spec generated