Skip to content

Commit 08fca16

Browse files
tanishikingtanishiking
committed
feat: [SemanticDB] support LambdaType (convert from HKTypeLambda)
scalameta/scalameta#2867 This commit adds support for LambdaType that is converted from HKTypeLambda in Scala3.
1 parent efb7b6e commit 08fca16

File tree

6 files changed

+270
-7
lines changed

6 files changed

+270
-7
lines changed

‎compiler/src/dotty/tools/dotc/semanticdb/PPrint.scala

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -196,6 +196,10 @@ class SymbolInformationPrinter (symtab: PrinterSymtab):
196196
s"${pprint(caseType.key)} => ${pprint(caseType.body)}"
197197
}.mkString(", ")
198198
s"${pprint(scrutinee)} match { ${casesStr} }"
199+
case LambdaType(tparams, res) =>
200+
val params = tparams.infos.map(_.displayName).mkString("[", ", ", "]")
201+
val resType = normal(res)
202+
s"$params =>> $resType"
199203
case x =>
200204
"<?>"
201205

‎compiler/src/dotty/tools/dotc/semanticdb/TypeOps.scala

Lines changed: 17 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -483,9 +483,23 @@ class TypeOps:
483483
case NoPrefix =>
484484
s.Type.Empty
485485

486-
// Not yet supported
487-
case _: HKTypeLambda =>
488-
s.Type.Empty
486+
case lambda: HKTypeLambda =>
487+
val paramSyms: List[SemanticSymbol] = lambda.paramNames.zip(lambda.paramInfos).map { (paramName, bounds) =>
488+
// def x[T[_]] = ???
489+
if paramName.isWildcard then
490+
WildcardTypeSymbol(sym, bounds).tap(registerFakeSymbol)
491+
else
492+
paramRefSymtab.lookup(lambda, paramName).getOrElse {
493+
TypeParamRefSymbol(sym, paramName, bounds).tap(registerFakeSymbol)
494+
}
495+
}
496+
val parameters =
497+
paramSyms.sscopeOpt(using LinkMode.HardlinkChildren)
498+
val resType = loop(lambda.resType)
499+
s.LambdaType(
500+
parameters,
501+
resType
502+
)
489503

490504
case tvar: TypeVar =>
491505
loop(tvar.stripped)

‎compiler/src/dotty/tools/dotc/semanticdb/generated/Type.scala

Lines changed: 130 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,7 @@ object Type {
3939
case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ByNameType => __v.value
4040
case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.RepeatedType => __v.value
4141
case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.MatchType => __v.value
42+
case __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.LambdaType => __v.value
4243
case dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.Empty => Empty
4344
}
4445
override def toBase(__custom: dotty.tools.dotc.semanticdb.Type): dotty.tools.dotc.semanticdb.TypeMessage = dotty.tools.dotc.semanticdb.TypeMessage(__custom match {
@@ -57,6 +58,7 @@ object Type {
5758
case __v: dotty.tools.dotc.semanticdb.ByNameType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.ByNameType(__v)
5859
case __v: dotty.tools.dotc.semanticdb.RepeatedType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.RepeatedType(__v)
5960
case __v: dotty.tools.dotc.semanticdb.MatchType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.MatchType(__v)
61+
case __v: dotty.tools.dotc.semanticdb.LambdaType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.LambdaType(__v)
6062
case Empty => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.Empty
6163
})
6264
}
@@ -129,6 +131,10 @@ final case class TypeMessage(
129131
val __value = sealedValue.matchType.get
130132
__size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
131133
};
134+
if (sealedValue.lambdaType.isDefined) {
135+
val __value = sealedValue.lambdaType.get
136+
__size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
137+
};
132138
__size
133139
}
134140
override def serializedSize: _root_.scala.Int = {
@@ -231,6 +237,12 @@ final case class TypeMessage(
231237
_output__.writeUInt32NoTag(__m.serializedSize)
232238
__m.writeTo(_output__)
233239
};
240+
sealedValue.lambdaType.foreach { __v =>
241+
val __m = __v
242+
_output__.writeTag(26, 2)
243+
_output__.writeUInt32NoTag(__m.serializedSize)
244+
__m.writeTo(_output__)
245+
};
234246
}
235247
def getTypeRef: dotty.tools.dotc.semanticdb.TypeRef = sealedValue.typeRef.getOrElse(dotty.tools.dotc.semanticdb.TypeRef.defaultInstance)
236248
def withTypeRef(__v: dotty.tools.dotc.semanticdb.TypeRef): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.TypeRef(__v))
@@ -262,6 +274,8 @@ final case class TypeMessage(
262274
def withRepeatedType(__v: dotty.tools.dotc.semanticdb.RepeatedType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.RepeatedType(__v))
263275
def getMatchType: dotty.tools.dotc.semanticdb.MatchType = sealedValue.matchType.getOrElse(dotty.tools.dotc.semanticdb.MatchType.defaultInstance)
264276
def withMatchType(__v: dotty.tools.dotc.semanticdb.MatchType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.MatchType(__v))
277+
def getLambdaType: dotty.tools.dotc.semanticdb.LambdaType = sealedValue.lambdaType.getOrElse(dotty.tools.dotc.semanticdb.LambdaType.defaultInstance)
278+
def withLambdaType(__v: dotty.tools.dotc.semanticdb.LambdaType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.LambdaType(__v))
265279
def clearSealedValue: TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.Empty)
266280
def withSealedValue(__v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue): TypeMessage = copy(sealedValue = __v)
267281

@@ -311,6 +325,8 @@ object TypeMessage extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc
311325
__sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.RepeatedType(__sealedValue.repeatedType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.RepeatedType](_input__))(LiteParser.readMessage(_input__, _)))
312326
case 202 =>
313327
__sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.MatchType(__sealedValue.matchType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.MatchType](_input__))(LiteParser.readMessage(_input__, _)))
328+
case 210 =>
329+
__sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.LambdaType(__sealedValue.lambdaType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.LambdaType](_input__))(LiteParser.readMessage(_input__, _)))
314330
case tag => _input__.skipField(tag)
315331
}
316332
}
@@ -345,6 +361,7 @@ object TypeMessage extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc
345361
def isByNameType: _root_.scala.Boolean = false
346362
def isRepeatedType: _root_.scala.Boolean = false
347363
def isMatchType: _root_.scala.Boolean = false
364+
def isLambdaType: _root_.scala.Boolean = false
348365
def typeRef: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeRef] = _root_.scala.None
349366
def singleType: _root_.scala.Option[dotty.tools.dotc.semanticdb.SingleType] = _root_.scala.None
350367
def thisType: _root_.scala.Option[dotty.tools.dotc.semanticdb.ThisType] = _root_.scala.None
@@ -360,6 +377,7 @@ object TypeMessage extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc
360377
def byNameType: _root_.scala.Option[dotty.tools.dotc.semanticdb.ByNameType] = _root_.scala.None
361378
def repeatedType: _root_.scala.Option[dotty.tools.dotc.semanticdb.RepeatedType] = _root_.scala.None
362379
def matchType: _root_.scala.Option[dotty.tools.dotc.semanticdb.MatchType] = _root_.scala.None
380+
def lambdaType: _root_.scala.Option[dotty.tools.dotc.semanticdb.LambdaType] = _root_.scala.None
363381
}
364382
object SealedValue {
365383
@SerialVersionUID(0L)
@@ -476,6 +494,13 @@ object TypeMessage extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc
476494
override def matchType: _root_.scala.Option[dotty.tools.dotc.semanticdb.MatchType] = Some(value)
477495
override def number: _root_.scala.Int = 25
478496
}
497+
@SerialVersionUID(0L)
498+
final case class LambdaType(value: dotty.tools.dotc.semanticdb.LambdaType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue derives CanEqual {
499+
type ValueType = dotty.tools.dotc.semanticdb.LambdaType
500+
override def isLambdaType: _root_.scala.Boolean = true
501+
override def lambdaType: _root_.scala.Option[dotty.tools.dotc.semanticdb.LambdaType] = Some(value)
502+
override def number: _root_.scala.Int = 26
503+
}
479504
}
480505
final val TYPE_REF_FIELD_NUMBER = 2
481506
final val SINGLE_TYPE_FIELD_NUMBER = 20
@@ -492,6 +517,7 @@ object TypeMessage extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc
492517
final val BY_NAME_TYPE_FIELD_NUMBER = 13
493518
final val REPEATED_TYPE_FIELD_NUMBER = 14
494519
final val MATCH_TYPE_FIELD_NUMBER = 25
520+
final val LAMBDA_TYPE_FIELD_NUMBER = 26
495521
def of(
496522
sealedValue: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue
497523
): _root_.dotty.tools.dotc.semanticdb.TypeMessage = _root_.dotty.tools.dotc.semanticdb.TypeMessage(
@@ -2034,3 +2060,107 @@ object MatchType extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.s
20342060
)
20352061
// @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.MatchType])
20362062
}
2063+
2064+
@SerialVersionUID(0L)
2065+
final case class LambdaType(
2066+
parameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None,
2067+
returnType: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.LambdaType._typemapper_returnType.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
2068+
) extends dotty.tools.dotc.semanticdb.Type.NonEmpty with SemanticdbGeneratedMessage derives CanEqual {
2069+
@transient @sharable
2070+
private[this] var __serializedSizeMemoized: _root_.scala.Int = 0
2071+
private[this] def __computeSerializedSize(): _root_.scala.Int = {
2072+
var __size = 0
2073+
if (parameters.isDefined) {
2074+
val __value = parameters.get
2075+
__size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
2076+
};
2077+
2078+
{
2079+
val __value = dotty.tools.dotc.semanticdb.LambdaType._typemapper_returnType.toBase(returnType)
2080+
if (__value.serializedSize != 0) {
2081+
__size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
2082+
}
2083+
};
2084+
__size
2085+
}
2086+
override def serializedSize: _root_.scala.Int = {
2087+
var __size = __serializedSizeMemoized
2088+
if (__size == 0) {
2089+
__size = __computeSerializedSize() + 1
2090+
__serializedSizeMemoized = __size
2091+
}
2092+
__size - 1
2093+
2094+
}
2095+
def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
2096+
parameters.foreach { __v =>
2097+
val __m = __v
2098+
_output__.writeTag(1, 2)
2099+
_output__.writeUInt32NoTag(__m.serializedSize)
2100+
__m.writeTo(_output__)
2101+
};
2102+
{
2103+
val __v = dotty.tools.dotc.semanticdb.LambdaType._typemapper_returnType.toBase(returnType)
2104+
if (__v.serializedSize != 0) {
2105+
_output__.writeTag(2, 2)
2106+
_output__.writeUInt32NoTag(__v.serializedSize)
2107+
__v.writeTo(_output__)
2108+
}
2109+
};
2110+
}
2111+
def getParameters: dotty.tools.dotc.semanticdb.Scope = parameters.getOrElse(dotty.tools.dotc.semanticdb.Scope.defaultInstance)
2112+
def clearParameters: LambdaType = copy(parameters = _root_.scala.None)
2113+
def withParameters(__v: dotty.tools.dotc.semanticdb.Scope): LambdaType = copy(parameters = Option(__v))
2114+
def withReturnType(__v: dotty.tools.dotc.semanticdb.Type): LambdaType = copy(returnType = __v)
2115+
2116+
2117+
2118+
2119+
// @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.LambdaType])
2120+
}
2121+
2122+
object LambdaType extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LambdaType] {
2123+
implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LambdaType] = this
2124+
def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.LambdaType = {
2125+
var __parameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None
2126+
var __returnType: _root_.scala.Option[dotty.tools.dotc.semanticdb.TypeMessage] = _root_.scala.None
2127+
var _done__ = false
2128+
while (!_done__) {
2129+
val _tag__ = _input__.readTag()
2130+
_tag__ match {
2131+
case 0 => _done__ = true
2132+
case 10 =>
2133+
__parameters = Option(__parameters.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Scope](_input__))(LiteParser.readMessage(_input__, _)))
2134+
case 18 =>
2135+
__returnType = _root_.scala.Some(__returnType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.TypeMessage](_input__))(LiteParser.readMessage(_input__, _)))
2136+
case tag => _input__.skipField(tag)
2137+
}
2138+
}
2139+
dotty.tools.dotc.semanticdb.LambdaType(
2140+
parameters = __parameters,
2141+
returnType = dotty.tools.dotc.semanticdb.LambdaType._typemapper_returnType.toCustom(__returnType.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance))
2142+
)
2143+
}
2144+
2145+
2146+
2147+
2148+
2149+
2150+
lazy val defaultInstance = dotty.tools.dotc.semanticdb.LambdaType(
2151+
parameters = _root_.scala.None,
2152+
returnType = dotty.tools.dotc.semanticdb.LambdaType._typemapper_returnType.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
2153+
)
2154+
final val PARAMETERS_FIELD_NUMBER = 1
2155+
final val RETURN_TYPE_FIELD_NUMBER = 2
2156+
@transient @sharable
2157+
private[semanticdb] val _typemapper_returnType: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type] = implicitly[SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.TypeMessage, dotty.tools.dotc.semanticdb.Type]]
2158+
def of(
2159+
parameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope],
2160+
returnType: dotty.tools.dotc.semanticdb.Type
2161+
): _root_.dotty.tools.dotc.semanticdb.LambdaType = _root_.dotty.tools.dotc.semanticdb.LambdaType(
2162+
parameters,
2163+
returnType
2164+
)
2165+
// @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LambdaType])
2166+
}

‎tests/semanticdb/expect/hk.expect.scala

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
package hk
2+
3+
trait Monad/*<-hk::Monad#*/[M/*<-hk::Monad#[M]*/[_]] {
4+
def pure/*<-hk::Monad#pure().*/[A/*<-hk::Monad#pure().[A]*/](a/*<-hk::Monad#pure().(a)*/: A/*->hk::Monad#pure().[A]*/): M/*->hk::Monad#[M]*/[A/*->hk::Monad#pure().[A]*/] = ???/*->scala::Predef.`???`().*/
5+
def flatMap/*<-hk::Monad#flatMap().*/[A/*<-hk::Monad#flatMap().[A]*/, B/*<-hk::Monad#flatMap().[B]*/](m/*<-hk::Monad#flatMap().(m)*/: M/*->hk::Monad#[M]*/[A/*->hk::Monad#flatMap().[A]*/])(f/*<-hk::Monad#flatMap().(f)*/: A/*->hk::Monad#flatMap().[A]*/ => M/*->hk::Monad#[M]*/[B/*->hk::Monad#flatMap().[B]*/]): M/*->hk::Monad#[M]*/[B/*->hk::Monad#flatMap().[B]*/] = ???/*->scala::Predef.`???`().*/
6+
}
7+
8+
class EitherMonad/*<-hk::EitherMonad#*/[T/*<-hk::EitherMonad#[T]*/] extends Monad/*->hk::Monad#*/[[E/*<-hk::EitherMonad#`<init>`().[E]*/] =>> Either/*->scala::package.Either#*/[T/*->hk::EitherMonad#[T]*/, E]] {
9+
}
10+
11+
type MapKV/*<-hk::hk$package.MapKV#*/ = [K/*<-hk::hk$package.MapKV#[K]*/] =>> [V/*<-hk::hk$package.MapKV#[V]*/] =>> Map/*->scala::Predef.Map#*/[K/*->hk::hk$package.MapKV#[K]*/,V/*->hk::hk$package.MapKV#[V]*/]
12+
13+
type MapV/*<-hk::hk$package.MapV#*/ = [_] =>> [V/*<-hk::hk$package.MapV#[V]*/] =>> Map/*->scala::Predef.Map#*/[String/*->scala::Predef.String#*/, V/*->hk::hk$package.MapV#[V]*/]
14+
15+
type Id/*<-hk::hk$package.Id#*/[A/*<-hk::hk$package.Id#[A]*/] = A/*->hk::hk$package.Id#[A]*/

‎tests/semanticdb/expect/hk.scala

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
package hk
2+
3+
trait Monad[M[_]] {
4+
def pure[A](a: A): M[A] = ???
5+
def flatMap[A, B](m: M[A])(f: A => M[B]): M[B] = ???
6+
}
7+
8+
class EitherMonad[T] extends Monad[[E] =>> Either[T, E]] {
9+
}
10+
11+
type MapKV = [K] =>> [V] =>> Map[K,V]
12+
13+
type MapV = [_] =>> [V] =>> Map[String, V]
14+
15+
type Id[A] = A

‎tests/semanticdb/metac.expect

Lines changed: 89 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,7 @@ Schema => SemanticDB v4
4848
Uri => Advanced.scala
4949
Text => empty
5050
Language => Scala
51-
Symbols => 60 entries
51+
Symbols => 61 entries
5252
Occurrences => 134 entries
5353
Synthetics => 3 entries
5454

@@ -57,10 +57,11 @@ advanced/C# => class C [typeparam T ] extends Object { self: C[T] => +3 decls }
5757
advanced/C#[T] => typeparam T
5858
advanced/C#`<init>`(). => primary ctor <init> [typeparam T ](): C[T]
5959
advanced/C#t(). => method t => T
60-
advanced/HKClass# => class HKClass [typeparam F [typeparam T ] <: <?>] extends Object { self: HKClass[F] => +3 decls }
61-
advanced/HKClass#[F] => typeparam F [typeparam T ] <: <?>
60+
advanced/HKClass# => class HKClass [typeparam F [typeparam T ] <: [U] =>> Tuple2[U, T]] extends Object { self: HKClass[F] => +3 decls }
61+
advanced/HKClass#[F] => typeparam F [typeparam T ] <: [U] =>> Tuple2[U, T]
6262
advanced/HKClass#[F][T] => typeparam T
63-
advanced/HKClass#`<init>`(). => primary ctor <init> [typeparam F [typeparam T ] <: <?>](): HKClass[F]
63+
advanced/HKClass#[F][U] => typeparam U
64+
advanced/HKClass#`<init>`(). => primary ctor <init> [typeparam F [typeparam T ] <: [U] =>> Tuple2[U, T]](): HKClass[F]
6465
advanced/HKClass#`<init>`().[F][T] => typeparam T
6566
advanced/HKClass#`<init>`().[F][U] => typeparam U
6667
advanced/HKClass#foo(). => method foo [typeparam T , typeparam U ](param x: F[T, U]): String
@@ -3969,6 +3970,90 @@ Occurrences:
39693970
[0:8..0:15): example <- example/
39703971
[2:6..2:24): FilenameWithSpaces <- example/FilenameWithSpaces#
39713972

3973+
expect/hk.scala
3974+
---------------
3975+
3976+
Summary:
3977+
Schema => SemanticDB v4
3978+
Uri => hk.scala
3979+
Text => empty
3980+
Language => Scala
3981+
Symbols => 26 entries
3982+
Occurrences => 43 entries
3983+
3984+
Symbols:
3985+
hk/EitherMonad# => class EitherMonad [typeparam T ] extends Object with Monad[[E] =>> Either[T, E]] { self: EitherMonad[T] => +2 decls }
3986+
hk/EitherMonad#[E] => typeparam E
3987+
hk/EitherMonad#[T] => typeparam T
3988+
hk/EitherMonad#`<init>`(). => primary ctor <init> [typeparam T ](): EitherMonad[T]
3989+
hk/EitherMonad#`<init>`().[E] => typeparam E
3990+
hk/Monad# => trait Monad [typeparam M [type _ ]] extends Object { self: Monad[M] => +4 decls }
3991+
hk/Monad#[M] => typeparam M [type _ ]
3992+
hk/Monad#[M][_] => type _
3993+
hk/Monad#`<init>`(). => primary ctor <init> [typeparam M [type _ ]](): Monad[M]
3994+
hk/Monad#flatMap(). => method flatMap [typeparam A , typeparam B ](param m: M[A])(param f: Function1[A, M[B]]): M[B]
3995+
hk/Monad#flatMap().(f) => param f: Function1[A, M[B]]
3996+
hk/Monad#flatMap().(m) => param m: M[A]
3997+
hk/Monad#flatMap().[A] => typeparam A
3998+
hk/Monad#flatMap().[B] => typeparam B
3999+
hk/Monad#pure(). => method pure [typeparam A ](param a: A): M[A]
4000+
hk/Monad#pure().(a) => param a: A
4001+
hk/Monad#pure().[A] => typeparam A
4002+
hk/hk$package. => final package object hk extends Object { self: hk.type => +4 decls }
4003+
hk/hk$package.Id# => type Id [typeparam A ] = A
4004+
hk/hk$package.Id#[A] => typeparam A
4005+
hk/hk$package.MapKV# => type MapKV [typeparam K ] = [V] =>> Map[K, V]
4006+
hk/hk$package.MapKV#[K] => typeparam K
4007+
hk/hk$package.MapKV#[V] => typeparam V
4008+
hk/hk$package.MapV# => type MapV [type _ ] = [V] =>> Map[String, V]
4009+
hk/hk$package.MapV#[V] => typeparam V
4010+
hk/hk$package.MapV#[_] => type _
4011+
4012+
Occurrences:
4013+
[0:8..0:10): hk <- hk/
4014+
[2:6..2:11): Monad <- hk/Monad#
4015+
[2:12..2:13): M <- hk/Monad#[M]
4016+
[3:6..3:10): pure <- hk/Monad#pure().
4017+
[3:11..3:12): A <- hk/Monad#pure().[A]
4018+
[3:14..3:15): a <- hk/Monad#pure().(a)
4019+
[3:17..3:18): A -> hk/Monad#pure().[A]
4020+
[3:21..3:22): M -> hk/Monad#[M]
4021+
[3:23..3:24): A -> hk/Monad#pure().[A]
4022+
[3:28..3:31): ??? -> scala/Predef.`???`().
4023+
[4:6..4:13): flatMap <- hk/Monad#flatMap().
4024+
[4:14..4:15): A <- hk/Monad#flatMap().[A]
4025+
[4:17..4:18): B <- hk/Monad#flatMap().[B]
4026+
[4:20..4:21): m <- hk/Monad#flatMap().(m)
4027+
[4:23..4:24): M -> hk/Monad#[M]
4028+
[4:25..4:26): A -> hk/Monad#flatMap().[A]
4029+
[4:29..4:30): f <- hk/Monad#flatMap().(f)
4030+
[4:32..4:33): A -> hk/Monad#flatMap().[A]
4031+
[4:37..4:38): M -> hk/Monad#[M]
4032+
[4:39..4:40): B -> hk/Monad#flatMap().[B]
4033+
[4:44..4:45): M -> hk/Monad#[M]
4034+
[4:46..4:47): B -> hk/Monad#flatMap().[B]
4035+
[4:51..4:54): ??? -> scala/Predef.`???`().
4036+
[7:6..7:17): EitherMonad <- hk/EitherMonad#
4037+
[7:18..7:19): T <- hk/EitherMonad#[T]
4038+
[7:29..7:34): Monad -> hk/Monad#
4039+
[7:36..7:37): E <- hk/EitherMonad#`<init>`().[E]
4040+
[7:43..7:49): Either -> scala/package.Either#
4041+
[7:50..7:51): T -> hk/EitherMonad#[T]
4042+
[10:5..10:10): MapKV <- hk/hk$package.MapKV#
4043+
[10:14..10:15): K <- hk/hk$package.MapKV#[K]
4044+
[10:22..10:23): V <- hk/hk$package.MapKV#[V]
4045+
[10:29..10:32): Map -> scala/Predef.Map#
4046+
[10:33..10:34): K -> hk/hk$package.MapKV#[K]
4047+
[10:35..10:36): V -> hk/hk$package.MapKV#[V]
4048+
[12:5..12:9): MapV <- hk/hk$package.MapV#
4049+
[12:21..12:22): V <- hk/hk$package.MapV#[V]
4050+
[12:28..12:31): Map -> scala/Predef.Map#
4051+
[12:32..12:38): String -> scala/Predef.String#
4052+
[12:40..12:41): V -> hk/hk$package.MapV#[V]
4053+
[14:5..14:7): Id <- hk/hk$package.Id#
4054+
[14:8..14:9): A <- hk/hk$package.Id#[A]
4055+
[14:13..14:14): A -> hk/hk$package.Id#[A]
4056+
39724057
expect/i5854.scala
39734058
------------------
39744059

0 commit comments

Comments
 (0)