General thoughts about Unions

Artur Muniz — Wed, 31 Jul 2019 18:09:02 +0000

Did you joined a union?
How do unions work in your country/state/province?
What are the Pros/Cons being unionized there?

In Brazil, all workers are represented by some union, but recent legislation changes diluted the extend and the role of a union on works relations. A mandatory contribution used to exist, and was billed every year on may (may 1st being our labor day) and now is opt-in (by a hand-written solicitation forwarded to HR).

Besides having the right of being represented, unions here won't do much for employees that are not "sindicalizados" (meaning actively joined the union) both because those workers don't see unions as a good thing and because unions choose focus on more engaged working classes.

At the same time, it's pretty frequent to heard about anti-syndicalism (it's illegal here), so most workers interested in unionizing are afraid of losing their jobs.
More often than not, unions only get traction on public sector or in private sectors that does offer some public service (as transportation etc) and strikes as commonly organized by unions.

My point of view is that every workforce should be unionized, as to give the workers a active voice, but it's unfeasible to expect those workers to organize on such conditions where their jobs are on the line.

Pros/Cons being unionized in Brazil:

Pros:

unionized workers tends to get higher wages
law support
unions provides representatives
collective bargains can extends labor rights
unions might offer cultural and leisure programms
unions might have discount agreements in a myriad of services/products Cons:
Losing your job (major one)
anti-syndicalism
getting called a communist
you might disagree with your union political view

Hacking JS async/await to chain Monads

Artur Muniz — Tue, 23 Jul 2019 21:55:57 +0000

The M word.

then :: Monad m => m a ~> (a -> m b) -> m b

`await` a minute

Native JS promises follow the https://promisesaplus.com/. A+ compliant promises implementation can interoperate, but it does so by being hopeful that anything that implements a then method will behave like a promise, and that's the point we'll be hacking in.

From the spec, the important parts for us are:

1.2 “thenable” is an object or function that defines a then method.

[...]

2.2 A promise’s then method accepts two arguments:
promise.then(onFulfilled, onRejected)

[...]

2.2.2 If onFulfilled is a function:
2.2.2.1 it must be called after promise is fulfilled, with promise’s value as its first argument.
2.2.2.2 it must not be called before promise is fulfilled.
2.2.2.3 it must not be called more than once.

And the most significant bit:

[...] If x is a thenable, attempts to make promise adopt the state of x, under the assumption that x behaves at least somewhat like a promise. Otherwise, it fulfills promise with the value x.

All of that means that:
1 - We must implement a then method, to trick the The Promise Resolution Procedure into calling it. It will be a alias for the bind operation.
2 - As by 2.2.2.3, our then will be feed a onFulfilled function that expects only one call, i.e. chaining enumerations won't be possible.

Tricking JS

Consider the following monad:

const Const = (x) => ({
  then (onFulfilled) {
    return onFulfilled(x)
  }
})

const distopy = Const(1000)
  .then(x => Const(x + 900))
  .then(x => Const(x + 80))
  .then(x => Const(x + 4)) // Const(1984)

then's signature is: then :: Const a ~> (a -> Const b) -> Const b

Now, I want a function that given to Const number, returns a Const* with the sum of both. I just need to write something like:

function sumConsts (constA, constB) {
  return constA
    .then(a => constB
      .then(b => Const(a + b)
    )
  )
}

The more Consts we need to sum, the more it will look-like a callback-hell, so I'd take the advantage of Const being a thenable and refactor sumConsts as:

const sumConsts = async (constA, constB) => Const(await constA + await constB)

But now, as async functions always returns a promise into the returned value and Const is a thenable the promise resolution procedure will kick in, and make the returned promise "attempts to adopt the state of" it, so will never get a Const back, but as both Const and promises implement the same interface, the Const semantic is kept.

`Maybe` another example

const Maybe = {
 Just: (v) => {
   const typeofV = typeof v
   if (typeofV === 'undefined' || typeofV === 'null') {
     return Maybe.Nothing
   }

   return {
     then (onFulfilled) {
       return onFulfilled(v)
     }
   }
 },

 Nothing: {
   // You can either never call `onFulfilled`, so a Nothing never resolves.
   // then() {},

   // Or call `onRejected`, so resolving a Nothing rejects the promise
   then(onFulfilled, onRejected) {
     onRejected(Maybe.Nothing)
     return Maybe.Nothing
   }
 }
}

function flipCoin (myGuess) {
  const coin = Math.random() < 0.5 ? 'heads' : 'tails'
  if (coin === myGuess) {
    return Maybe.Just (myGuess)
  } else {
    return Maybe.Nothing
  }
}

async function playIt (guess = 'heads', tries = 1) {
  try {
    await flipCoin (guess)
    return tries
  } catch (reason) {
    if (reason === Maybe.Nothing)
      return playIt(guess, tries + 1)
    else
      throw reason
  }
}

playIt()
  .then(console.log) // avg output: 2

DEV Community: Artur Muniz