Manabu Nakamura gakuzzzz

Validator に (validateToEither と同様な) validateToAp みたいなのを作らず ApplicativeValidator を別に用意したのは何故なんでしょう？
- validateToValidation みたいな謎な名前になってしまうから？
ApplicativeBuilder的な ComposingN があるので FunctionN に curried を持たせなくても良さそうですね（実装は泥臭くなりますがオブジェクト生成数を抑制できます）
- 逆にカリー化できる関数があると ComposingN のようなものを不要にできたりもします。
- とは言えYAVIのユースケースだと Validator からメソッドチェーンで使うのが主だと思うので、ComposingN の方が有用そうですね。
- 完全に余談ですが、カリー化できる FunctionN を別途定義するより、curried を static メソッドにすると curried(Foo::bar) みたいな使い方が可能になるので個人的にはそちらの方がお勧めです。（Functions 的な1クラスのoverloadですませられますし）
Validation<E, > の apply が Validation<List<E>, > を返すのがびっくりしますね。Applicative の挙動を期待するなら型としては Validation<E, > になるので。
YAVI の利用範囲から考えると、エラーの集約方法を汎用化する必要もなさそうなので、error は最初から List に決め打ちしちゃってもいいかもしれません。以下のようなイメージです。

Java Stream API で foldLeft/foldRight で宿題にした StackOverflow しない実装の一例です。

面白ポイントとしては、foldRight/foldLeft の実装差分は Function::compose/Function::andThen が Endo::compose/Endo::andThen に変わっただけ、という所ですね。

（注意）ただしこれは不変な List の concat を Stream を使って実装しているため、非常に遅いです。 高速な実装については読者への宿題とします。

https://twitter.com/cero_t/status/1305994285897011200 の話。

Map.of

Map<String, Integer> someKeyName2ValueName = new LinkedHashMap<>(Map.of(
    "foo", 10,
    "bar", 20,
    "baz", 30
));

前提

こちらのツイート https://twitter.com/matarillo/status/1302048512771645440 をみて foldMap か foldLeft で簡単に書けるのでは？と思ったのが発端

データ構造がこんな感じだとして

  case class OrganizationRecord(
    id: Long,
    organizationLv1: String,

class Foo[+A]
class Bar[-A]

class Test1[A] {
  def piyo(a: A): Unit = ???      // OK
  def poyo(a: Foo[A]): Unit = ??? // OK
  def puyo(a: Bar[A]): Unit = ??? // OK

 def paya(): A = ??? // OK

associateの例を Immutable Entity でどうするか

1:1:N ぐらいなら collect で何とでもなる

    Employee_ e = new Employee_();
    Task_ t = new Task_();
    Address_ a = new Address_();

 Map, Optional&gt;&gt; result = nativeql

利用シーン

val emps: Seq[Emp] = ...
val column = Emp.column
val (placeholders, batchParams) = createBatchParams {
  emps.map { emp =>
    Seq(
      column.id   -> emp.id,
      column.name -> emp.name

共通コード

public class EnumReverseLookup<E extends Enum<E>, ATTR> {

    private final Class<E> enumClass;
    private final Function<E, ATTR> getter;

    public EnumReverseLookup(final Class<E> enumClass, final Function<E, ATTR> getter) {
        this.enumClass = enumClass;

	object Sample {

	implicit def futureEitherTxBoundary[A, B](implicit ec: ExecutionContext): TxBoundary[Future[Either[A, B]]] = new TxBoundary[Future[Either[A, B]]] {

	def finishTx(result: Future[Either[A, B]], tx: Tx): Future[Either[A, B]] = {
	onFinishTx(result) {
	case Success(Right(_)) => tx.commit()
	case Success(Left(_)) => tx.rollback()
	case Failure(_) => tx.rollback()
	}

	package jp.t2v.lab;

	import java.util.function.Function;

	@FunctionalInterface
	public interface MyBiFunc<T, U, R> extends Function<T, Function<U, R>> {

	@Override
	default Function<U, R> apply(T t) {
	return u -> apply(t, u);