# fppy
开发状态：
    
依赖：
  
一个基于`python`的函数式编程类库，仅做学习使用。主要功能如下：
- [x] 常量定义
- [x] 惰性求值/惰性属性
- [x] 抽象代数
- [x] 常用组合子
- [x] 列表类
- [x] 基于`Iterable`的惰性列表
- [x] 基于元组定义的列表
- [x] 基于类定义的列表
- [x] 基于类从头定义的惰性列表
- [x] 偏函数
- [x] 基于性质测试(Property-based Testing)
- [x] 更多功能的函数装饰器
- [ ] State类
- [ ] 设计模式
- [ ] 错误处理
- [x] Option类
- [x] Either类
- [x] Try类
- [ ] Lens
- [ ] Cake
## 如何安装
从[PYPI](https://pypi.org/)软件库：
```bash
pip install fppy-learn
```
下载源码自己安装：
```python
pip install poetry
git clone https://github.com/threecifanggen/python-functional-programming.git
cd python-functional-programming
poetry install
```
## 快速功能预览
### 函数修饰器
```python
from fppy.base import F_
@F_
def f(x):
return x + 1
>>> f(1)
2
>>> f.apply(1)
2
>>> f.and_then(lambda x: x ** 3)(1) # (x + 1) ** 3
8
>>> f.compose(lambda x: x ** 3)(1) # (x ** 3) + 1
1
>>> f.map([1, 2, 3])
[2, 3, 4]
```
### 常量定义
```python
>>> from fppy.const import Const
>>>
>>> const = Const()
>>> const.a = 1
>>> const.a
1
>>> const.a = 2
# raise ConstError
```
### 列表类
一个可以实现`map`、`reduce`等操作的惰性列表
#### 元组实现的列表
##### 1. 新建
```python
from fppy.cons_list_base import *
a = cons_apply(1, 2, 3)
head(a) # 1
tail(a) # cons(2, cons(3, ()))
```
##### 2. 打印
```python
>>> print_cons(cons_apply(1, 2, 3))
1, 2, 3, nil
```
##### 3. 列表操作
```python
a = cons_apply(1, 2, 3)
map_cons_curry(lambda x: x + 1)(a) # cons_apply(2, 3, 4)
filter_cons_curry(lambda x: x % 2 == 0)(a) # cons_apply(2)
fold_left_cons_curry(lambda x, y: x + y)(0)(a) # 6
```
#### 类实现的列表
```python
from fppy.cons_list import Cons
Cons.maker(1, 2, 3)\
.map(lambda x: x + 1)\
.filter(lambda x: x % 2 == 0)\
.fold_left(lambda x, y: x + y, 0)
```
#### 从头实现的惰性列表
```python
from fppy.lazy_list_base import LazyCons
LazyCons.from_iter(1)(lambda x: x)\
.map(lambda x: x + 1)\
.filter(lambda x: x % 2 == 0)\
.take(3)\
.fold_left(lambda x, y: x + y, 0)
```
#### 惰性列表
##### 1. 新建
```python
from fppy.lazy_list import LazyList
# 定义正整数无穷列表
ll = LazyList.from_iter(2)(lambda x: x + 2)
# 从List对象定义
ll = LazyList([1, 2, 3])
# 从生成器、迭代器定义
x = (i for i in range(100))
ll = LazyList(x)
```
##### 2. map、filter、collect
```python
LazyList([1, 2, 3])\
.map(lambda x: x + 1)\
.filter(lambda x: x % 2 == 0)\
.collect() # 返回[2, 4]
```
##### 3. 其他
其他方法参考文档。
### 常见组合子
#### 1. Y组合子
下面的例子是计算阶乘：
```python
from fppy.combinator import Y
fac = Y(lambd f: lambda x: 1 if (x ==0) else x * f(x - 1))
```
#### 2. Z组合子
下面是计算指数函数的Z组合子实现
```python
from fppy.combinator import Z
power = Z(lambda f: lambda x, n: 1 if (n == 0) else x * f(x, n - 1))
```
### 偏函数
这里的偏函数是指Partial Function，即定义域取不完整的函数；而不是高阶函数中的Partial Applied Function的概念。
定义一个如下函数：
- 如果`x > 0`，则计算`1 / x`
- 如果`x < 0`，则计算`log(-x)`
```python
from math import log
from fppy.partail_function import PartialFunction
# 直接定义
pf = PartialFunction\
.case(lambda x: x > 0)\
.then(lambda x: 1 / x)\
.case(lambda x: x < 0)\
.then(lambda x: log(-x))
## 计算
pf.apply(1) # 返回1
pf.apply(-1) # 返回0
pf.apply(0) # 返回NoOtherCaseError
## 判断是否在某点有定义
pf.is_defined_at(0.4) # 返回True
pf.is_defined_at(0) # 返回False
```
我们还可以使用`or_else`来组合偏函数，比如上面的函数可以如下实现：
```python
pf_greater_then_0 = PartialFunction\
.case(lambda x: x > 0)\
.then(lambda x: 1 / x)
pf_less_then_0 = PartialFunction\
.case(lambda x: x < 0)\
.then(lambda x: log(-x))
pf = pf_greater_then_0.or_else(pf_less_then_0)
```
### 惰性求值
#### 1. 惰性属性
```python
from fppy.lazy_evaluate import lazy_property
@dataclass
class Circle:
x: float
y: float
r: float
@lazy_property
def area(self):
print("area compute")
return self.r ** 2 * 3.14
```
以上定义了一个圆的类，具体获取`area`时，仅第一次会计算（通过打印`"area compute"`显示）。
#### 2. 惰性值
`Python`没有代码块的概念，所以必须把惰性求值过程包在一个函数内，以下是调用方法：
```python
from fppy.lazy_evaluate import lazy_val
def f():
print("f compute")
return 12
lazy_val.a = f
```
调用结果下：
```python
>>> lazy_val.a
f compute
12
>>> lazy_val.a
12
```
这就表示仅第一次调用时发生了计算。
### 错误处理
### 1. Option
```python
from fppy.option import Just, Nothing
>>> Just(1).map(lambda x: x + 1)
Just(2)
>>> Just(1).flat_map(lambda x: Just(x * 3))
Just(3)
>>> Just(1).get
1
>>> Just(1).get_or_else(2)
1
>>> Just(1).filter(lambda x: x < 0)
Nothing()
>>> Just(1).filter(lambda x: x > 0)
Just(1)
```
与偏函数合用会有很多妙处：
```python
from math import log
from fppy.partail_function import PartialFunction
pf = PartialFunction\
.case(lambda x: x > 0)\
.then(lambda x: 1 / x)\
.case(lambda x: x < 0)\
.then(lambda x: log(-x))
>>> pf.lift(1)
Just(1)
>>> pf.lift(0)
Nothing()
>>> Just(1).collect(pf)
Just(1)
>>> Just(0).collect(pf)
Nothing()
>>> Just(1).collect(pf)
Just(1.)
>>> Just(1).collect(pf).map(lambda x: int(x) - 1)
Just(-1)
>>> Just(1).collect(pf).map(lambda x: int(x) - 1).collect(pf)
Just(0)
>>> Just(1).collect(pf).map(lambda x: int(x) - 1).collect(pf).collect(pf)
Nothing()
>>> Just(1).collect(pf).map(lambda x: int(x) - 1).collect(pf).collect(pf).collect(pf)
Nothing()
>>> Just(1).collect(pf).map(lambda x: int(x) - 1).collect(pf).collect(pf).collect(pf).get_or_else(2)
2
```
### 2. Either
(待完善)
### 3. Try
`Try`单子时一个非常方便地处理错误的类，它的逻辑时传递错误类一直到最后处理，可以获取到错误发生时的错误类型和输入值，方便调试：
```python
>>> from fppy.try_monad import Try
>>> res = Try(1).map(lambda x: x / 0).map(lambda x: x + 1)
>>> res.error
ZeroDivisionError('division by zero')
>>> res.get_or_else(2)
2
>>> res.get_error_input()
1
```
Raw data
{
"_id": null,
"home_page": "https://github.com/threecifanggen/python-functional-programming",
"name": "fppy-learn",
"maintainer": "",
"docs_url": null,
"requires_python": ">=3.10,<4.0",
"maintainer_email": "",
"keywords": "functional_programming,lambda",
"author": "huangbaochen",
"author_email": "huangbaochenwo@live.com",
"download_url": "https://files.pythonhosted.org/packages/81/f6/105aae055eeb46aff542eb348f6a0e5f94adf158dbd62db31545fa67fbbe/fppy_learn-0.3.1.tar.gz",
"platform": null,
"description": "# fppy\n\n\u5f00\u53d1\u72b6\u6001\uff1a\n\n    \n\n\u4f9d\u8d56\uff1a\n\n  \n\n\u4e00\u4e2a\u57fa\u4e8e`python`\u7684\u51fd\u6570\u5f0f\u7f16\u7a0b\u7c7b\u5e93\uff0c\u4ec5\u505a\u5b66\u4e60\u4f7f\u7528\u3002\u4e3b\u8981\u529f\u80fd\u5982\u4e0b\uff1a\n\n- [x] \u5e38\u91cf\u5b9a\u4e49\n- [x] \u60f0\u6027\u6c42\u503c/\u60f0\u6027\u5c5e\u6027\n- [x] \u62bd\u8c61\u4ee3\u6570\n- [x] \u5e38\u7528\u7ec4\u5408\u5b50\n- [x] \u5217\u8868\u7c7b\n - [x] \u57fa\u4e8e`Iterable`\u7684\u60f0\u6027\u5217\u8868\n - [x] \u57fa\u4e8e\u5143\u7ec4\u5b9a\u4e49\u7684\u5217\u8868\n - [x] \u57fa\u4e8e\u7c7b\u5b9a\u4e49\u7684\u5217\u8868\n - [x] \u57fa\u4e8e\u7c7b\u4ece\u5934\u5b9a\u4e49\u7684\u60f0\u6027\u5217\u8868 \n- [x] \u504f\u51fd\u6570\n- [x] \u57fa\u4e8e\u6027\u8d28\u6d4b\u8bd5(Property-based Testing)\n- [x] \u66f4\u591a\u529f\u80fd\u7684\u51fd\u6570\u88c5\u9970\u5668\n- [ ] State\u7c7b\n- [ ] \u8bbe\u8ba1\u6a21\u5f0f\n - [ ] \u9519\u8bef\u5904\u7406\n - [x] Option\u7c7b\n - [x] Either\u7c7b\n - [x] Try\u7c7b\n - [ ] Lens\n - [ ] Cake\n\n## \u5982\u4f55\u5b89\u88c5\n\n\u4ece[PYPI](https://pypi.org/)\u8f6f\u4ef6\u5e93\uff1a\n\n```bash\npip install fppy-learn\n```\n\n\u4e0b\u8f7d\u6e90\u7801\u81ea\u5df1\u5b89\u88c5\uff1a\n\n```python\npip install poetry\n\ngit clone https://github.com/threecifanggen/python-functional-programming.git\ncd python-functional-programming\n\npoetry install\n```\n\n## \u5feb\u901f\u529f\u80fd\u9884\u89c8\n\n### \u51fd\u6570\u4fee\u9970\u5668\n\n```python\nfrom fppy.base import F_\n\n@F_\ndef f(x):\n return x + 1\n\n>>> f(1)\n2\n>>> f.apply(1)\n2\n>>> f.and_then(lambda x: x ** 3)(1) # (x + 1) ** 3\n8\n>>> f.compose(lambda x: x ** 3)(1) # (x ** 3) + 1\n1\n>>> f.map([1, 2, 3])\n[2, 3, 4]\n```\n\n### \u5e38\u91cf\u5b9a\u4e49\n\n```python\n>>> from fppy.const import Const\n>>>\n>>> const = Const()\n>>> const.a = 1\n>>> const.a\n1\n>>> const.a = 2\n# raise ConstError\n```\n\n### \u5217\u8868\u7c7b\n\n\u4e00\u4e2a\u53ef\u4ee5\u5b9e\u73b0`map`\u3001`reduce`\u7b49\u64cd\u4f5c\u7684\u60f0\u6027\u5217\u8868\n\n#### \u5143\u7ec4\u5b9e\u73b0\u7684\u5217\u8868\n\n##### 1. \u65b0\u5efa\n\n```python\nfrom fppy.cons_list_base import *\n\na = cons_apply(1, 2, 3)\nhead(a) # 1\ntail(a) # cons(2, cons(3, ()))\n```\n\n##### 2. \u6253\u5370\n\n```python\n>>> print_cons(cons_apply(1, 2, 3))\n1, 2, 3, nil\n```\n\n##### 3. \u5217\u8868\u64cd\u4f5c\n\n```python\na = cons_apply(1, 2, 3)\nmap_cons_curry(lambda x: x + 1)(a) # cons_apply(2, 3, 4)\nfilter_cons_curry(lambda x: x % 2 == 0)(a) # cons_apply(2)\nfold_left_cons_curry(lambda x, y: x + y)(0)(a) # 6\n```\n\n#### \u7c7b\u5b9e\u73b0\u7684\u5217\u8868\n\n```python\nfrom fppy.cons_list import Cons\n\nCons.maker(1, 2, 3)\\\n .map(lambda x: x + 1)\\\n .filter(lambda x: x % 2 == 0)\\\n .fold_left(lambda x, y: x + y, 0)\n```\n\n#### \u4ece\u5934\u5b9e\u73b0\u7684\u60f0\u6027\u5217\u8868\n\n```python\nfrom fppy.lazy_list_base import LazyCons\n\nLazyCons.from_iter(1)(lambda x: x)\\\n .map(lambda x: x + 1)\\\n .filter(lambda x: x % 2 == 0)\\\n .take(3)\\\n .fold_left(lambda x, y: x + y, 0)\n```\n\n#### \u60f0\u6027\u5217\u8868\n\n##### 1. \u65b0\u5efa\n\n```python\nfrom fppy.lazy_list import LazyList\n\n# \u5b9a\u4e49\u6b63\u6574\u6570\u65e0\u7a77\u5217\u8868\nll = LazyList.from_iter(2)(lambda x: x + 2)\n\n# \u4eceList\u5bf9\u8c61\u5b9a\u4e49\nll = LazyList([1, 2, 3])\n\n# \u4ece\u751f\u6210\u5668\u3001\u8fed\u4ee3\u5668\u5b9a\u4e49\nx = (i for i in range(100))\nll = LazyList(x)\n```\n\n##### 2. map\u3001filter\u3001collect\n\n```python\nLazyList([1, 2, 3])\\\n .map(lambda x: x + 1)\\\n .filter(lambda x: x % 2 == 0)\\\n .collect() # \u8fd4\u56de[2, 4]\n```\n\n##### 3. \u5176\u4ed6\n\n\u5176\u4ed6\u65b9\u6cd5\u53c2\u8003\u6587\u6863\u3002\n\n### \u5e38\u89c1\u7ec4\u5408\u5b50\n\n#### 1. Y\u7ec4\u5408\u5b50\n\n\u4e0b\u9762\u7684\u4f8b\u5b50\u662f\u8ba1\u7b97\u9636\u4e58\uff1a\n\n```python\nfrom fppy.combinator import Y\n\nfac = Y(lambd f: lambda x: 1 if (x ==0) else x * f(x - 1))\n```\n\n#### 2. Z\u7ec4\u5408\u5b50\n\n\u4e0b\u9762\u662f\u8ba1\u7b97\u6307\u6570\u51fd\u6570\u7684Z\u7ec4\u5408\u5b50\u5b9e\u73b0\n\n```python\nfrom fppy.combinator import Z\n\npower = Z(lambda f: lambda x, n: 1 if (n == 0) else x * f(x, n - 1))\n```\n\n### \u504f\u51fd\u6570\n\n\u8fd9\u91cc\u7684\u504f\u51fd\u6570\u662f\u6307Partial Function\uff0c\u5373\u5b9a\u4e49\u57df\u53d6\u4e0d\u5b8c\u6574\u7684\u51fd\u6570\uff1b\u800c\u4e0d\u662f\u9ad8\u9636\u51fd\u6570\u4e2d\u7684Partial Applied Function\u7684\u6982\u5ff5\u3002\n\n\u5b9a\u4e49\u4e00\u4e2a\u5982\u4e0b\u51fd\u6570\uff1a\n\n- \u5982\u679c`x > 0`\uff0c\u5219\u8ba1\u7b97`1 / x`\n- \u5982\u679c`x < 0`\uff0c\u5219\u8ba1\u7b97`log(-x)`\n\n```python\nfrom math import log\nfrom fppy.partail_function import PartialFunction\n# \u76f4\u63a5\u5b9a\u4e49\npf = PartialFunction\\\n .case(lambda x: x > 0)\\\n .then(lambda x: 1 / x)\\\n .case(lambda x: x < 0)\\\n .then(lambda x: log(-x))\n\n## \u8ba1\u7b97\npf.apply(1) # \u8fd4\u56de1\npf.apply(-1) # \u8fd4\u56de0\npf.apply(0) # \u8fd4\u56deNoOtherCaseError\n\n## \u5224\u65ad\u662f\u5426\u5728\u67d0\u70b9\u6709\u5b9a\u4e49\npf.is_defined_at(0.4) # \u8fd4\u56deTrue\npf.is_defined_at(0) # \u8fd4\u56deFalse\n```\n\n\u6211\u4eec\u8fd8\u53ef\u4ee5\u4f7f\u7528`or_else`\u6765\u7ec4\u5408\u504f\u51fd\u6570\uff0c\u6bd4\u5982\u4e0a\u9762\u7684\u51fd\u6570\u53ef\u4ee5\u5982\u4e0b\u5b9e\u73b0\uff1a\n\n```python\npf_greater_then_0 = PartialFunction\\\n .case(lambda x: x > 0)\\\n .then(lambda x: 1 / x)\n\npf_less_then_0 = PartialFunction\\\n .case(lambda x: x < 0)\\\n .then(lambda x: log(-x))\n\npf = pf_greater_then_0.or_else(pf_less_then_0)\n```\n\n### \u60f0\u6027\u6c42\u503c\n\n#### 1. \u60f0\u6027\u5c5e\u6027\n\n```python\nfrom fppy.lazy_evaluate import lazy_property\n\n@dataclass\nclass Circle:\n x: float\n y: float\n r: float\n\n @lazy_property\n def area(self):\n print(\"area compute\")\n return self.r ** 2 * 3.14\n```\n\n\u4ee5\u4e0a\u5b9a\u4e49\u4e86\u4e00\u4e2a\u5706\u7684\u7c7b\uff0c\u5177\u4f53\u83b7\u53d6`area`\u65f6\uff0c\u4ec5\u7b2c\u4e00\u6b21\u4f1a\u8ba1\u7b97\uff08\u901a\u8fc7\u6253\u5370`\"area compute\"`\u663e\u793a\uff09\u3002\n\n#### 2. \u60f0\u6027\u503c\n\n`Python`\u6ca1\u6709\u4ee3\u7801\u5757\u7684\u6982\u5ff5\uff0c\u6240\u4ee5\u5fc5\u987b\u628a\u60f0\u6027\u6c42\u503c\u8fc7\u7a0b\u5305\u5728\u4e00\u4e2a\u51fd\u6570\u5185\uff0c\u4ee5\u4e0b\u662f\u8c03\u7528\u65b9\u6cd5\uff1a\n\n```python\nfrom fppy.lazy_evaluate import lazy_val\n\ndef f():\n print(\"f compute\")\n return 12\n\nlazy_val.a = f\n```\n\n\u8c03\u7528\u7ed3\u679c\u4e0b\uff1a\n\n```python\n>>> lazy_val.a\nf compute\n12\n>>> lazy_val.a\n12\n```\n\n\u8fd9\u5c31\u8868\u793a\u4ec5\u7b2c\u4e00\u6b21\u8c03\u7528\u65f6\u53d1\u751f\u4e86\u8ba1\u7b97\u3002\n\n### \u9519\u8bef\u5904\u7406\n\n### 1. Option\n\n```python\nfrom fppy.option import Just, Nothing\n\n>>> Just(1).map(lambda x: x + 1)\nJust(2)\n>>> Just(1).flat_map(lambda x: Just(x * 3))\nJust(3)\n>>> Just(1).get\n1\n>>> Just(1).get_or_else(2)\n1\n>>> Just(1).filter(lambda x: x < 0)\nNothing()\n>>> Just(1).filter(lambda x: x > 0)\nJust(1)\n```\n\n\u4e0e\u504f\u51fd\u6570\u5408\u7528\u4f1a\u6709\u5f88\u591a\u5999\u5904\uff1a\n\n```python\nfrom math import log\nfrom fppy.partail_function import PartialFunction\n\npf = PartialFunction\\\n .case(lambda x: x > 0)\\\n .then(lambda x: 1 / x)\\\n .case(lambda x: x < 0)\\\n .then(lambda x: log(-x))\n\n\n>>> pf.lift(1)\nJust(1)\n>>> pf.lift(0)\nNothing()\n>>> Just(1).collect(pf)\nJust(1)\n>>> Just(0).collect(pf)\nNothing()\n\n>>> Just(1).collect(pf)\nJust(1.)\n>>> Just(1).collect(pf).map(lambda x: int(x) - 1)\nJust(-1)\n>>> Just(1).collect(pf).map(lambda x: int(x) - 1).collect(pf)\nJust(0)\n>>> Just(1).collect(pf).map(lambda x: int(x) - 1).collect(pf).collect(pf)\nNothing()\n>>> Just(1).collect(pf).map(lambda x: int(x) - 1).collect(pf).collect(pf).collect(pf)\nNothing()\n>>> Just(1).collect(pf).map(lambda x: int(x) - 1).collect(pf).collect(pf).collect(pf).get_or_else(2)\n2\n\n```\n\n### 2. Either\n\n(\u5f85\u5b8c\u5584)\n\n### 3. Try\n\n`Try`\u5355\u5b50\u65f6\u4e00\u4e2a\u975e\u5e38\u65b9\u4fbf\u5730\u5904\u7406\u9519\u8bef\u7684\u7c7b\uff0c\u5b83\u7684\u903b\u8f91\u65f6\u4f20\u9012\u9519\u8bef\u7c7b\u4e00\u76f4\u5230\u6700\u540e\u5904\u7406\uff0c\u53ef\u4ee5\u83b7\u53d6\u5230\u9519\u8bef\u53d1\u751f\u65f6\u7684\u9519\u8bef\u7c7b\u578b\u548c\u8f93\u5165\u503c\uff0c\u65b9\u4fbf\u8c03\u8bd5\uff1a\n\n```python\n>>> from fppy.try_monad import Try\n>>> res = Try(1).map(lambda x: x / 0).map(lambda x: x + 1)\n>>> res.error\nZeroDivisionError('division by zero')\n>>> res.get_or_else(2)\n2\n>>> res.get_error_input()\n1\n```\n\n\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "A implements of Functional Programming in Python.",
"version": "0.3.1",
"split_keywords": [
"functional_programming",
"lambda"
],
"urls": [
{
"comment_text": "",
"digests": {
"md5": "024fbc170702659e6e1a62aa2721ac2e",
"sha256": "bddc8a3e436198ff4e6500baa7b521d4a6cdefdc37c4454c1febac9c94816f4a"
},
"downloads": -1,
"filename": "fppy_learn-0.3.1-py3-none-any.whl",
"has_sig": false,
"md5_digest": "024fbc170702659e6e1a62aa2721ac2e",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.10,<4.0",
"size": 24662,
"upload_time": "2022-12-16T13:28:42",
"upload_time_iso_8601": "2022-12-16T13:28:42.545646Z",
"url": "https://files.pythonhosted.org/packages/65/a3/e816ffa44c2d7f0001b69870ca6f7434727513b49bbc5c981d3ee375f025/fppy_learn-0.3.1-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"md5": "67a0426d133a9fb37fdd34cf20b46fee",
"sha256": "08aa55401f9fb0e1cc18f737a38709c57d17cca8a98a52f717942a410924bb83"
},
"downloads": -1,
"filename": "fppy_learn-0.3.1.tar.gz",
"has_sig": false,
"md5_digest": "67a0426d133a9fb37fdd34cf20b46fee",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10,<4.0",
"size": 20287,
"upload_time": "2022-12-16T13:28:43",
"upload_time_iso_8601": "2022-12-16T13:28:43.701369Z",
"url": "https://files.pythonhosted.org/packages/81/f6/105aae055eeb46aff542eb348f6a0e5f94adf158dbd62db31545fa67fbbe/fppy_learn-0.3.1.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2022-12-16 13:28:43",
"github": true,
"gitlab": false,
"bitbucket": false,
"github_user": "threecifanggen",
"github_project": "python-functional-programming",
"travis_ci": false,
"coveralls": true,
"github_actions": true,
"lcname": "fppy-learn"
}
JSON
