zoukankan      html  css  js  c++  java
  • [Functional Programming] Function modelling -- 3. Reader Monad

    Reader Monad

    Continue with previous post, here we have some helper functions:

    const toUpper = s => s.toUpperCase();
    const exclaim = s => `${s}!`;

    And here is current code we have:

    const Fn = run => ({
      run,
      map: f => Fn(x => f(run(x))),
      chain: f =>
        Fn(x => console.log("run(x)", run(x), f(run(x))) || f(run(x)).run(x)),
      concat(otherFn) {
        return Fn(x => run(x).concat(otherFn.run(x)));
      }
    });

    Monad

    Monad is all about nesting, for example, we have 'Fn' instead a 'Fn':

    Fn(x => Fn(y => ...))

    Monad job is to flatten it.

    To implement a Monad interface, we need to implement 'chain' function:

    const Fn = run => ({
       run,
       concat(otherFn) {
          return Fn(x => run(x).concat(otherFn.run(x)))
       },
       map(f) { 
          return Fn(f => f(run(x)))
       },
       chain(otherM) {
          
       }
    })
    

    'chain' function take other Monad as arguement. 

    The implementation of 'chain' is pretty similar to 'map', the difference in meaning between 'map' & 'chain' is that we want to apply two 'Fn(method)' on the same value.

    const Fn = run => ({
      run,
      map: f => Fn(
        x => f(run(x))
      ),
      chain: f => Fn(
        x => f(run(x))
              .run(x)
      ),
      concat(otherFn) {
        return Fn(x => run(x).concat(otherFn.run(x)));
      }
    });

    Taking an example:

    Fn(toUpper)
      .chain(upper => Fn(y => exclaim(upper)))
      .run("hi"); // HI!

    'run(x)' return value, in the example is the result of 'toUpper' which is 'HI'.

    Then 'f(run(x))' return 'Fn' Monad:

    Fn (
    { 
      run: [Function],
      map: [Function: map],
      chain: [Function: chain],
      concat: [Function: concat] 
    })

    Last when we call 'f(run(x)).run(x)', we will get 'HI!', which is running 'exclaim' function over 'HI'.

    Also .run function unwrap Fn, everytimes we call .run(), we will get its value, instead of Fn().

    For 'chain' method:

      chain(f) {
        // f() return another Fn
        // when you call .run(), it unwrapper Fn()
        return Fn((x) => f(run(x)).run(x));
      },

    it call two times 'run()' but only add one 'Fn', which means it unwrap one nested 'Fn'.


    Fn.of()

    We have seen the example: 'Fn(upper)', we don't get used to that... we somehow lift a function 'upper' into a Functor, then data come last when we run ".run('hi')".

    We can change that, by passing the data first into 'Fn.of(data)', then we can doing mapping, chainning.

    But there is another interesting thing, in the previous example, data: 'hi' is the only input. If now we lift data into Fn.of('hi'), then we run ".run(another_data)", now we have two data input.

    Let's see 'Fn.of()' function first:

    const Fn = run => ({
      run,
      map: f => Fn(x => f(run(x))),
      chain: f =>
        Fn(x => console.log("run(x)", run(x), f(run(x))) || f(run(x)).run(x)),
      // run two functions and concat the result
      concat(otherM) {
        return Fn(x => run(x).concat(otherM.run(x)));
      }
    });
    Fn.of = x => Fn(() => x);
    

    Example:

    Fn.of("hi")
      .map(toUpper)
      .chain(upper => Fn(x => [upper, exclaim(x)]))
      .run("hello"); // [ 'HI', 'hello!' ]
    

    As you can see, now we have two values. We have applied 'toUpper' transform on 'hi', and apply 'exclaim' function on "hello".

    Example 2:

    Fn.of("hi")
      .map(toUpper)
      .chain(upper => Fn(x => [upper, exclaim(x)])) // ["HI", 'hello!']
      .chain(ary => Fn(x => [exclaim(ary[0]), x])) // ["HI!", "hello"]
      .run("hello");

    We can keep chaining based on previous chain's result. But this time, we keep 'x' as it is. So now, this is interesting thing, the data we pass with '.run('hello')', always keep the same value every time we try to read it.

    You can use it can enviormenet configuration object, anytime you need to read env variable you can get it from 'chain'. This partten is called: "Read Monda".

    Think about Angular, for example, it is similar to dependency injection. For React, you can use it as Provider / Context.


    Fn.ask()

    Let's define a convenient function call 'ask'. So instead of using "Fn()" constructor

    .chain(upper => Fn(x => [upper, exclaim(x)])

    We want to do:

    const Fn = run => ({
      run,
      map: f => Fn(x => f(run(x))),
      chain: f =>
        Fn(x => console.log("run(x)", run(x), f(run(x))) || f(run(x)).run(x)),
      // run two functions and concat the result
      concat(otherFn) {
        return Fn(x => run(x).concat(otherFn.run(x)));
      }
    });
    Fn.of = x => Fn(() => x);
    Fn.ask = Fn(x => x);
    

      

    Then we can refactor the previous example:

    Fn.of("hi")
      .map(toUpper)
      .chain(upper => Fn.ask.map(x => [upper, exclaim(x)])) // ["HI", 'hello!']
      .chain(ary => Fn.ask.map(x => [exclaim(ary[0]), x])) // ["HI!", "hello"]
      .run("hello");
    

      

  • 相关阅读:
    『TensorFlow』模型保存和载入方法汇总
    『cs231n』作业2选讲_通过代码理解Dropout
    『cs231n』作业2选讲_通过代码理解优化器
    『科学计算』图像检测微型demo
    『cs231n』作业1选讲_通过代码理解KNN&交叉验证&SVM
    大数据技术之_16_Scala学习_13_Scala语言的数据结构和算法_Scala学习之旅收官之作
    IDEA 取消参数名称(形参名)提示
    大数据技术之_16_Scala学习_12_设计模式+泛型、上下界、视图界定、上下文界定、协变逆变不变
    大数据技术之_16_Scala学习_11_客户信息管理系统+并发编程模型 Akka+Akka 网络编程-小黄鸡客服案例+Akka 网络编程-Spark Master Worker 进程通讯项目
    大数据技术之_16_Scala学习_10_使用递归的方式去思考,去编程+作业07/08/09
  • 原文地址:https://www.cnblogs.com/Answer1215/p/12484174.html
Copyright © 2011-2022 走看看