725 lines
34 KiB
Scala
725 lines
34 KiB
Scala
package tf.bug.fancade
|
||
|
||
import tf.bug.shinji.{Arrow, ArrowLoop, Cartesian, Monoidal}
|
||
|
||
object Fanscript {
|
||
|
||
sealed trait Pin
|
||
case object Number extends Pin
|
||
case object Bool extends Pin
|
||
case object Vector extends Pin
|
||
case object Rotation extends Pin
|
||
case object Obj extends Pin
|
||
case object Constraint extends Pin
|
||
case object Pull extends Pin
|
||
case object T extends Pin
|
||
case class ×[A <: Pin, B <: Pin](a: A, b: B) extends Pin
|
||
|
||
trait PinEv[A <: Pin] {
|
||
val value: A
|
||
}
|
||
object PinEv {
|
||
implicit val pinValueForNumber: PinEv[Number.type] = new PinEv[Number.type] {
|
||
override val value: Number.type = Number
|
||
}
|
||
implicit val pinValueForBool: PinEv[Bool.type] = new PinEv[Bool.type] {
|
||
override val value: Bool.type = Bool
|
||
}
|
||
implicit val pinValueForVector: PinEv[Vector.type] = new PinEv[Vector.type] {
|
||
override val value: Vector.type = Vector
|
||
}
|
||
implicit val pinValueForRotation: PinEv[Rotation.type] = new PinEv[Rotation.type] {
|
||
override val value: Rotation.type = Rotation
|
||
}
|
||
implicit val pinValueForObj: PinEv[Obj.type] = new PinEv[Obj.type] {
|
||
override val value: Obj.type = Obj
|
||
}
|
||
implicit val pinValueForConstraint: PinEv[Constraint.type] = new PinEv[Constraint.type] {
|
||
override val value: Constraint.type = Constraint
|
||
}
|
||
implicit val pinValueForPull: PinEv[Pull.type] = new PinEv[Pull.type] {
|
||
override val value: Pull.type = Pull
|
||
}
|
||
implicit val pinValueForT: PinEv[T.type] = new PinEv[T.type] {
|
||
override val value: T.type = T
|
||
}
|
||
implicit def pinValueForProduct[A <: Pin, B <: Pin](implicit left: PinEv[A], right: PinEv[B]): PinEv[A × B] = new PinEv[A × B] {
|
||
override val value: A × B = ×(left.value, right.value)
|
||
}
|
||
}
|
||
|
||
sealed trait →[A <: Pin, B <: Pin] {
|
||
def left: A
|
||
def right: B
|
||
|
||
final def leftEv: PinEv[A] = new PinEv[A] {
|
||
override val value: A = left
|
||
}
|
||
final def rightEv: PinEv[B] = new PinEv[B] {
|
||
override val value: B = right
|
||
}
|
||
|
||
final def andThen[C <: Pin](f: B → C): A → C =
|
||
fanscript.andThen(this, f)
|
||
final def >>>[C <: Pin](f: B → C): A → C =
|
||
andThen(f)
|
||
|
||
final def compose[C <: Pin](f: C → A): C → B =
|
||
fanscript.compose(this, f)
|
||
final def <<<[C <: Pin](f: C → A): C → B =
|
||
compose(f)
|
||
|
||
final def split[C <: Pin, D <: Pin](f: C → D): (A × C) → (B × D) =
|
||
fanscript.split(this, f)
|
||
final def ***[C <: Pin, D <: Pin](f: C → D): (A × C) → (B × D) =
|
||
split(f)
|
||
|
||
final def merge[C <: Pin](f: A → C): A → (B × C) =
|
||
fanscript.merge(this, f)
|
||
final def &&&[C <: Pin](f: A → C): A → (B × C) =
|
||
merge(f)
|
||
}
|
||
case class Id[A <: Pin](a: A) extends (A → A) {
|
||
override def left: A = a
|
||
override def right: A = a
|
||
}
|
||
case class AndThen[A <: Pin, B <: Pin, C <: Pin](f: A → B, g: B → C) extends (A → C) {
|
||
override def left: A = f.left
|
||
override def right: C = g.right
|
||
}
|
||
case class Swap[A <: Pin, B <: Pin](a: A, b: B) extends ((A × B) → (B × A)) {
|
||
override def left: A × B = ×(a, b)
|
||
override def right: B × A = ×(b, a)
|
||
}
|
||
case class Deunit[A <: Pin](a: A) extends (A → (T.type × A)) {
|
||
override def left: A = a
|
||
override def right: T.type × A = ×(T, a)
|
||
}
|
||
case class Unit[A <: Pin](a: A) extends ((T.type × A) → A) {
|
||
override def left: T.type × A = ×(T, a)
|
||
override def right: A = a
|
||
}
|
||
case class Associate[A <: Pin, B <: Pin, C <: Pin](a: A, b: B, c: C) extends (((A × B) × C) → (A × (B × C))) {
|
||
override def left: (A × B) × C = ×(×(a, b), c)
|
||
override def right: A × (B × C) = ×(a, ×(b, c))
|
||
}
|
||
case class Duplicate[A <: Pin](a: A) extends (A → (A × A)) {
|
||
override def left: A = a
|
||
override def right: A × A = ×(a, a)
|
||
}
|
||
case class Terminate[A <: Pin](a: A) extends (A → T.type) {
|
||
override def left: A = a
|
||
override def right: T.type = T
|
||
}
|
||
case class Bimap[A <: Pin, B <: Pin, C <: Pin, D <: Pin](f: A → B, g: C → D) extends ((A × C) → (B × D)) {
|
||
override def left: A × C = ×(f.left, g.left)
|
||
override def right: B × D = ×(f.right, g.right)
|
||
}
|
||
case class Loop[A <: Pin, B <: Pin, C <: Pin](f: (A × C) → (B × C)) extends (A → B) {
|
||
override def left: A = f.left.a
|
||
override def right: B = f.right.a
|
||
}
|
||
|
||
case object Z extends (T.type → Pull.type) {
|
||
override def left: T.type = T
|
||
override def right: Pull.type = Pull
|
||
}
|
||
|
||
def bubbleSort[In <: Pin, Out <: Pin](sort: Vector[Int])(implicit inEv: PinEv[In], outEv: PinEv[Out]): Option[In → Out] = {
|
||
???
|
||
}
|
||
|
||
object Builtin {
|
||
|
||
case class NumberValue(number: Float) extends (T.type → Number.type) {
|
||
override def left: T.type = T
|
||
override def right: Number.type = Number
|
||
}
|
||
case class VectorValue(x: Float, y: Float, z: Float) extends (T.type → Vector.type) {
|
||
override def left: T.type = T
|
||
override def right: Vector.type = Vector
|
||
}
|
||
case class RotationValue(x: Float, y: Float, z: Float) extends (T.type → Rotation.type) {
|
||
override def left: T.type = T
|
||
override def right: Rotation.type = Rotation
|
||
}
|
||
case object TrueValue extends (T.type → Bool.type) {
|
||
override def left: T.type = T
|
||
override def right: Bool.type = Bool
|
||
}
|
||
case object FalseValue extends (T.type → Bool.type) {
|
||
override def left: T.type = T
|
||
override def right: Bool.type = Bool
|
||
}
|
||
|
||
case object InspectNumber extends ((Number.type × Pull.type) → Pull.type) {
|
||
override def left: Number.type × Pull.type = ×(Number, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object InspectVector extends ((Vector.type × Pull.type) → Pull.type) {
|
||
override def left: Vector.type × Pull.type = ×(Vector, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object InspectRotation extends ((Rotation.type × Pull.type) → Pull.type) {
|
||
override def left: Rotation.type × Pull.type = ×(Rotation, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object InspectTruth extends ((Bool.type × Pull.type) → Pull.type) {
|
||
override def left: Bool.type × Pull.type = ×(Bool, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object InspectObject extends ((Obj.type × Pull.type) → Pull.type) {
|
||
override def left: Obj.type × Pull.type = ×(Obj, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
|
||
case object Win extends (Pull.type → Pull.type) {
|
||
override def left: Pull.type = Pull
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object Lose extends (Pull.type → Pull.type) {
|
||
override def left: Pull.type = Pull
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object SetScore extends ((Number.type × Pull.type) → Pull.type) {
|
||
override def left: Number.type × Pull.type = ×(Number, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object SetCamera extends ((Vector.type × Rotation.type × Number.type × Pull.type) → Pull.type) {
|
||
override def left: Vector.type × Rotation.type × Number.type × Pull.type = ×(×(×(Vector, Rotation), Number), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object SetLight extends ((Vector.type × Rotation.type × Pull.type) → Pull.type) {
|
||
override def left: Vector.type × Rotation.type × Pull.type = ×(×(Vector, Rotation), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object ScreenSize extends (T.type → (Number.type × Number.type)) {
|
||
override def left: T.type = T
|
||
override def right: Number.type × Number.type = ×(Number, Number)
|
||
}
|
||
case object Accelerometer extends (T.type → Vector.type) {
|
||
override def left: T.type = T
|
||
override def right: Vector.type = Vector
|
||
}
|
||
case object CurrentFrame extends (T.type → Number.type) {
|
||
override def left: T.type = T
|
||
override def right: Number.type = Number
|
||
}
|
||
|
||
case object GetPosition extends (Obj.type → (Vector.type × Rotation.type)) {
|
||
override def left: Obj.type = Obj
|
||
override def right: Vector.type × Rotation.type = ×(Vector, Rotation)
|
||
}
|
||
case object SetPosition extends ((Obj.type × Vector.type × Rotation.type × Pull.type) → Pull.type) {
|
||
override def left: Obj.type × Vector.type × Rotation.type × Pull.type = ×(×(×(Obj, Vector), Rotation), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object Raycast extends ((Vector.type × Vector.type) → (Bool.type × Vector.type × Obj.type)) {
|
||
override def left: Vector.type × Vector.type = ×(Vector, Vector)
|
||
override def right: Bool.type × Vector.type × Obj.type = ×(×(Bool, Vector), Obj)
|
||
}
|
||
case object GetSize extends (Obj.type → (Vector.type × Vector.type)) {
|
||
override def left: Obj.type = Obj
|
||
override def right: Vector.type × Vector.type = ×(Vector, Vector)
|
||
}
|
||
case object SetVisible extends ((Obj.type × Bool.type × Pull.type) → Pull.type) {
|
||
override def left: Obj.type × Bool.type × Pull.type = ×(×(Obj, Bool), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object CreateObject extends ((Obj.type × Pull.type) → (Obj.type × Pull.type)) {
|
||
override def left: Obj.type × Pull.type = ×(Obj, Pull)
|
||
override def right: Obj.type × Pull.type = ×(Obj, Pull)
|
||
}
|
||
case object DestroyObject extends ((Obj.type × Pull.type) → Pull.type) {
|
||
override def left: Obj.type × Pull.type = ×(Obj, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
|
||
case class PlaySound(loop: Boolean, sample: SoundSample) extends ((Number.type × Number.type × Pull.type) → (Number.type × Pull.type)) {
|
||
override def left: Number.type × Number.type × Pull.type = ×(×(Number, Number), Pull)
|
||
override def right: Number.type × Pull.type = ×(Number, Pull)
|
||
}
|
||
case object StopSound extends ((Number.type × Pull.type) → Pull.type) {
|
||
override def left: Number.type × Pull.type = ×(Number, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object VolumePitch extends ((Number.type × Number.type × Number.type × Pull.type) → Pull.type) {
|
||
override def left: Number.type × Number.type × Number.type × Pull.type = ×(×(×(Number, Number), Number), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
|
||
case object AddForce extends ((Obj.type × Vector.type × Vector.type × Vector.type × Vector.type × Pull.type) → Pull.type) {
|
||
override def left: Obj.type × Vector.type × Vector.type × Vector.type × Vector.type × Pull.type = ×(×(×(×(×(Obj, Vector), Vector), Vector), Vector), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object GetVelocity extends (Obj.type → (Vector.type × Vector.type)) {
|
||
override def left: Obj.type = Obj
|
||
override def right: Vector.type × Vector.type = ×(Vector, Vector)
|
||
}
|
||
case object SetVelocity extends ((Obj.type × Vector.type × Vector.type × Pull.type) → Pull.type) {
|
||
override def left: Obj.type × Vector.type × Vector.type × Pull.type = ×(×(×(Obj, Vector), Vector), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object SetLocked extends ((Obj.type × Vector.type × Vector.type × Pull.type) → Pull.type) {
|
||
override def left: Obj.type × Vector.type × Vector.type × Pull.type = ×(×(×(Obj, Vector), Vector), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object SetMass extends ((Obj.type × Number.type × Pull.type) → Pull.type) {
|
||
override def left: Obj.type × Number.type × Pull.type = ×(×(Obj, Number), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object SetFriction extends ((Obj.type × Number.type × Pull.type) → Pull.type) {
|
||
override def left: Obj.type × Number.type × Pull.type = ×(×(Obj, Number), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object SetBounciness extends ((Obj.type × Number.type × Pull.type) → Pull.type) {
|
||
override def left: Obj.type × Number.type × Pull.type = ×(×(Obj, Number), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object SetGravity extends ((Vector.type × Pull.type) → Pull.type) {
|
||
override def left: Vector.type × Pull.type = ×(Vector, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object AddConstraint extends ((Obj.type × Obj.type × Vector.type × Pull.type) → (Constraint.type × Pull.type)) {
|
||
override def left: Obj.type × Obj.type × Vector.type × Pull.type = ×(×(×(Obj, Obj), Vector), Pull)
|
||
override def right: Constraint.type × Pull.type = ×(Constraint, Pull)
|
||
}
|
||
case object LinearLimits extends ((Constraint.type × Vector.type × Vector.type × Pull.type) → Pull.type) {
|
||
override def left: Constraint.type × Vector.type × Vector.type × Pull.type = ×(×(×(Constraint, Vector), Vector), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object AngularLimits extends ((Constraint.type × Vector.type × Vector.type × Pull.type) → Pull.type) {
|
||
override def left: Constraint.type × Vector.type × Vector.type × Pull.type = ×(×(×(Constraint, Vector), Vector), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object LinearSpring extends ((Constraint.type × Vector.type × Vector.type × Pull.type) → Pull.type) {
|
||
override def left: Constraint.type × Vector.type × Vector.type × Pull.type = ×(×(×(Constraint, Vector), Vector), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object AngularSpring extends ((Constraint.type × Vector.type × Vector.type × Pull.type) → Pull.type) {
|
||
override def left: Constraint.type × Vector.type × Vector.type × Pull.type = ×(×(×(Constraint, Vector), Vector), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object LinearMotor extends ((Constraint.type × Vector.type × Vector.type × Pull.type) → Pull.type) {
|
||
override def left: Constraint.type × Vector.type × Vector.type × Pull.type = ×(×(×(Constraint, Vector), Vector), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object AngularMotor extends ((Constraint.type × Vector.type × Vector.type × Pull.type) → Pull.type) {
|
||
override def left: Constraint.type × Vector.type × Vector.type × Pull.type = ×(×(×(Constraint, Vector), Vector), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
|
||
case object If extends ((Bool.type × Pull.type × Pull.type × Pull.type) → Pull.type) {
|
||
override def left: Bool.type × Pull.type × Pull.type × Pull.type = ×(×(×(Bool, Pull), Pull), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object OnPlay extends ((Pull.type × Pull.type) → Pull.type) {
|
||
override def left: Pull.type × Pull.type = ×(Pull, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object LateUpdate extends ((Pull.type × Pull.type) → Pull.type) {
|
||
override def left: Pull.type × Pull.type = ×(Pull, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object BoxArt extends ((Pull.type × Pull.type) → Pull.type) {
|
||
override def left: Pull.type × Pull.type = ×(Pull, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case class OnTouch(event: TouchEvent, finger: TouchFinger) extends ((Pull.type × Pull.type) → (Number.type × Number.type × Pull.type)) {
|
||
override def left: Pull.type × Pull.type = ×(Pull, Pull)
|
||
override def right: Number.type × Number.type × Pull.type = ×(×(Number, Number), Pull)
|
||
}
|
||
case object OnSwipe extends ((Pull.type × Pull.type) → (Vector.type × Pull.type)) {
|
||
override def left: Pull.type × Pull.type = ×(Pull, Pull)
|
||
override def right: Vector.type × Pull.type = ×(Vector, Pull)
|
||
}
|
||
case object OnCollision extends ((Obj.type × Pull.type × Pull.type) → (Obj.type × Number.type × Vector.type × Pull.type)) {
|
||
override def left: Obj.type × Pull.type × Pull.type = ×(×(Obj, Pull), Pull)
|
||
override def right: Obj.type × Number.type × Vector.type × Pull.type = ×(×(×(Obj, Number), Vector), Pull)
|
||
}
|
||
case object Loop extends ((Number.type × Number.type × Pull.type × Pull.type) → (Number.type × Pull.type)) {
|
||
override def left: Number.type × Number.type × Pull.type × Pull.type = ×(×(×(Number, Number), Pull), Pull)
|
||
override def right: Number.type × Pull.type = ×(Number, Pull)
|
||
}
|
||
|
||
case object Negate extends (Number.type → Number.type) {
|
||
override def left: Number.type = Number
|
||
override def right: Number.type = Number
|
||
}
|
||
case object Inverse extends (Rotation.type → Rotation.type) {
|
||
override def left: Rotation.type = Rotation
|
||
override def right: Rotation.type = Rotation
|
||
}
|
||
case object AddNumbers extends ((Number.type × Number.type) → Number.type) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Number.type = Number
|
||
}
|
||
case object AddVectors extends ((Vector.type × Vector.type) → Vector.type) {
|
||
override def left: Vector.type × Vector.type = ×(Vector, Vector)
|
||
override def right: Vector.type = Vector
|
||
}
|
||
case object SubtractNumbers extends ((Number.type × Number.type) → Number.type) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Number.type = Number
|
||
}
|
||
case object SubtractVectors extends ((Vector.type × Vector.type) → Vector.type) {
|
||
override def left: Vector.type × Vector.type = ×(Vector, Vector)
|
||
override def right: Vector.type = Vector
|
||
}
|
||
case object Multiply extends ((Number.type × Number.type) → Number.type) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Number.type = Number
|
||
}
|
||
case object Scale extends ((Vector.type × Number.type) → Vector.type) {
|
||
override def left: Vector.type × Number.type = ×(Vector, Number)
|
||
override def right: Vector.type = Vector
|
||
}
|
||
case object Rotate extends ((Vector.type × Rotation.type) → Vector.type) {
|
||
override def left: Vector.type × Rotation.type = ×(Vector, Rotation)
|
||
override def right: Vector.type = Vector
|
||
}
|
||
case object Combine extends ((Rotation.type × Rotation.type) → Rotation.type) {
|
||
override def left: Rotation.type × Rotation.type = ×(Rotation, Rotation)
|
||
override def right: Rotation.type = Rotation
|
||
}
|
||
case object Divide extends ((Number.type × Number.type) → Number.type) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Number.type = Number
|
||
}
|
||
case object Power extends ((Number.type × Number.type) → Number.type) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Number.type = Number
|
||
}
|
||
case object EqualNumbers extends ((Number.type × Number.type) → Bool.type) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Bool.type = Bool
|
||
}
|
||
case object EqualVectors extends ((Vector.type × Vector.type) → Bool.type) {
|
||
override def left: Vector.type × Vector.type = ×(Vector, Vector)
|
||
override def right: Bool.type = Bool
|
||
}
|
||
case object EqualObjects extends ((Obj.type × Obj.type) → Bool.type) {
|
||
override def left: Obj.type × Obj.type = ×(Obj, Obj)
|
||
override def right: Bool.type = Bool
|
||
}
|
||
case object EqualTruths extends ((Bool.type × Bool.type) → Bool.type) {
|
||
override def left: Bool.type × Bool.type = ×(Bool, Bool)
|
||
override def right: Bool.type = Bool
|
||
}
|
||
case object LessThan extends ((Number.type × Number.type) → Bool.type) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Bool.type = Bool
|
||
}
|
||
case object GreaterThan extends ((Number.type × Number.type) → Bool.type) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Bool.type = Bool
|
||
}
|
||
case object And extends ((Bool.type × Bool.type) → Bool.type) {
|
||
override def left: Bool.type × Bool.type = ×(Bool, Bool)
|
||
override def right: Bool.type = Bool
|
||
}
|
||
case object Or extends ((Bool.type × Bool.type) → Bool.type) {
|
||
override def left: Bool.type × Bool.type = ×(Bool, Bool)
|
||
override def right: Bool.type = Bool
|
||
}
|
||
case object Not extends (Bool.type → Bool.type) {
|
||
override def left: Bool.type = Bool
|
||
override def right: Bool.type = Bool
|
||
}
|
||
case object Random extends ((Number.type × Number.type) → Number.type) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Number.type = Number
|
||
}
|
||
case object RandomSeed extends ((Number.type × Pull.type) → Pull.type) {
|
||
override def left: Number.type × Pull.type = ×(Number, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object Min extends ((Number.type × Number.type) → Number.type) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Number.type = Number
|
||
}
|
||
case object Max extends ((Number.type × Number.type) → Number.type) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Number.type = Number
|
||
}
|
||
case object Sin extends (Number.type → Number.type) {
|
||
override def left: Number.type = Number
|
||
override def right: Number.type = Number
|
||
}
|
||
case object Cos extends (Number.type → Number.type) {
|
||
override def left: Number.type = Number
|
||
override def right: Number.type = Number
|
||
}
|
||
case object Round extends (Number.type → Number.type) {
|
||
override def left: Number.type = Number
|
||
override def right: Number.type = Number
|
||
}
|
||
case object Floor extends (Number.type → Number.type) {
|
||
override def left: Number.type = Number
|
||
override def right: Number.type = Number
|
||
}
|
||
case object Ceiling extends (Number.type → Number.type) {
|
||
override def left: Number.type = Number
|
||
override def right: Number.type = Number
|
||
}
|
||
case object Absolute extends (Number.type → Number.type) {
|
||
override def left: Number.type = Number
|
||
override def right: Number.type = Number
|
||
}
|
||
case object Modulo extends ((Number.type × Number.type) → Number.type) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Number.type = Number
|
||
}
|
||
case object Logarithm extends ((Number.type × Number.type) → Number.type) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Number.type = Number
|
||
}
|
||
case object BreakVector extends (Vector.type → (Number.type × Number.type × Number.type)) {
|
||
override def left: Vector.type = Vector
|
||
override def right: Number.type × Number.type × Number.type = ×(×(Number, Number), Number)
|
||
}
|
||
case object MakeVector extends ((Number.type × Number.type × Number.type) → Vector.type) {
|
||
override def left: Number.type × Number.type × Number.type = ×(×(Number, Number), Number)
|
||
override def right: Vector.type = Vector
|
||
}
|
||
case object Normalize extends (Vector.type → Vector.type) {
|
||
override def left: Vector.type = Vector
|
||
override def right: Vector.type = Vector
|
||
}
|
||
case object DotProduct extends ((Vector.type × Vector.type) → Vector.type) {
|
||
override def left: Vector.type × Vector.type = ×(Vector, Vector)
|
||
override def right: Vector.type = Vector
|
||
}
|
||
case object CrossProduct extends ((Vector.type × Vector.type) → Vector.type) {
|
||
override def left: Vector.type × Vector.type = ×(Vector, Vector)
|
||
override def right: Vector.type = Vector
|
||
}
|
||
case object BreakRotation extends (Rotation.type → (Number.type × Number.type × Number.type)) {
|
||
override def left: Rotation.type = Rotation
|
||
override def right: Number.type × Number.type × Number.type = ×(×(Number, Number), Number)
|
||
}
|
||
case object MakeRotation extends ((Number.type × Number.type × Number.type) → Rotation.type) {
|
||
override def left: Number.type × Number.type × Number.type = ×(×(Number, Number), Number)
|
||
override def right: Rotation.type = Rotation
|
||
}
|
||
case object Distance extends ((Vector.type × Vector.type) → Number.type) {
|
||
override def left: Vector.type × Vector.type = ×(Vector, Vector)
|
||
override def right: Number.type = Number
|
||
}
|
||
case object LERP extends ((Rotation.type × Rotation.type × Number.type) → Rotation.type) {
|
||
override def left: Rotation.type × Rotation.type × Number.type = ×(×(Rotation, Rotation), Number)
|
||
override def right: Rotation.type = Rotation
|
||
}
|
||
case object AxisAngle extends ((Vector.type × Number.type) → Rotation.type) {
|
||
override def left: Vector.type × Number.type = ×(Vector, Number)
|
||
override def right: Rotation.type = Rotation
|
||
}
|
||
case object ScreenToWorld extends ((Number.type × Number.type) → (Vector.type × Vector.type)) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Vector.type × Vector.type = ×(Vector, Vector)
|
||
}
|
||
case object WorldToScreen extends (Vector.type → (Number.type × Number.type)) {
|
||
override def left: Vector.type = Vector
|
||
override def right: Number.type × Number.type = ×(Number, Number)
|
||
}
|
||
case object LineVsPlane extends ((Vector.type × Vector.type × Vector.type × Vector.type) → Vector.type) {
|
||
override def left: Vector.type × Vector.type × Vector.type × Vector.type = ×(×(×(Vector, Vector), Vector), Vector)
|
||
override def right: Vector.type = Vector
|
||
}
|
||
case object LookRotation extends ((Vector.type × Vector.type) → Rotation.type) {
|
||
override def left: Vector.type × Vector.type = ×(Vector, Vector)
|
||
override def right: Rotation.type = Rotation
|
||
}
|
||
|
||
case class GetNumber(name: String) extends (T.type → Number.type) {
|
||
override def left: T.type = T
|
||
override def right: Number.type = Number
|
||
}
|
||
case class GetObject(name: String) extends (T.type → Obj.type) {
|
||
override def left: T.type = T
|
||
override def right: Obj.type = Obj
|
||
}
|
||
case class GetVector(name: String) extends (T.type → Vector.type) {
|
||
override def left: T.type = T
|
||
override def right: Vector.type = Vector
|
||
}
|
||
case class GetRotation(name: String) extends (T.type → Rotation.type) {
|
||
override def left: T.type = T
|
||
override def right: Rotation.type = Rotation
|
||
}
|
||
case class GetTruth(name: String) extends (T.type → Bool.type) {
|
||
override def left: T.type = T
|
||
override def right: Bool.type = Bool
|
||
}
|
||
case class GetConstraint(name: String) extends (T.type → Constraint.type) {
|
||
override def left: T.type = T
|
||
override def right: Constraint.type = Constraint
|
||
}
|
||
case class SetNumber(name: String) extends ((Number.type × Pull.type) → Pull.type) {
|
||
override def left: Number.type × Pull.type = ×(Number, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case class SetObject(name: String) extends ((Obj.type × Pull.type) → Pull.type) {
|
||
override def left: Obj.type × Pull.type = ×(Obj, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case class SetVector(name: String) extends ((Vector.type × Pull.type) → Pull.type) {
|
||
override def left: Vector.type × Pull.type = ×(Vector, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case class SetRotation(name: String) extends ((Rotation.type × Pull.type) → Pull.type) {
|
||
override def left: Rotation.type × Pull.type = ×(Rotation, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case class SetTruth(name: String) extends ((Bool.type × Pull.type) → Pull.type) {
|
||
override def left: Bool.type × Pull.type = ×(Bool, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case class SetConstraint(name: String) extends ((Constraint.type × Pull.type) → Pull.type) {
|
||
override def left: Constraint.type × Pull.type = ×(Constraint, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object SetNumberRef extends ((Number.type × Number.type × Pull.type) → Pull.type) {
|
||
override def left: Number.type × Number.type × Pull.type = ×(×(Number, Number), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object SetObjectRef extends ((Obj.type × Obj.type × Pull.type) → Pull.type) {
|
||
override def left: Obj.type × Obj.type × Pull.type = ×(×(Obj, Obj), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object SetVectorRef extends ((Vector.type × Vector.type × Pull.type) → Pull.type) {
|
||
override def left: Vector.type × Vector.type × Pull.type = ×(×(Vector, Vector), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object SetRotationRef extends ((Rotation.type × Rotation.type × Pull.type) → Pull.type) {
|
||
override def left: Rotation.type × Rotation.type × Pull.type = ×(×(Rotation, Rotation), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object SetTruthRef extends ((Bool.type × Bool.type × Pull.type) → Pull.type) {
|
||
override def left: Bool.type × Bool.type × Pull.type = ×(×(Bool, Bool), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object SetConstraintRef extends ((Constraint.type × Constraint.type × Pull.type) → Pull.type) {
|
||
override def left: Constraint.type × Constraint.type × Pull.type = ×(×(Constraint, Constraint), Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object ListNumber extends ((Number.type × Number.type) → Number.type) {
|
||
override def left: Number.type × Number.type = ×(Number, Number)
|
||
override def right: Number.type = Number
|
||
}
|
||
case object ListObject extends ((Obj.type × Number.type) → Obj.type) {
|
||
override def left: Obj.type × Number.type = ×(Obj, Number)
|
||
override def right: Obj.type = Obj
|
||
}
|
||
case object ListVector extends ((Vector.type × Number.type) → Vector.type) {
|
||
override def left: Vector.type × Number.type = ×(Vector, Number)
|
||
override def right: Vector.type = Vector
|
||
}
|
||
case object ListRotation extends ((Rotation.type × Number.type) → Rotation.type) {
|
||
override def left: Rotation.type × Number.type = ×(Rotation, Number)
|
||
override def right: Rotation.type = Rotation
|
||
}
|
||
case object ListTruth extends ((Bool.type × Number.type) → Bool.type) {
|
||
override def left: Bool.type × Number.type = ×(Bool, Number)
|
||
override def right: Bool.type = Bool
|
||
}
|
||
case object ListConstraint extends ((Constraint.type × Number.type) → Constraint.type) {
|
||
override def left: Constraint.type × Number.type = ×(Constraint, Number)
|
||
override def right: Constraint.type = Constraint
|
||
}
|
||
case object Increment extends ((Number.type × Pull.type) → Pull.type) {
|
||
override def left: Number.type × Pull.type = ×(Number, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
case object Decrement extends ((Number.type × Pull.type) → Pull.type) {
|
||
override def left: Number.type × Pull.type = ×(Number, Pull)
|
||
override def right: Pull.type = Pull
|
||
}
|
||
|
||
}
|
||
|
||
implicit lazy val fanscript:
|
||
Cartesian[Pin, PinEv, →, T.type, ×] with ArrowLoop[Pin, PinEv, →, T.type, ×, →] =
|
||
new Cartesian[Pin, PinEv, →, T.type, ×] with ArrowLoop[Pin, PinEv, →, T.type, ×, →] {
|
||
|
||
override def duplicate[A <: Pin](implicit a: PinEv[A]): A → (A × A) =
|
||
Duplicate(a.value)
|
||
|
||
override def terminate[A <: Pin](implicit a: PinEv[A]): A → T.type =
|
||
Terminate(a.value)
|
||
|
||
override def loop[A <: Pin, B <: Pin, C <: Pin](f: (A × C) → (B × C)): A → B =
|
||
Loop(f)
|
||
|
||
override def lift[A <: Pin, B <: Pin](f: A → B): A → B =
|
||
f
|
||
|
||
override def id[A <: Pin](implicit a: PinEv[A]): A → A =
|
||
Id(a.value)
|
||
|
||
override def strongProfunctorCategory: Monoidal[Pin, PinEv, →, T.type, ×] =
|
||
this
|
||
|
||
override def first[A <: Pin, B <: Pin, C <: Pin](f: A → B)(implicit c: PinEv[C]): (A × C) → (B × C) =
|
||
bimap(f, id[C])
|
||
|
||
override def second[A <: Pin, B <: Pin, C <: Pin](f: A → B)(implicit c: PinEv[C]): (C × A) → (C × B) = {
|
||
implicit val a: PinEv[A] = f.leftEv
|
||
implicit val b: PinEv[B] = f.rightEv
|
||
val unswapped: (A × C) → (B × C) = first(f)
|
||
andThen(swap[C, A], andThen(unswapped, swap[B, C]))
|
||
}
|
||
|
||
override def profunctorLeftConstraint[A <: Pin, B <: Pin](f: A → B): PinEv[A] =
|
||
f.leftEv
|
||
|
||
override def profunctorRightConstraint[A <: Pin, B <: Pin](f: A → B): PinEv[B] =
|
||
f.rightEv
|
||
|
||
override def swap[A <: Pin, B <: Pin](implicit a: PinEv[A], b: PinEv[B]): (A × B) → (B × A) =
|
||
Swap(a.value, b.value)
|
||
|
||
override implicit def unitConstraint: PinEv[T.type] =
|
||
PinEv.pinValueForT
|
||
|
||
override def associateRight[A <: Pin, B <: Pin, C <: Pin](implicit a: PinEv[A], b: PinEv[B], c: PinEv[C]): ((A × B) × C) → (A × (B × C)) =
|
||
Associate(a.value, b.value, c.value)
|
||
|
||
override def unitorLeft[A <: Pin](implicit a: PinEv[A]): (T.type × A) → A =
|
||
Unit(a.value)
|
||
|
||
override def deunitorLeft[A <: Pin](implicit a: PinEv[A]): A → (T.type × A) =
|
||
Deunit(a.value)
|
||
|
||
override def homLeftConstraint[A <: Pin, B <: Pin](hom: A → B): PinEv[A] =
|
||
hom.leftEv
|
||
|
||
override def homRightConstraint[A <: Pin, B <: Pin](hom: A → B): PinEv[B] =
|
||
hom.rightEv
|
||
|
||
override def andThen[A <: Pin, B <: Pin, C <: Pin](f: A → B, g: B → C): A → C =
|
||
AndThen(f, g)
|
||
|
||
override def compose[A <: Pin, B <: Pin, C <: Pin](f: B → C, g: A → B): A → C =
|
||
andThen(g, f)
|
||
|
||
override implicit def bifunctorApplyConstraint[A <: Pin, B <: Pin](implicit a: PinEv[A], b: PinEv[B]): PinEv[A × B] =
|
||
PinEv.pinValueForProduct[A, B](a, b)
|
||
|
||
override def bifunctorLeftConstraint[A <: Pin, B <: Pin](implicit e: PinEv[A × B]): PinEv[A] =
|
||
new PinEv[A] {
|
||
override val value: A = e.value.a
|
||
}
|
||
|
||
override def bifunctorRightConstraint[A <: Pin, B <: Pin](implicit e: PinEv[A × B]): PinEv[B] =
|
||
new PinEv[B] {
|
||
override val value: B = e.value.b
|
||
}
|
||
|
||
override def bimap[A <: Pin, B <: Pin, C <: Pin, D <: Pin](f: A → C, g: B → D): (A × B) → (C × D) =
|
||
Bimap(f, g)
|
||
|
||
}
|
||
|
||
}
|