Спасать человека надо

не, ну потренироваться в point-free стоит

но писать в продакшн в поинт-фри нельзя

pointfree.io можно, в качестве бекапа, использовать

ты посмотри, работает

Как так центр схлопывается? (int -> int)  >> (int -> int) заменяется на int -> int, нет?

сигнатура >> :: (a -> b) -> (b -> c) -> (a -> c)

берёт функцию из А в Б
объединяет её с функцией из Б в С
и отдаёт функцию сразу из А в С схлопывая Б

int -> (int -> int)  >> (int -> int) -> (int -> int)

вот тут есть функция которая слева из int в (int -> int)
и функция справа из (int -> int) в (int -> int)

точно так же, композиция схлопывает ненужный центр (int -> int) и отдаёт тебе итоговую функцию
из  int в (int -> int)
что равносильно int -> int -> int

Bruh…

Разрыв башки конечно, спасибо, вроде понятно

Это все игрища математиков. Есть разные способы собирать из существующих функций новые. Айрат показал тебе один способ, который прям сильно прижился в функциональных языках из-за его практичности. Есть и другой способ, например то как Черч определяет композицию для его примитивной рекурсии. Во всех таких случаях важен тип функции, конкретика множеств на которых она определена, а все остальное это как правило элементарное склеивание — одна строчка кода.

a -> b и b -> c склеить легко при условии, что они определены для всех элементов типа a и типа b. Если не определены, то в программировании можно хотя бы исключение выкинуть, в математике исключение стэк не пробивает потому что стэка нет.

ну вот в жирафе (а это уже продакшн!) используется гораздо более полезный вид композиции - композиция функторов. Она же композиция Кляйзли

(a -> Monad<b>) -> (b -> Monad<c>) -> (a -> Monad<c>)

чтобы её понять обычную точно надо всосать.

Все будет проще если добавить Monad[a] -> a в промежутках сугубо ради понимания :)

в доке жирафа кстати хорошо расписано. Помогает понять АспНетКор очень сильно
https://github.com/giraffe-fsharp/Giraffe/blob/master/DOCUMENTATION.md#httphandler

Говорят, что Giraffe был вдохновлён концептами из Suave. Посмотрел я на сурсы второго, и что-то не понял где именно там схожесть.

В жирафе всё строится на этой троице:

type HttpFuncResult = Task<HttpContext option>
type HttpFunc = HttpContext -> HttpFuncResult
type HttpHandler = HttpFunc -> HttpContext -> HttpFuncResult

Что, в целом, практически аналогично асповским миддлварям.

Тогда как в суаве (или как это правильно читается), как я понял, в основе лежит это:

type WebPart<'a> = 'a -> Async<'a option>
type WebPart = WebPart<HttpContext>

Но ведь это же жирафовский HttpFunc! Не HttpHandler. Получается, у них нет next, у них всё на этом работает. Как так?

И вот эту разницу не могу понять. В чём плюсы и минусы обоих подходов?

Наверное suave не нужен handler, тк они используют ленивую Async

Суаве это полноценный веб сервер если что, который можно поднять одной строкой (кестрел так не поднимается).

Жираф полностью спиздил синтаксис и идею композиции хендлеров из суаве, но натянул эту идею поверх готового аспнеткора

Вот это суаве


let myApp =
 choose [
   GET >=> choose
     [ path "/hello" >=> OK "Hello GET" ; path "/goodbye" >=> OK "Good bye GET" ];
   POST >=> choose
     [ path "/hello" >=> OK "Hello POST" ; path "/goodbye" >=> OK "Good bye POST" ];
   DELETE >=> choose
     [ path "/hello" >=> OK "Hello DELETE" ; path "/goodbye" >=> OK "Good bye DELETE" ];
   PUT >=> choose
     [ path "/hello" >=> OK "Hello PUT" ; path "/goodbye" >=> OK "Good bye PUT" ];
 ]

Вот только нет такой функции