fluencelabs/aqua
1
0
Fork 0
mirror of https://github.com/fluencelabs/aqua.git synced 2025-07-31 22:01:55 +00:00
Code Issues Projects Releases Wiki Activity

Streams support (#87)

Browse Source 
* #29 going to support streams

* Added StreamName

* StreamName removed

* Streams support works

* Debug println removed

Co-authored-by: Dima <dmitry.shakhtarin@fluence.ai>
This commit is contained in:
Dmitry Kurinskiy
2021-04-27 16:59:12 +03:00
committed by GitHub
parent 3b3ff24133
commit 27f2912c5f
39 changed files with 339 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
parser/src/main/scala/aqua/parser/expr/ArrowTypeExpr.scala
View File

@@ -12,7 +12,8 @@ case class ArrowTypeExpr[F[_]](name: Name[F], `type`: ArrowTypeToken[F]) extends
object ArrowTypeExpr extends Expr.Leaf {
override def p[F[_]: LiftParser: Comonad]: Parser[ArrowTypeExpr[F]] =
(Name.p[F] ~ ((` : ` *> ArrowTypeToken.`arrowdef`[F]) | ArrowTypeToken.`arrowWithNames`)).map {
(Name
.p[F] ~ ((` : ` *> ArrowTypeToken.`arrowdef`[F]) | ArrowTypeToken.`arrowWithNames`)).map {
case (name, t) =>
ArrowTypeExpr(name, t)
}

19
parser/src/main/scala/aqua/parser/expr/DeclareStreamExpr.scala Normal file
View File

@@ -0,0 +1,19 @@
package aqua.parser.expr
import aqua.parser.Expr
import aqua.parser.lexer.{Name, Token, TypeToken}
import aqua.parser.lift.LiftParser
import cats.Comonad
import cats.parse.Parser
import Token._
case class DeclareStreamExpr[F[_]](name: Name[F], `type`: TypeToken[F]) extends Expr[F]
object DeclareStreamExpr extends Expr.Leaf {
override def p[F[_]: LiftParser: Comonad]: Parser[DeclareStreamExpr[F]] =
((Name.p[F] <* ` : `) ~ TypeToken.`typedef`[F]).map { case (name, t) =>
DeclareStreamExpr(name, t)
}
}

4
parser/src/main/scala/aqua/parser/expr/FieldTypeExpr.scala
View File

@@ -12,7 +12,7 @@ case class FieldTypeExpr[F[_]](name: Name[F], `type`: DataTypeToken[F]) extends
object FieldTypeExpr extends Expr.Leaf {
override def p[F[_]: LiftParser: Comonad]: Parser[FieldTypeExpr[F]] =
((Name.p[F] <* ` : `) ~ DataTypeToken.`datatypedef`[F]).map {
case (name, t) => FieldTypeExpr(name, t)
((Name.p[F] <* ` : `) ~ DataTypeToken.`datatypedef`[F]).map { case (name, t) =>
FieldTypeExpr(name, t)
}
}

3
parser/src/main/scala/aqua/parser/expr/FuncExpr.scala
View File

@@ -25,7 +25,8 @@ object FuncExpr
ParExpr,
ForExpr,
IfExpr,
ElseOtherwiseExpr
ElseOtherwiseExpr,
DeclareStreamExpr
) {
override def p[F[_]: LiftParser: Comonad]: Parser[FuncExpr[F]] =

4
parser/src/main/scala/aqua/parser/lexer/Arg.scala
View File

@@ -10,7 +10,7 @@ case class Arg[F[_]](name: Name[F], `type`: TypeToken[F])
object Arg {
def p[F[_]: LiftParser: Comonad]: P[Arg[F]] =
((Name.p[F] <* ` : `) ~ TypeToken.`typedef`[F]).map {
case (name, t) => Arg(name, t)
((Name.p[F] <* ` : `) ~ TypeToken.`typedef`[F]).map { case (name, t) =>
Arg(name, t)
}
}

6
parser/src/main/scala/aqua/parser/lexer/Token.scala
View File

@@ -43,9 +43,7 @@ object Token {
val `:` : P[Unit] = P.char(':')
val ` : ` : P[Unit] = P.char(':').surroundedBy(` `.?)
val `name`: P[String] = (P.charIn(az) ~ P.charsWhile(anum_).?).map { case (c, s) ⇒
c.toString ++ s.getOrElse("")
}
val `name`: P[String] = (P.charIn(az) ~ P.charsWhile(anum_).?).string
val `Class`: P[String] = (P.charIn(AZ) ~ P.charsWhile(anum_).?).map { case (c, s) ⇒
c.toString ++ s.getOrElse("")
@@ -59,8 +57,10 @@ object Token {
val `.` : P[Unit] = P.char('.')
val `"` : P[Unit] = P.char('"')
val `*` : P[Unit] = P.char('*')
val `[]` : P[Unit] = P.string("[]")
val `(` : P[Unit] = ` `.?.with1 *> P.char('(') <* ` `.?
val `)` : P[Unit] = ` `.?.with1 *> P.char(')') <* ` `.?
val `()` : P[Unit] = P.string("()")
val ` -> ` : P[Unit] = ` `.?.with1 *> P.string("->") <* ` `.?
val ` <- ` : P[Unit] = (` `.?.with1 *> P.string("<-") <* ` `.?).backtrack
val `=` : P[Unit] = P.string("=")

30
parser/src/main/scala/aqua/parser/lexer/TypeToken.scala
View File

@@ -17,6 +17,18 @@ case class ArrayTypeToken[F[_]: Comonad](override val unit: F[Unit], data: DataT
override def as[T](v: T): F[T] = unit.as(v)
}
case class StreamTypeToken[F[_]: Comonad](override val unit: F[Unit], data: DataTypeToken[F])
extends DataTypeToken[F] {
override def as[T](v: T): F[T] = unit.as(v)
}
object StreamTypeToken {
def `streamtypedef`[F[_]: LiftParser: Comonad]: P[StreamTypeToken[F]] =
(`*`.lift ~ DataTypeToken.`datatypedef`[F]).map(ud => StreamTypeToken(ud._1, ud._2))
}
case class CustomTypeToken[F[_]: Comonad](name: F[String]) extends DataTypeToken[F] {
override def as[T](v: T): F[T] = name.as(v)
@@ -64,7 +76,7 @@ object ArrowTypeToken {
def `arrowdef`[F[_]: LiftParser: Comonad]: P[ArrowTypeToken[F]] =
(comma0(DataTypeToken.`datatypedef`).with1 ~ ` -> `.lift ~
(DataTypeToken.`datatypedef`
.map(Some(_)) | P.string("()").as(None))).map { case ((args, point), res) ⇒
.map(Some(_)) | `()`.as(None))).map { case ((args, point), res) ⇒
ArrowTypeToken(point, args, res)
}
@@ -75,27 +87,23 @@ object ArrowTypeToken {
}
}
case class AquaArrowType[F[_]](args: List[TypeToken[F]], res: Option[DataTypeToken[F]])
extends ArrowDef[F] {
override def argTypes: List[TypeToken[F]] = args
override def resType: Option[DataTypeToken[F]] = res
}
object DataTypeToken {
def `arraytypedef`[F[_]: LiftParser: Comonad]: P[ArrayTypeToken[F]] =
(P.string("[]").lift ~ `datatypedef`[F]).map(ud => ArrayTypeToken(ud._1, ud._2))
(`[]`.lift ~ `datatypedef`[F]).map(ud => ArrayTypeToken(ud._1, ud._2))
def `datatypedef`[F[_]: LiftParser: Comonad]: P[DataTypeToken[F]] =
P.oneOf(
P.defer(`arraytypedef`[F]) :: BasicTypeToken.`basictypedef`[F] :: CustomTypeToken.ct[F] :: Nil
P.defer(`arraytypedef`[F]) :: P.defer(StreamTypeToken.`streamtypedef`) :: BasicTypeToken
.`basictypedef`[F] :: CustomTypeToken.ct[F] :: Nil
)
}
object TypeToken {
def `typedef`[F[_]: LiftParser: Comonad]: P[TypeToken[F]] =
P.oneOf(ArrowTypeToken.`arrowdef`.backtrack :: DataTypeToken.`datatypedef` :: Nil)
P.oneOf(
ArrowTypeToken.`arrowdef`.backtrack :: DataTypeToken.`datatypedef` :: Nil
)
}