and add a new submenu entry above typeclasses

I don't know what the submenu entry should be called

I'd rather it wasn't called Syntax because that overlaps with another concept, but that's the name of the module

so I don't know really

we can have a syntax -> datatypes subsection to deal with the overlap

so maybe Syntax is the correct name

What's everyone's favorite tutorial for recursion schemes? I'm working on the arrow-recursion documentation intro and need some good examples to go off of.

I like the Domain Modeling with Haskell one

it builds up to it over 3 videos

which explains the problem perfectly

AAAAAAAAND my to watch list got bigger 😄

hahaha

those can be watched in 20 minutes max

@Aedan Smith Best talk from first principles: A great one with DB and model examples:

alright thanks

Thanks, I'll definitely use those as references.

This is ready for review https://github.com/arrow-kt/arrow/pull/825

👋

@jacob in the current KEEP proposal we are at a point where we can start with the POC which in its first approach looks like:

// type class
interface Monoid<A> {
  fun A.combine(b: A): A
  val empty: A
}
// instance
extension object IntMonoid : Monoid<Int> {
  fun Int.combine(b: Int): Int = this + b
  val empty: Int = 0
}

// polimorphic function or class that depends on `Monoid`
fun <A> add(a: A, b: A, with Monoid<A>): A = a.combine(b)
add(1, 1) // compiles
add("a", "b") // does not compile: No `Monoid<String>` instance defined in scope

add

may desugar to:

fun <A> add(a: A, b: A, $ev: Monoid<A>): A = $ev.run { a.combine(b) }

where scope is package scope for now?

or file scope?

the scope of available instances is currently determined by explicit imports

cool

So if you import

IntMonoid

at the final edge or concretion call site then it is available otherwise fails to compile.

You can carry over constrains without importing instances by simply keep on adding

with

to methods they use the type class.

The compiler already implements this kind of resolution

because today this is possible:

fun <A> Monoid<A>.add(a: A, b: A): A = a.combine(b)