fluencelabs/hackethberlin
1
0
Fork 0
mirror of https://github.com/fluencelabs/hackethberlin synced 2025-04-24 17:02:18 +00:00
Code Issues Projects Releases Wiki Activity

Function calls

Browse Source
This commit is contained in:
alari 2018-09-08 19:20:15 +02:00
parent f4d186dfa9
commit 36b6a683bb
4 changed files with 41 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
core/src/main/scala/fluence/hackethberlin/Expr.scala
View File

@ -9,7 +9,7 @@ sealed trait Expr[T] {
def toVyper: String
}
sealed trait InlineExpr[T <: types.Type] extends Expr[T] {
sealed trait InlineExpr[T] extends Expr[T] with Expr.ToInlineVyper {
def toReturn: Free[Expr, T] = Free liftF Expr.Return[T](this)
def :=:(name: Symbol): Free[Expr, Expr.Ref[T]] =
@ -17,27 +17,33 @@ sealed trait InlineExpr[T <: types.Type] extends Expr[T] {
}
object Expr {
case class Ref[T <: types.Type](name: String, boxedValue: T) extends InlineExpr[T] {
override def toVyper: String = name
sealed trait ToInlineVyper {
def toInlineVyper: String
}
case class Infix[L <: types.Type, R <: types.Type, T <: types.Type](
case class Ref[T](name: String, boxedValue: T) extends InlineExpr[T] {
override def toVyper: String = name
override def toInlineVyper: String = toVyper
}
case class Infix[L, R, T](
op: String,
left: InlineExpr[L],
right: InlineExpr[R],
boxedValue: T
) extends InlineExpr[T] {
override def toVyper: String = left.toVyper + s" $op " + right.toVyper
override def toInlineVyper: String = toVyper
}
case class Assign[T <: Type](ref: Ref[T], value: InlineExpr[T]) extends Expr[Ref[T]] {
case class Assign[T](ref: Ref[T], value: InlineExpr[T]) extends Expr[Ref[T]] {
override def boxedValue: Ref[T] = ref
override def toVyper: String =
s"${ref.toVyper} = ${value.toVyper}"
}
case class Return[T <: types.Type](ret: InlineExpr[T]) extends Expr[T] {
case class Return[T](ret: InlineExpr[T]) extends Expr[T] {
override def boxedValue: T = ret.boxedValue
override def toVyper: String =

23
core/src/main/scala/fluence/hackethberlin/FuncDef.scala
View File

@ -4,7 +4,7 @@ import fluence.hackethberlin.types.{DataVyper, ProductType}
import shapeless._
import cats.free.Free
class FuncDef[Args <: HList, Ret <: types.Type](
class FuncDef[Args <: HList, Ret <: types.Type, Params <: HList](
name: String,
argsDef: ProductType[Args],
ret: Ret,
@ -20,25 +20,32 @@ class FuncDef[Args <: HList, Ret <: types.Type](
.filter(_ != types.Void)
.fold("")(" -> " + _.toVyper)}:\n$bodyVyper\n"
def @:(decorator: Decorator): FuncDef[Args, Ret] =
new FuncDef[Args, Ret](name, argsDef, ret, body, decorators + decorator)
def @:(decorator: Decorator): FuncDef[Args, Ret, Params] =
new FuncDef[Args, Ret, Params](name, argsDef, ret, body, decorators + decorator)
//def apply[Params <: HList](params: Params)(implicit a: LUBConstraint s: ops.hlist.Mapped[Args, InlineExpr]): InlineExpr[Ret] = ???
def apply(params: Params)(implicit toList: ops.hlist.ToList[Params, Expr.ToInlineVyper]): InlineExpr[Ret] =
Expr.Ref(toList.apply(params).map(_.toInlineVyper).mkString(s"$name(", ", ", ")"), ret)
}
object FuncDef {
def apply[Args <: HList: DataVyper, Ret <: types.Type](
def apply[Args <: HList: DataVyper, Ret <: types.Type, _Values <: HList](
name: String,
argsDef: Args,
ret: Ret
)(body: ProductType[Args] ⇒ Free[Expr, Ret]): FuncDef[Args, Ret] =
)(body: ProductType[Args] ⇒ Free[Expr, Ret])(
implicit values: ops.record.Values.Aux[Args, _Values],
mapped: ops.hlist.Mapped[_Values, InlineExpr]
): FuncDef[Args, Ret, mapped.Out] =
new FuncDef(name, ProductType(argsDef), ret, body)
def apply[Args <: HList: DataVyper](
def apply[Args <: HList: DataVyper, _Values <: HList](
name: String,
argsDef: Args
)(body: ProductType[Args] ⇒ Free[Expr, Unit]): FuncDef[Args, types.Void] =
)(
body: ProductType[Args] ⇒ Free[Expr, Unit],
mapped: ops.hlist.Mapped[_Values, InlineExpr]
)(implicit values: ops.record.Values.Aux[Args, _Values]): FuncDef[Args, types.Void, mapped.Out] =
new FuncDef(name, ProductType(argsDef), types.Void, args ⇒ body(args).map(_ ⇒ types.Void))
}

15
core/src/main/scala/fluence/hackethberlin/types/ProductType.scala
View File

@ -1,13 +1,13 @@
package fluence.hackethberlin.types
import cats.free.Free
import fluence.hackethberlin.{Expr, FuncDef}
import shapeless.{HList, Witness}
import fluence.hackethberlin.{Expr, FuncDef, InlineExpr}
import shapeless._
import shapeless.ops.record.Selector
class ProductType[D <: HList](dataDef: D, dv: DataVyper[D]) extends Type {
def ref[T <: Symbol, V <: Type](k: Witness.Aux[T])(implicit selector: Selector.Aux[D, T, V]): Expr.Ref[V] =
def ref[T <: Symbol, V <: Type](k: Witness.Aux[T])(implicit selector: Selector.Aux[D, T, V]): InlineExpr[V] =
Expr.Ref[V](k.value.name, selector(dataDef))
// type in type definition somewhere
@ -22,8 +22,13 @@ class ProductType[D <: HList](dataDef: D, dv: DataVyper[D]) extends Type {
def toArgsVyper: String =
dv.toVyperDefinitions(dataDef).mkString(", ")
def funcDef[Ret <: Type](name: String, ret: Ret)(body: ProductType[D] ⇒ Free[Expr, Ret]): FuncDef[D, Ret] =
new FuncDef[D, Ret](name, this, ret, body)
def funcDef[Ret <: Type, _Values <: HList](name: String, ret: Ret)(
body: ProductType[D] ⇒ Free[Expr, Ret]
)(
implicit values: ops.record.Values.Aux[D, _Values],
mapped: ops.hlist.Mapped[_Values, InlineExpr]
): FuncDef[D, Ret, mapped.Out] =
new FuncDef[D, Ret, mapped.Out](name, this, ret, body)
}

4
src/main/scala/fluence/MakeVyperApp.scala
View File

@ -59,4 +59,8 @@ object MakeVyperApp extends App {
).toVyper
)
println(
func(recordStruct.ref('record_address) :: HNil).toVyper
)
}