访问没有`this`的对象方法

Question

Can I write something like the following without using this ? I want map to return another object with the same method names and method foo changed. How can I access another method of an object without this?

function createSomething() {
    const foo = () => 1
    function map(f) {
        const newFoo = () => f(this.foo())
        return {
            foo: newFoo,
            map: map
        }
    }
    return {
        foo: foo,
        map: map
    }
}

const s = createSomething()
            .map( x => x+1 )
            .map( x => x*x )
            .foo()  // s === 4

Answer 1

In your case its easy:

const newFoo = () => f(foo())

However, you could build a new instance at every mutation and pass a state through it ( that would make it a lot easier):

function createSomething(state = 1){
  return {
    map(func){
      return createSomething(func(state));
    },
    forEach(func){
      func(state);
      return createSomething(state);
    },
    state(){ return state }
  };
}

So you can do:

 createSomething(5)
   .map( a => a +2)
   .forEach( console.log) //7
   .map( a => a + 8 )
   .forEach( console.log) //15
   .state() // 15

 const start = createSomething(5),
       second = start.map( a => a + 5),
       last = second.map(a => a + 5);

 console.log(
   start.state(),//5
   second.state(),//10
   last.state()//15
 );

Answer 2

Here's another way you can do it – you'll see this form expressed in lots of my other answers here on the site

 const Box = value => ({ value: value, map: f => Box (f (value)), ap: ({value: other}) => Box (value (other)), inspect: () => `Box {${value}}` }) const square = x => x * x console.log (Box (3) .map (square)) // Box {3} console.log (Box (square) .ap (Box (4))) // Box {16} 

And another way you can do it without the infix-style interface. The inspect code here is a little kludgy, but the idea is you'd only leave that stuff attached to development code

 const Box = { make: value => ({ type: Box, value, inspect: Box.inspector (value) }), map: (f, b) => Box.make (f (b.value)), ap: (x, f) => Box.make (f.value (x.value)), inspector: value => () => `Box {${value}}` } const square = x => x * x console.log (Box.map (square, Box.make (3))) // Box {3} console.log (Box.ap (Box.make (4), Box.make (square))) // Box {16}