IvanVergiliev

val andPredicates: Array[Column] = parseAndPredicates(...)
val compositePredicate: Column = andPredicates.foldLeft(lit(true))((x, y) => x && y)

IvanVergiliev

f(H) =
  f(H - 1) // for the first transform call
  +
  f(H - 1) // for the second transform call
= 2 * f(H - 1) =
= 2 * 2 * f(H - 2) = ... = 2 ^ (H - 1) * f(1) // unfolding further

IvanVergiliev

import org.apache.spark.sql.Column

def treeFold(
  columns: List[Column],
  initialValue: Column,
  op: (Column, Column) => Column
): Column = {
  if (columns.isEmpty) {
    initialValue
  } else if (columns.length == 1) {

IvanVergiliev

def transformTree(tree: Tree): Option[Tree] = {
  // Notice that there's no `canTranform` - we're using
  // `transform().isDefined` to check for transformability!
  val transformedLeft = if (transform(tree.left).isDefined) {
    transform(tree.left)
  } else None
  
  ...
}

IvanVergiliev

def transformTree(tree: Tree): Option[Tree] = {
  val transformedLeft = if (canTransform(tree.left)) {
    transform(tree.left)
  } else None
  
  val transformedRight = if (canTransform(tree.right)) {
    transform(tree.right)
  } else None
  
  val result = if (transformedLeft.isDefined && transformedRight.isDefined) {

IvanVergiliev

#include <cstdlib>

#include <string>

// All of the below are not really standards-compliant, but good enough
// for experiments.
void* operator new(std::size_t size) {
  printf("Calling new(%zu).\n", size);
  return std::malloc(size);
}

IvanVergiliev

package io.github.ivanvergiliev;

public class NonVolatileFlag {
  private static boolean flag = false;

  public static class FlagChecker implements Runnable {
    public void run() {
      long iter = 0;
      while (flag == false) {
        ++iter;

IvanVergiliev

#include <cstdio>

#include <array>

using std::array;

const int MOD = 1000;

class ArrayWrapper {
  const array<int, 2>& value;

IvanVergiliev

var HelloMessage = React.createClass({
  render: function() {
    return <script>function f() { var a = 5; }</script>;
  }
});

IvanVergiliev

#include <cstdio>

template<typename First, typename... Rest>
struct Tuple: public Tuple<Rest...> {
  Tuple(First first, Rest... rest): Tuple<Rest...>(rest...), first(first) {}

  First first;
};

template<typename First>