so applicative

and now I feel silly for not realising that in the previous PR

where’s

lift2

?

sorry, thinking from the haskell fp-course thing. might be in monad as liftM2 but lemme check

ok, we have lift in functor, but no more combinations because for liftN you need applicative because you use ap

easily defined though, maybe I'll add it if I can't find it anywhere

I would have thought it would have to be somewhere though, it's a pretty easy way to write traverse and sequence IIRC

👍🏼

fun <F, A, B, C> lift2(FA: Applicative<F>, f: (A) -> (B) -> C, a: Kind<F, A>, b: Kind<F, B>): Kind<F, C> {
  return FA.run { a.map { f(it) }.let { b.ap(it) } }
}

fun <L, R>rightCombine(SG: Semigroup<R>, a: Either<L, R>, b: Either<L, R>): Either<L, R> {
  val f = { xa: R -> { xb: R ->  SG.run { xa.combine(xb) } } }

  return lift2(Either.applicative(), f, a, b).fix()
}

looks correct

maybe was a mistake on my part to make L combine for either

Untitled.pl

do it that way inside Applicative instead

that way we get expression body, and syntactic sugar for functions

don’t curry, it’s not worth the extra syntax and allocation

👍

so hard to get used to using classes rather than functions

hahahaha it’s funny because it’s the opposite for me in OCaml

😛

OCaml's class system is rather nice 🙂

when I first read the yallop paper I gave it a shot to implement it in reason, made much more sense after building it, but the module system took a lot of getting my head around

makes it nice that that same learning applies to arrow

I find the classes a bolted-on feature in the language, we use them for visitors and using different syntax for the same concepts is a bit yucky

with modules my concern is when you have to make them match types. In Kotlin you do

interface Bla<T>: Ble<T>, Blu<T>

and that’s it. In OCaml you end up with monsters like

module Make_interval(Endpoint : sig
    type t
    include Comparable with type t := t
    include Core_kernel.Sexpable with type t := t
  end)
  : (Interval_intf_with_sexp with type endpoint := Endpoint.t)

still find it hard to get comfortable with the

module where t is this other t

thing to tie them together

half of those results are bogus too

lift2

looks like

map

to me

we do have those

comes like a tuple, but that’s fixable 😄