https://groups.google.com/forum/?fromgroups=#!topic/scala-user/nC263xUiaQo

The same dumb stupid Java where you can only pass a final into an internal class...

"

List<Integer> ints = new ArrayList<>(); 
ints.add(1); 
ints.add(2); 
ints.add(3); 

int sum = 0; 
ints.forEach(i -> {sum += i;}); 

The compiler error is: "value used in lambda expression should be effectively final". I got some bad suspicion and tried whether this compiles:

int sumArray[] = new int[] { 0 }; 
ints.forEach(i -> {sumArray[0] += i;}); 

This did compile.
"

I believe we can.

Generally speaking, say, we have two monads, T and U; their composition T ∘ U is a functor which is not always a monad. Unit is okay, but multiplication, T ∘ U ∘ T ∘ U → T ∘ U does not always exist. It would exist if the two monads commuted, that if, if we had U ∘ T → T ∘ U, which is also known as traversal of U over T; in case U comes from a monoid, this is the famouse "map/reduce".

I was working on a simple example in Java programming language, say, take Reader monad and Maybe monad, the latter also known as Option in Scala and in various Java libraries. It is almost obvious that if we have a Maybe wrapped into a Reader, it cannot be naturally transformed into Reader wrapped into a Maybe.

Maybe in Java can be thought of as a function that may throw some kind of exception, and we don't care which, just catch it (and log it, that's what Java people do with exceptions).

Reader in Java can be represented as "dependency injection" - we have a function that is supposed to return something, but its behavior depends on some external circumstances unknown to client code. This is different from State, an example of which is a Random Numbers Generator; with "dependency" we are tied to the same environment during the lifetime of the program.

For the utmost simplicity, let's imagine that we have only two possible "environment values", say, DEBUG, which is either TRUE or FALSE.

So, in this case, what the client thinks of as a function: X → Y, in our Reader is actually a function: X → Y2 whereby we potentially produce two values, one for DEBUG=TRUE and another for DEBUG=FALSE.

If we deal with Maybe, what a client sees as a function: X → Y is actually function: X → 1+Y, where failures map values into this 1, which in Java is represented via null.

Okay.

Now one composition is (1 + Y)2 == 1 + 2×Y + Y2, and the other is 1 + Y2.

We can easily embed the second one into the first one, but there's no general natural way to transform the first one to the second one; what will we do with the two instances of 1×Y? Unless we have Y as an algebra over Maybe, that is, a natural transformation 1 → Y.

Nevertheless, I will show that the composition of Maybe ∘ Reader is a monad.

First, let's generalize Reader to a dependency on a certain type E of "environment: Reader<E>.

So, Reader amounts to having a functor X ↦ XE, where unit X → XE amounts to constant, and multiplication (XE)E → XE is dual to diagonal Δ E → E×E, that is, XΔ.

Now, can we naturally transform Reader(Maybe(Reader(Maybe(X)))) to Reader(Maybe(X))? Not only naturally, but with all the monadic properties of multiplication (unit and associativity, that is).

We have (1 + (1 + X)E)E, and we need to produce (1 + X)E

This is dual to (thanks to Yoneda Lemma) having a good transformation
E × (1 + (1 + X)E)E → (1 + X)

Let's throw in Δ E → E×E, and build
E × (1 + (1 + X)E)E → E × E × (1 + (1 + X)E)E → (1 + X)

Using eval: E × AE, have
E × E × (1 + (1 + X)E)E → E × (1 + (1 + X)E)

So it would be enough to have a good
E × (1 + (1 + X)E) → (1 + X)
which amounts to having

E × 1 + E × (1 + X)E) → (1 + X)

Which is obvious: the first component maps to 1, the second is eval again.

That's it.

Questions? Errors? Remarks? Suggestions.

(One question is how come Java types are not Maybe-algebras, they are, are not they?)

вон тут человек многопоточный лисп на ней нарисовал - 110 строк

Вот так и надо с ней общаться.

    public Props(Tuple2<String, String>... tuples) {
        map = new HashMap<String, String>();
        for (Tuple2<String, String> t: tuples) {
            map.put(t._1(), t._2());
        }
    }

Это у меня есть такой джавный класс, Props, и я теперь в этом проекте кусочеки на Скале пишу, так чтоб конструктор вызывать через new Props(USER->"sonoio", PASSWORD->"пароль")

загадка была такая, что вроде в продакшене всё у нас с базами в порядке, а когда я присобачил в фреймуорк чтобы селф-тесты бегали, то эти селф-тесты позорно рушились, причём явление происходило не сразу, а коррелировало с какими-то затратами процессора, с ресурсами памяти...

Короче, я придумал этот аспект, Health.check("vot tut pocheshite pozhaluista");, но он не особо помогал. Постепенно локализовал - после queue.wait() вдруг база переставала работать (а данные записывались только частично - но они каждый в своей транзакции). Замена на Thread.sleep() убирала эффект.

Что делал - по совету присутствующего товарища magictoken понатыкал логов в постгрес; ну и свои логи тоже.

Выяснились интересные вещи:
- записи перестают попадать в таблицу после queue.wait();
- лог postgres показывает, что транзакция открывается, данные приходят, транзакция закрывается.
- если не менять код, то наблюдается очень стабильное поведение.

Короче, что выяснилось. В сервере в разных потоках бегают сразу два серверных приложения. Они используют две разные базы данных. В принципе, когда мы получили задание, то в глобальный синглтон складывается рефренс на фабрику "энтити менеджеров" (каждый раз, когда я вижу в коде слово "менеджер", моя рука тянется к кнопке delete). Как только наше приложение садится подождать, пока на его мессагу ответят, просыпается другое приложение (могло бы на другом процессоре работать), и подставляет свой контекст. Мы получаем ответ, просыпаемся, продолжаем движение - складывая наши данные уже в другую базу.

Классический пример ахинеи. Я такую чушь ещё в фортране видал, и в си видал... В Борланде в одной интересной программе пара файлов передавалась в виде имён и рукояток, по иерархии вызовов; иногда, имея имя файла, мы открывали файл снова и передавали новую рукоятку; иногда имена складывалиь в глобальную переменную "имя открытого файла"; таких переменных было несколько - большая программа-то, все хотят а) кешировать, б) делиться знаниями.

Ну и теперь, по какой причине я так долго трахался с этой фигнёй? А отвык на самом деле.

Ну всё, щас я им всё поперелопачу. И логов присандалю, и ООП повпендюриваю, инкапсуляция, адхок полиморфизм, народность.

П.С. Кстати, и в реале менеджеры выполняют похожую роль, кешируют информацию и делятся ею; через пару лет у такого голова полна суеверий и сплетен, и сделать что-либо толковое можно только если ему не говорить. Ну если только он не лезет в твою компетенцию. Инкапсуляция.

Причём, в роли таких "кеширующих менеджеров" вполне может выступать и коллектив коллег (брр, это я Гугл вспоминаю, где мне не давали в джаваскрипте замыкания писать, табулировать списки параметров - аски арт запрещён, а также у них не было нигде места на серверах под 21к моего скрипта).

    public  T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
	System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

That's from Java's ArrayList class.

    private static StackTraceElement whereami(int i) {
        return Thread.currentThread().getStackTrace()[i];
    }

    public static int __LINE__() {
        return whereami(3).getLineNumber();
    }

    public static String __FILE__() {
        return whereami(3).getFileName();
    }

e.g.

        SysLog.debug("this is %s #%d", "message", 42);
        assertEquals("DEBUG  (" + __FILE__() + ":" + (__LINE__() - 1) + ") - this is message #42", log.toString());