Scala Domain Modeling and Architecture

Scala Domain Modeling and Architecture Experience Report

Hossam Karim

for {! ! locus ← Chromosome ⤞ Gene ⤞ Locus! if Locus ∈ range! ! path ← locus ⤞ Sequence ⤞ nucleotide! if nucleotide alignment (_ > 89)! ! } yield path!

inputMessage >>= fasta >>= { case n: Nucleotide ⇒ ! ("media" → "nucleotide") ~> n.giNumber case _: AminoAcid ⇒ ! fail[String](! "Expected a ‘nucleotide’ Sequence") case _ ⇒ ! fail[String](! "Expected a ‘single’ Sequence representation”) } >>= { for { query ← meta.Sequence ⤞ meta.nucleotide if meta.nucleotide.giNumber === _ } yield query } >>= xml !





trait Message[A, H] { val body: Validation[H, Option[A]] val headers: H } trait MessageBuilder { def build[A, H: Monoid]( body: Validation[H, Option[A]], headers: H): Message[A, H] }

trait Message[A, H] { val body: Validation[H, Option[A]] val headers: H } trait MessageBuilder { def build[A, H: Monoid]( body: Validation[H, Option[A]], headers: H): Message[A, H] }

implicit def m2m[H]! (implicit builder: MessageBuilder, ! monoid: Monoid[H]) =! new Monad[({type λ[α] = Message[α, H]})#λ] { def pure[A](a: => A): Message[A, H] = . . .! def bind[A, B]! (a: Message[A, H], ! f: (A) => Message[B, H]): Message[B, H] = . . . }

def pure[A](a: => A) = ! builder.build[A, H](Success(Option(a)), ∅[H])

def bind[A, B](! m: Message[A, H], ! f: (A) => Message[B, H]): Message[B, H] = {! val mb: Message[B, H] = m.body match { case Success(Some(value)) ⇒ f(value) case Success(None) ⇒! builder.build[B, H](! Success(Option.empty[B]), ∅[H]) case Failure(a) ⇒! builder.build[B, H](! Failure(a), ∅[H] |+| a) }! builder.build[B, H](mb.body, m.headers |+| mb.headers) }

implicit object BasicMessageBuilder extends MessageBuilder { def build[A, H: Monoid](! body: Validation[H, Option[A]], headers: H) = BasicMessage(body, headers) } !implicit object DiagnosisMessageBuilder extends! MessageBuilder { def build[A, H: Monoid](! body: Validation[H, Option[A]], headers: H) = DiagnosisMessage(body, headers) } def body[A](value: A)(implicit builder: MessageBuilder) :! Message[A, HL] = builder.build(Success(Some(value)), List.empty[Header])

import Basic._!//import Diagnosis._!//import Transactional._!!gene map { for (! e ← meta.Chromosome ⤞ meta.Gene ! if meta.Gene.uuid === _.uuid! ) yield e } >>= search

(genex <**> geney) (_ ++ _) >>= header("media-type", "application/vnd.x.gene+json") >>= json for { m ← body(<gene xmlns="urn:model:gene:1.0">...</gene>) gene ← xml(m) } yield gene gene map { for { e ← meta.Gene ⤞ meta.Gene.uuid if meta.Gene.uuid === _.uuid } yield e } >>= search

import scalaz._!import Scalaz._!// profit!!

trait Resource {! val name: String!} ! trait Ontology extends Resource {! val nestingOntology: Option[Ontology]! val nestedOntology: List[Ontology]! val ownedType: List[Type]! val ownedRelation: List[Relation]!}!

trait GraphResource { this: Resource => } trait GraphVertex extends GraphResource { this: Entity => val graphFeatures: List[PrimitiveFeature] val master: Boolean val rootToMasterEdge: GraphEdge with Relation val masterToSelf: Option[GraphEdge with Relation] = None } trait GraphEdge extends GraphResource { this: Relation => }

trait RelationalResource { this: Resource => } trait NamedRelationalResource extends RelationalResource { this: Resource => val relationalName: String } trait RelationalEntity extends NamedRelationalResource { this: Entity => } trait RelationalCompositeFeature extends RelationalResource { this: CompositeFeature => val mapping: Map[String, String] }

object Chromosome extends Entity with RelationalEntity! with GraphVertex with XmlElement { self => sealed trait ChromosomePart { val ownerType = self } // Ontology Trait val featuringType = self val ownedFeature = chromatine :: Nil // XML Trait val namespace = "urn:domain:chromosome:1.0" val prefix = "chr" // Features val chromatine = new Chromatine( name = "chromatine", ownerType = Chromosome, mapping = Map.empty[String, String]) }

implicit def enrich[A <: DomainModel](model: A) = new { def metamodel: Option[Type] = Ontology.typeOf(model) } def xmlFilter[A <: DomainModel] = (model: A) ⇒ model.metamodel match { case Some(_: XmlElement) ⇒ body(XmlModel[A](model)) case _ ⇒ fail[XmlModel[A]]! ("No XmlElement meta-model definition could be found") } def ingoingEdges[A <: DomainModel] = (model: A) ⇒ model.metamodel match { case Some(vertex: GraphVertex) ⇒ ! Ontology.edges.filter(_.target == vertex) case _ ⇒ List.empty[GraphEdge] }

implicit def enrich[A <: DomainModel](model: A) = new { def metamodel: Option[Type] = Ontology.typeOf(model) } def xmlFilter[A <: DomainModel] = (model: A) ⇒ model.metamodel match { case Some(_: XmlElement) ⇒ body(XmlModel[A](model)) case _ ⇒ fail[XmlModel[A]]! ("No XmlElement meta-model definition could be found") } def ingoingEdges[A <: DomainModel] = (model: A) ⇒ model.metamodel match { case Some(vertex: GraphVertex) ⇒ ! Ontology.edges.filter(_.target == vertex) case _ ⇒ List.empty[GraphEdge] }

trait Type extends Resource trait SimpleType extends Type trait Entity extends Type!! trait Relation extends Type trait Feature[+T <: Type] extends Resource trait SimpleFeature[+T <: SimpleType] extends Feature[T] trait PrimitiveFeature extends SimpleFeature[Primitive] trait EnumerationFeature extends SimpleFeature[Enumeration] trait CompositeFeature extends SimpleFeature[Composite] trait Primitive extends SimpleType trait Enumeration extends SimpleType trait Composite extends SimpleType

trait PrimitiveLogic { val resource: Primitive def ===[A](value: Primitive[A]): Operator = . . . def in[A](values: PrimitiveList[A]): Operator = . . . } def find(operator: Operator): Option[T] def list(operator: Operator): List[T]!

import PrimitiveLogic._ dao list (Locus.locusUUID in list) dao find (Locus.locusUUID === uuid)

import Logic._ val validation = Sequence.nucleotide.accession.accessionNumber !== x import GraphOps._ val path = Sequence.nucleotide ⤞ Sequence.protein ⤞ Locus.typeOfGene where (_ !== y)

for {! ! locus ← Chromosome ⤞ Gene ⤞ Locus! if Locus ∈ range! ! path ← locus ⤞ Sequence ⤞ nucleotide! if nucleotide alignment (_ > 89)! ! } yield path!

trait Qvt[PIM, Query, View, PSM] { def query(pim: PIM): List[Query] def view(query: Query): View def transform(view: View): PSM }

class GraphSimpleQvt( ontologyProfile: OntologyProfile, graphProfile: GraphProfile) extends SimpleQvt[Model, Package, GraphOntology] { def query(pim: Model) = { walk[Package](pim)(_.getNestedPackages). filter(graphProfile.graphPredicate) } def transform(view: Package) = graph(view) def graph(element: Package): GraphOntology = { ... } . . . }

def walk[A] (element: A) (f: A => Iterable[A]): List[A] = { val children = f(element).toList children ++ ! (children.flatMap(walk(_, f))) }

def packageName(element: Package): String = Stream! .iterate(element)(_.getNestingPackage) .takeWhile(!_.isInstanceOf[Model]) .map(_.getName) .reverse .mkString(".") //.scala rocks !!

Thank You

Scala Domain Modeling and Architecture

Technology