Possible followedBy operator

FollowedBy.kt

// followedBy operator definition

@JvmName("pureFollowedByAny")
infix fun <A, B, C> ((A) -> B).followedBy(f: (B) -> C): (A) -> C = { a -> f(this(a)) }

@JvmName("effFollowedByPure")
infix fun <R, E, A, B, C> ((A) -> KIO<R, E, B>).followedBy(f: (B) -> C): (A) -> KIO<R, E, C> = { a -> this(a).map(f) }

@JvmName("effFollowedByEff")
infix fun <R, E, A, B, C> ((A) -> KIO<R, E, B>).followedBy(f: (B) -> KIO<R, E, C>): (A) -> KIO<R, E, C> = { a -> this(a).flatMap(f) }

// Example usage

class ApiRequest
class ApiResponse
object BadRequest

inline class Author(val name: String)
data class Book(val title: String)

fun authorFromApiRequest(request: ApiRequest): IO<BadRequest, Author> = TODO()

fun retrieveBooksForAuthor(author: Author): UIO<List<Book>> = TODO()

fun filterOnlyCoAuthoredBooks(bs: List<Book>): List<Book> = TODO()

fun sortByDate(bs: List<Book>): List<Book> = TODO()

fun adaptForApiResponse(bs: IO<BadRequest, List<Book>>): ApiResponse = TODO()

val useCase: (ApiRequest) -> ApiResponse = (
        ::authorFromApiRequest
                followedBy ::retrieveBooksForAuthor
                followedBy ::filterOnlyCoAuthoredBooks
                followedBy ::sortByDate
                followedBy ::adaptForApiResponse
        )

If you can find a clever way to make followedBy look like a pipe, you just created pipes in kotlin.

Yes that's what I'm trying to achieve!