mskoroglu

package com.mustafakoroglu.gist.virtualfuture;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.function.Supplier;
import java.util.stream.StreamSupport;

mskoroglu

/**
 * A functional interface for use cases with an input of type {@code Q} and an output of type {@code S}.
 * It extends {@code java.util.function.Function} to provide functional interface compatibility.
 *
 * @param <Q> the type of the request
 * @param <S> the type of the response
 */
@FunctionalInterface
public interface UseCase<Q, S> extends java.util.function.Function<Q, S> {
  /**

mskoroglu

public abstract class EventHandler<E extends Event> {

  @SafeVarargs
  protected EventHandler(final E... reifiedTypeArray) {
    if (reifiedTypeArray.length > 0) {
      throw new IllegalArgumentException();
    }
    final var reifiedType = reifiedTypeArray.getClass().getComponentType();
    EventBus.registerHandler((Class<? extends Event>) reifiedType, this);
  }

mskoroglu

fun table(block: Table.() -> Unit): Table {
    val table = Table()
    table.block()
    return table
}

class Table : Iterable<Row>, WithMetadataFilter<Row> {
    private val rows = hashSetOf<Row>()

    fun row(index: Int? = null, block: Row.() -> Unit): Row {

mskoroglu

/**
 * Usage
 * ```ts
 * const person = { name: "John", surname: "Doe", age: 35 };
 * console.log(pick(person, "surname", "age"));
 * ```
 * 
 * Result
 * ```json
 * { surname: 'Doe', age: 35 }

mskoroglu

export default class Optional<T> {
  private static readonly EMPTY = new Optional(null);

  private readonly value: T | null;

  private constructor(value: T | null) {
    this.value = value;
  }

  public static empty<T>(): Optional<T> {

mskoroglu

version: '3'

volumes:
  pg_0_data:
    driver: local
  pg_1_data:
    driver: local

services:
  pg-0:

mskoroglu

import "reflect-metadata";
import {
  Connection,
  createConnection,
  EntityTarget,
  getConnectionManager,
  Repository,
} from "typeorm";
import { Post } from "./posts/Post";

mskoroglu

// Example: cities.sortedWithLocaleBy(Locale("tr")) { it.name }
inline fun <T, R : Comparable<R>> Iterable<T>.sortedWithLocaleBy(
        locale: java.util.Locale,
        crossinline selector: (T) -> R?
) = sortedWith(compareBy(java.text.Collator.getInstance(locale), selector))

// Example: cities.sortedWithLocaleByDescending(Locale("tr")) { it.name }
inline fun <T, R : Comparable<R>> Iterable<T>.sortedWithLocaleByDescending(
        locale: java.util.Locale,
        crossinline selector: (T) -> R?

mskoroglu

import React from "react";
import { withState, multiState } from "./multi-state";

const Input = ({ state, ...props }) => (
  <input
    value={state.value}
    onChange={e => state.setValue(e.target.value)}
    {...props}
  />
);