so there will be fewer `fix()` and `sequence(Eithe...

# arrow

[pakoito]

so there will be fewer fix() and sequence(Either.applicative()) needed all around. Ideally not at all 🙂

[dcampogiani]

I did not see the talk (yet), there will be automatic resolution of instances ?

[pakoito]

ye, OptionOf will be considered the same as Option by the typechecker if I understood correctly

[dcampogiani]

so if i write a method accepting

Kind<F,Int>, Kind<F,Int>, Applicative<F>

I can avoid passing for example Option.applicative as last parameter? And just pass two instances of Option<Int>

[dcampogiani]

?

[dcampogiani]

Untitled

[dcampogiani]

and invoke as

[dcampogiani]

Untitled

[dcampogiani]

?

[pakoito]

applicative: Applicative<F> = with)

[pakoito]

ye

[dcampogiani]

Thank you paco

[dcampogiani]

Sometime I miss when Kategory was using default parameters such as:

(…., Functor<F> = functor() )

[dcampogiani]

with reified and a global map for lookup

[pakoito]

oh yes

[pakoito]

the good old days

[pakoito]

so broken

[pakoito]

hahaha

[Pagoda 5b]

so, let me understand this better… how does the with default provides the actual instance?

[Pagoda 5b]

I expect to be imports needed, for proper extensions?

[Pagoda 5b]

@pakoito @dcampogiani

[pakoito]

I believe it’s called given now

[pakoito]

the instances are unique per type, enforced at compile time

[pakoito]

so there’s no imports, and there’re no possible suprises of malicious instances

[pakoito]

the instances HAVE TO be defined either where the datatype is defined, or where the interface is defined

[pakoito]

(I may need to check the latest version but AFAIK imports were not needed)

[Pagoda 5b]

is given a polymorphic instance, then?? how comes?

[pakoito]

object given: Nothing

[pakoito]

the compiler plugin uses it as a marker

[pakoito]

typechecks the other side of the assignment

[pakoito]

and finds the right instance

[pakoito]

it was either that or an @annotation

[Pagoda 5b]

ohh, that’s what Raul was talking about yesterday… is it macro based?

[Pagoda 5b]

sorry to bugger you

[Pagoda 5b]

please ignore me if you want

[pakoito]

you’re not bugging

[pakoito]

if by macro you mean compiler extension then yes

[Pagoda 5b]

I meant arrow-meta

[pakoito]

it’s a plugin

[pakoito]

meta has a bit of everything you need for metaprogramming, including a templating engine

[Pagoda 5b]

actually I made a brain-short-circuit with scala, where scala-meta == macros… 😛

[pakoito]

which I guess is like macros

[Pagoda 5b]

this is getting so streamlined, really like magic

[Pagoda 5b]

thanks for the details

[pakoito]

I hope it doesn’t get as magic as AOP xD

[pakoito]

it’s as simple as typecheck the left side of the assignment and see if it’s on the global injection module

[pakoito]

classic @Inject pattern

[pakoito]

dagger can do this because behind the scenes it’s doing all the parsing and typechecking

[pakoito]

we’re just moving it to the compiler

[pakoito]

so you don’t have to double the work, and also get IDE features, incrementality, compiler errors…the good stuff

[Pagoda 5b]

So the inference is global, and you have to make instances globally coherent, right?

[pakoito]

yep

[pakoito]

no orphan instances

[pakoito]

and overrides have to be explicit

[pakoito]

sequence(MyUnlawfulInstance)

[Pagoda 5b]

where do I find some blog article/series or presentations on the approach, to have a better idea than reverse engineering the docs?

[pakoito]

look for the keep87 talks

[pakoito]

and the design doc

[pakoito]

it's just an implementation of that

[Pagoda 5b]

👍