1 /*
2 
3  Copyright 2018 Sebastian B. Galkin
4 
5  This file is part of paraseba/scaladores-may-2018-talk.
6 
7  paraseba/scaladores-may-2018-talk is free software: you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation, either version 3 of the License, or
10  (at your option) any later version.
11 
12  paraseba/scaladores-may-2018-talk is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
19 
20  */
21 
22 package monoid.diagrams
23 
24 import scala.collection.immutable._
25 import monoid.monoids._
26 
27 
28 object Diagrams {
29   import SemigroupSyntax._
30 
31   sealed trait Prim
32   final case class Point() extends Prim
33   final case class Line() extends Prim
34   final case class Ellipse() extends Prim
35 
36   final case class Dual[M](undual: M)
37 
38   implicit def dualMonoid[M:Monoid]: Monoid[Dual[M]] = new Monoid[Dual[M]] {
39     def zero = Dual(implicitly[Monoid[M]].zero)
40     def append(a: Dual[M], b : => Dual[M]) = Dual(b.undual |+| a.undual)
41   }
42 
43   def wSemi[Out, In:Semigroup](unwrap: Out => In, wrap: In => Out): Semigroup[Out] = new Semigroup[Out] {
44     def append(x:Out, y: => Out) = wrap(unwrap(x) |+| unwrap(y))
45   }
46 
47   def wMon[Out, In:Monoid](unwrap: Out => In, wrap: In => Out): Monoid[Out] = new Monoid[Out] {
48     def append(x: Out, y: => Out) = wrap(unwrap(x) |+| unwrap(y))
49     def zero = wrap(implicitly[Monoid[In]].zero)
50   }
51 
52   type P2 = (Double, Double)
53   type V2 = (Double, Double)
54   def v2mul(s: Double, v: V2): V2 = v match {
55     case (x,y) => (s*x, s*y)
56   }
57 
58 
59   import SimpleMonoids._
60 
61   final case class Diagram1(primitives: Dual[List[Prim]])
62 
63   final case class Max[A](unmax: A)
64   final case class Min[A](unmin: A)
65 
66   implicit def maxSemi[A:Ordering]: Semigroup[Max[A]] = new Semigroup[Max[A]] {
67     def append(a: Max[A], b: => Max[A]): Max[A] = Max(Ordering[A].max(a.unmax, b.unmax))
68   }
69 
70   implicit def minSemi[A:Ordering]: Semigroup[Min[A]] = new Semigroup[Min[A]] {
71     def append(a: Min[A], b: => Min[A]): Min[A] = Min(Ordering[A].min(a.unmin, b.unmin))
72   }
73 
74   final case class EnvelopeBad(f: V2 => Max[Double])
75   final case class Envelope(f: Option[V2 => Max[Double]])
76 
77   @SuppressWarnings(Array("org.wartremover.warts.Throw"))
78   @SuppressWarnings(Array("org.wartremover.warts.ToString"))
79   def envelopeP(p: Prim): Envelope = {throw new Exception(p.toString)}
80 
81   @SuppressWarnings(Array("org.wartremover.warts.Throw"))
82   @SuppressWarnings(Array("org.wartremover.warts.ToString"))
83   def translateP(v: V2, p: Prim): Prim = {throw new Exception(p.toString + v.toString)}
84 
85   def envelope(d: Diagram1): Envelope = mconcat(d.primitives.undual.map(envelopeP))
86   def translate(v: V2, d: Diagram1): Diagram1 = Diagram1(Dual(d.primitives.undual.map(translateP(v, _))))
87 
88   def beside(v: V2, d1: Diagram1, d2: Diagram1): Diagram1 =
89     (envelope(d1).f, envelope(d2).f) match {
90       case (Some(f1), Some(f2)) => d1 |+| translate(v2mul(f1(v).unmax + f2(v).unmax, v), d2)
91       case _ => d1 |+| d2
92     }
93 
94   object Envelope {
95     val badSemi: Semigroup[EnvelopeBad] = wSemi(_.f, EnvelopeBad(_))
96 
97     implicit val monoid: Monoid[Envelope] = wMon(_.f, Envelope(_))
98 
99   }
100 
101 
102   final case class TraceBad(f: P2 => V2 => Min[Double])
103   final case class Trace(f: P2 => V2 => Option[Min[Double]])
104 
105   @SuppressWarnings(Array("org.wartremover.warts.Throw"))
106   @SuppressWarnings(Array("org.wartremover.warts.ToString"))
107   def traceP(p: Prim): Trace = {throw new Exception(p.toString)}
108 
109   object Trace {
110     val semiBad: Semigroup[TraceBad] = wSemi(_.f, TraceBad(_))
111     implicit val monoid: Monoid[Trace] = wMon(_.f, Trace(_))
112 
113   }
114 
115   object Diagram1 {
116     implicit val monoid: Monoid[Diagram1] = wMon(_.primitives, Diagram1(_))
117   }
118 
119   final case class Diagram2 private (primitives: Dual[List[Prim]], env: Envelope, tr: Trace)
120   def envelope2(d: Diagram2): Envelope = d.env
121   def trace2(d: Diagram2): Trace = d.tr
122 
123   def primDiag(p: Prim): Diagram2 = Diagram2(Dual(List(p)), envelopeP(p), traceP(p))
124 
125   object Diagram2 {
126     def mkDiag(ps: List[Prim]): Diagram2 = mconcat(ps.map(primDiag))
127 
128     def d2Tuple(d: Diagram2): (Dual[List[Prim]], (Envelope, Trace)) =  (d.primitives, (d.env, d.tr))
129     def tuple2d2(t: (Dual[List[Prim]], (Envelope, Trace))): Diagram2  =  Diagram2(t._1,t._2._1,t._2._2)
130 
131     implicit val monoid: Monoid[Diagram2] = wMon(d2Tuple, tuple2d2)
132   }
133 
134 }