Grohden

//An memoize fn would be good to use here.
const getService = (serviceName) => angular.element(document.body).injector().get(serviceName);

export default new Proxy({}, {
    get (target, prop) {
        return getService(prop);
    }
});

Grohden

import java.lang.ref.WeakReference

// It doesn't matter for the receiver which one is the received argument
typealias LateBoxList<R> = List<LateMapBox<*, R>>

fun <T, R> Iterable<T>.mapAsLateBox(mapper: (T) -> R): List<LateMapBox<T, R>> {
  return this.map { LateMapBox(it, mapper) }
}

/**

Grohden

/*
 * This function doesn't work. I get a tiny error log saying that i cannot
 * update the email of a anonymous user and that i should call `registerIdentifiedUser`
 * 
 * In the `RealIntercom` class, on the `registerIdentifiedUser`
 * there's a if condition that fails in this case
 * `if (userIdentity.canRegisterIdentifiedUser(userRegistration))`
 *
 * It fails cuz the `Registration` class expects the `updateState` to be called
 * at least once, `withEmail` and `withUserId` are the ones that do that

Grohden

<- $ # module settings where

{ map, join, concat, filter, empty, fold, all, sort-by, any } = require 'prelude-ls'

response = JSON.parse """
 {  
   "requestRepository":true,
   "enterprises":[  
      {  
         "code":"T1",

Grohden

abstract class QuerySpec<Manager, Entity, TRepository : Repository<Manager, Entity>, Return> {
  abstract fun fetchResult(arg: Manager): Return
}

abstract class Repository<Manager, Entity> {
  abstract val manager: Manager

  fun <TQuerySpec : QuerySpec<Manager, Entity, Repository<Manager, Entity>, Return>, Return> executeQuery(querySpec: TQuerySpec): Return {
    return querySpec.fetchResult(manager)
  }

Grohden

/**
 * Forks a nullable into a non nullable,
 *
 * This differs from the if else expression
 * which is thread unsafe and doesn't guarantee
 * the non nullability even if the value was validated as non null
 * by the if expression (due to concurrency) 
 * NOTE: need to check this :D, probably i need to use contracts like the std to assure what
 * i said above
 *

Grohden

/* All the massive/repetitive/boring activity code above */

  override fun onPrepareOptionsMenu(menu: Menu) {
    super.onPrepareOptionsMenu(menu)

    val filterMenu = menu.findItem(R.id.actionFilter)

    /*

Grohden

Desvantagens

• Tempos de build e testes
• Tamanho do repositório (tempo de checkout)
• Nescessidade de tooling dedicado
• Tendencia a aumentar o acoplamento entre as dependências

Vantagens

Grohden

type Routes = {
    a: {
        string: string 
    }
    b: undefined
}


type NullableKeys<T, K extends keyof T> = T[K] extends null | undefined
    ? K

Grohden

const fs = require('fs');
const english = require("./english.json").text
const portuguese = require("./portuguese.json").text

const DEFAULT_KEY = "en-US"
const accumlator = {}

// Acc the english ones
english.reduce((all, value) => {
    all[value.key] = {