Która sygnatura jest czytelniejsza i bardziej intuicyjna?

Jak w temacie. Dla nie Haskelowców: zapis F a c oznacza że F przymuje dwa typy generycne (kursywą bo w Haskelu mówi się o typach parametryzowanych, a nie o generykach).
Po Scallowemu byłoby to:

def myCompose[A,B,C](f1: F[B,C], f2: F[A,B]): F[A,C]
def myAndThen[A,B,C](f1: F[A,B], f2: F[B,C]): F[A,C] 

A po kotlinowemu pewniem cos w rodzaju:

fun myCompose<A,B,C>(f1: F<B,C>, f2: F<A,B>): F<A,C>
fun myAndThen<A,B,C>(f1: F<A,B>, f2: F<B,C>): F<A,C> 

Jak ktoś potrzebuje konkretniejszy przykład to można uznać że F[A,C] to Function1[A, C] czyli A => C
Wtedy pytanie upraszcza się czy wolimy compose czy andThen

def compose[A](g: (A) => T1): (A) => R
def andThen[A](g: (R) => A): (T1) => A

KamilAdam napisał(a):

Wtedy pytanie upraszcza się czy wolimy compose czy andThen

z tych dwóch kombinatorów wolę andThen :) bo się liniowo czyta

natomiast compose niejako sam wychodzi jak się ręcznie tworzy funkcję z kilku podfunkcji (i nie robi kroków pośrednich tylko przekazuje rezultat funkcji do innej funkcji), ale to nie jest użycie kombinatorów, więc się nie liczy w tym pytaniu. tzn. chodzi mi o:

val composed = (param: String) => {
  func1(func2(param)) // compose bez kombinatora
}

Jakiś przykład faktycznego użcia?

Riddle napisał(a):

Jakiś przykład faktycznego użcia?

A to coś zmienia jak będzie realne użycie?

Niech będzie https://hackage.haskell.org/package/base-4.18.0.0/docs/src/GHC.Base.html#line-1643

instance  Functor IO where
   fmap f x = x >>= (pure . f)

. to compose

Chociaż mogę tu wkleic kod wiely bibliotek Haskellowych

Wolisz

compose pure f
--wersha z lukrem składniowym
pure `compose` f 

czy

andThen f pure
--wersja z lukrem składniowym
f `andThen` pure

?

UPDATE o prosze, realny przykład z PureScripta https://stackoverflow.com/questions/46253149/how-do-you-compose-functions-in-purescript

import Data.String (length, trim)

trimmedLength :: String -> Int
trimmedLength = length <<< trim

lub

import Data.String (length, trim)

trimmedLength :: String -> Int
trimmedLength = trim >>> length

<<< to compose, a >>> to andThen

Dla mnie compose, bo compose w mojej głowie jednoznacznie kojarzy się z kompozycją funkcji natomiast andThen jest czasami używany jako monadowe flatMap (np. Optional/Option w C++/Rust).

Ale jak to w przypadku namingu bywa: wszystko zależy od nabytych doświadczeń a te są różne w zależności od tego kto i w czym pisał przez całe swoje życie