zoukankan      html  css  js  c++  java
  • [Functional Programming] From simple implementation to Currying to Partial Application

    Let's say we want to write a most simple implementation 'avg' function:

    const avg = list => {
        let sum = 0;
        for(let i = 0; i < list.length; i++) {
            sum += list[i]
        }
        return sum / list.length
    }

    Basiclly, the 'avg' function doing two things:

    • Calculate sum
    • Divide sum / length

    It works fine for tiny / small application, but for the large application, we need to think about reuseablitiy. We want to breakdown one function and think about any reuseable partten, which later can be reused.

    In the following examples, We want to bring in two libarays which are commonly used in FP. One is Ramda, another one is Crocks.

    Currying:

    First, we want to write 'sum' and 'devide' functions by ourselves:

    const { curry, reduce, compose } = require("crocks");
    const R = require("ramda");
    
    const sum = reduce(R.add, 0);
    // divideByLen :: [Number] -> Number -> Number
    const divideByLen = curry(
      compose(
        R.flip(R.divide),
        R.length
      )
    );

    'sum' is simple, using 'reduce' from Crocks, you can also write JS reduce, doesn't matter.

    What we need to explain is 'divideByLen' function. 

    • Why 'curry'?

    Basic we want to call divideByLen in two ways:

    divideByLen([1,2,3], sum([1,2,3]))
    divideByLen([1,2,3])(sum([1,2,3]))

    [Notice] You need to bring in 'curry' from Crocks, it is more flexable. 

    • Why 'flip'?

    Because R.divide(sum, length), we need to feed the divide function with sum as first argement, then length as second arguement. But when we write code, length will be feeded frist, sum will be partially applied, it will come second, therefore we need to call 'flip'.

    Bring all together:

    const avg = list =>
      compose(
        divideByLen(list),
        sum
      )(list);

    We notice that, we have to pass 'list' to both Sum(list) and divideByLen(list). The code looks not so good. Whenever you are facing the situation, you need to pass the same arguement to two functions in parallel. You can consider to using 'Partial Application'.

    Partial Application:

    // Ramda

    const avg = R.converge(R.divide, [R.sum, R.length]);

    We are using 'Ramda's converge' function, bascilly you have pass in a data, the data will be passed to R.sum(data) & R.length(data), the return results of those two functions, will be passed to R.divide(resOfSum, resOfLength). 

    //Crocks:

    const { curry, fanout, merge, compose } = require("crocks");
    
    const avg = compose(
      merge(R.divide),
      fanout(R.sum, R.length)
    );

    We are using the Pair ADT, the data will be passed to R.sum(data) & R.length(data) thought 'fanout' function, it returns Pair(resOfSum, resOfLength).

    Then we use 'merge', it works with Pair ADT, we merge two results by R.divide(resOfSum, resOfLength).

  • 相关阅读:
    Python获取秒级时间戳与毫秒级时间戳
    时间戳与时间类型转化(秒级时间戳)
    linux压缩和解压缩命令
    对于Python中@property的理解和使用
    探索性测试方法
    Linux 中 grep 命令的 12 个实践例子
    在 Linux 启动或重启时执行命令与脚本
    亲测的orabbix监控Oracle过程
    find 使用搜集
    Centos7.3-mysql5.7复制安装过程
  • 原文地址:https://www.cnblogs.com/Answer1215/p/10753304.html
Copyright © 2011-2022 走看看