From the demos, it appears Arrow Meta will display ‘aliases' of types in IntelliJ, eg. showing ‘`Union2<A|B>``, and I really like this feature because it makes the language way easier to read but doesn't change the syntax at all so it's quite safe. I would love if this was expanded to other boilerplate, for example to replace function composition by ∘ (

val h = g ∘ f)

. In Julia, they actually define many functions as unicode directly, I think it's a good compromise to just let the IDE display those as such. What do you think?

How can I print messages from a meta compiler plugin so that I can see them during compilation? Simple println() didn't work...

Hey, I am curious if the source of demos you have presented on Kotliners (or similar) is available somewhere, would be amazing to check it out!

Where can I read up on Coercion Projection and Liquid Types ? as they will be used in ArrowMeta @raulraja

Hello, is there an API for rename refactor of a PsiElement? Basically to rename a property and update its usages or the only way is to do that manually?

Hi. How do I get 

//metadebug

 -annotated classes to be displayed on compilation? is there some compiler switch or something? I cloned the arrow-meta-examples project but nothing gets printed into compiler output even though 

//metadebug

  is clearly there

In the type proofs demo of the Twitter username, the casts returned nullables to model that a String was not a valid Twitter username. Wouldn't it be better if it returned a

Validated

, so it's possible to get the reason why it failed?

@raulraja @simon.vergauwen i noticed that

lenses

plugin in meta is commented out, not sure what the reason is. i've experimented with adding support for type parameters on case classes (wrt lenses): usage https://github.com/tkroman/poptix/blob/master/poptix-gradle-plugin-test/src/main/kotlin/com/tkroman/poptix/PoptixExample.kt#L13 src https://github.com/tkroman/poptix/blob/master/poptix-gradle-plugin/src/main/kotlin/com/tkroman/poptix/PoptixTransformation.kt#L85 does this look like something useful for the mainline? i'm not really confident about the quality of implementation but would love to help out (with proper guidance) if you would accept this contribution

Hi guys, I was wondering how I should learn about functional programming. Do you guys have any recommendations? A good book perhaps? Course? How do I start? Should I study Category Theory first? Thank you very much

Could be arrow meta also used to resolve instance of Kotlinx.Serialization (some context in comments) at compile time?

I’m trying to mess around with arrow-meta on one of my other projects (I wanted to try some of the stuff from the ArrowFx and Meta talk that @raulraja and @simon.vergauwen did) but when I try to follow the example here https://github.com/arrow-kt/arrow-meta-examples/blob/master/use-arrow-meta-compiler-plugin/build.gradle I get compilation errors. A section from my build.gradle which I think contains everything from that example

buildscript {
    repositories {
        maven {
            url '<https://oss.jfrog.org/artifactory/oss-snapshot-local/>'
        }
    }
    dependencies {
        classpath "io.arrow-kt:gradle-plugin:1.3.61-SNAPSHOT"
    }
}

plugins {
    id "org.jetbrains.kotlin.jvm" version "1.3.61"
    id "org.jetbrains.kotlin.plugin.jpa" version "1.3.61"
    id "org.jetbrains.kotlin.plugin.spring" version "1.3.61"
    id "org.springframework.boot" version "2.1.7.RELEASE"
    id "com.adarshr.test-logger" version "2.0.0"
}

apply plugin: "java"
apply plugin: "war"
apply plugin: "kotlin"
apply plugin: "kotlin-spring"
apply plugin: "kotlin-jpa"
apply plugin: "kotlin-kapt"
apply plugin: "org.springframework.boot"
apply plugin: "io.spring.dependency-management"
apply plugin: "jacoco"
apply plugin: "io.arrow-kt.arrow"

repositories {
    jcenter()
    mavenCentral()
    maven { url "<https://splunk.jfrog.io/splunk/ext-releases-local>" }
    maven { url "<https://dl.bintray.com/arrow-kt/arrow-kt/>" }
    maven {
        url '<https://oss.jfrog.org/artifactory/oss-snapshot-local/>'
    }
}
dependencies {
    ...other dependencies 
    // Arrow
    implementation Dependencies.ArrowOptics
    implementation Dependencies.ArrowSyntax
    implementation Dependencies.ArrowFx
    kapt Dependencies.ArrowMeta
    compileOnly "io.arrow-kt:arrow-meta-prelude:1.3.61-SNAPSHOT"
}

The error message doesn’t seem super useful to me, but am I making a common mistake here or any suggestions on how to debug this? Thanks!

Hello there! I’m wanna to contribute, from which i can start?

Do expect behavior if the Gradle buildMeta task launch fails with test passing errors?

Does Arrow Meta in Kotlin 1.4 mean that all

.fix()

and

.k()

calls will be unnecessary?

Is the source code for the keep-87 plugin available anywhere? cuz IIRC it's based on Arrow Meta, right? I wanted to draw some inspiration from it to make a compiler plugin myself, but the only plugins in the arrow meta plugin package seem to be the higherkind, proof, optics, etc. ones, but not the typeclasses/extension interfaces one.

anything I could do? 🤔

Hey guys, maybe you know Something: is there any news, discussion or whatever regarding the support for bundled ide plugins with compiler plugins, so that the user doesn't need to install ide Support manually?

Is there a snapshot version available of the gradle plugin for 1.4 yet? or even for one of the M versions? The only one that I can see is for 1.3.61

Hey ho, i recently tested the "given" construct (however it is called now) with meta compiler plugin, which is SO nice, this is so much what kotlin needs for type extensions :) However, i found sth i am not sure whether i misunderstood it or not. When i have an interface over a type T and two implementations as top level object, it always resolves to the first declared instance, even though the generic type should prevent that. Is this expected? I could give my example when it's not clear what i mean.

Arrow meta itself is multiplatform, right? but the arrow-meta-prelude, which has all the annotations for some of the plugins like the type proofs one and also all the Union classes and stuff, is JVM only. Is this intentional, or just a slight oversight? and are there any plans to make it mp? because it looks like there isn't really anything JVM specific in the prelude.

Hi everyone! I have a question about the resolving step in the kotlin compiler plugin. I try to use arrow meta to develop a plugin, but I am not sure how can I get a fully qualified name. I have found a good example in addition to the hello world example for getting started, but if I right understand it works during the parsing step and I can not get the fully qualified name like

io.arrowkt.example.MyObject

instead of a short one like

MyObject

. I use

dotQualifiedExpression

in meta param. My final goal is to find a dotQualifiedExpression like

MyObject.myFunction

and get all children if it is possible. For example, if I found

MyObject.myFunction

and originally it is 

MyObject.myFunction.children

, I would like to get all children and I would like to be sure it is MyObject from

io.arrowkt.example.MyObject

. Could you help me, please?

Hi everyone again! Sorry for my newbie question, but I can not find the place where

MessageCollector

writes the messages (the filed of

CompilerContext

). Maybe I did not understand clearly, but the

arrow meta

uses

NONE

MessageCollector, which does nothing. Can I override it? I would like to receive my logs. I tried to run the @raulraja example with

bindingContext

:

val Meta.example: CliPlugin
    get() =
        "Hello World" {
            meta(
                analysis(
                    doAnalysis = { project, module, projectContext, files, bindingTrace, componentProvider ->
                        null
                    },
                    analysisCompleted = { project, module, bindingTrace, files ->
                        val slice: ImmutableMap<PsiElement, DeclarationDescriptor> =
                            bindingTrace.bindingContext.getSliceContents(BindingContext.DECLARATION_TO_DESCRIPTOR)
                        slice.forEach { (psi, descriptor) ->
                            if (psi is KtProperty && descriptor is PropertyDescriptor) {
                                messageCollector?.report(
                                    CompilerMessageSeverity.WARNING,
                                    "${psi.text} -> Type: ${descriptor.returnType}"
                                )
                            }
                        }
                        null
                    }
                )
            )
        }

Since meta is still in 1.3.61-snapshot, does that mean we can't use it with Kotlin 1.4 yet?

Hi! I've asked this question about the different implementation/use-cases of typeclasses in Kotlin, and Mr. Raja redirected me to here to discuss those. Please tell me if I'm not making sense, it's a quite new concept to me ^^

Is it possible to evaluate a non

const

property of a companion object at compile time?

I can't use Kotlin 1.3.70 because of Arrow Meta, so I'm stuck with Kotlin serialization 0.16.0 which is mostly undocumented and I don't know how to write some more-than-basic custom serializers... I hope you will be able to switch to Kotlin 1.4.0 soon.

Hi there! Is it possible to process non-kt files during compilation? I would like to provide types from files such as open api specification. Can think of 2 possible ways to do it: gradle plugin and compiler plugin. Gradle clearly has access to resource files in source sets, but lacks syntax and semantics checks, and it is less obvious how to provide IDEA support. As for compiler, i really have no clue :(