This document appears to describe domain modeling and architecture using Scala. It includes code snippets defining traits for resources, ontologies, relational entities, graph vertices and edges. It also shows implementations of a Chromosome entity and methods to enrich domain models, filter for XML models, and retrieve ingoing edges. The code defines a type hierarchy for domain models with relational, graph and XML capabilities.

1. Scala
Domain
Modeling
and
Architecture
Experience
Report
Hossam
Karim

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

11.
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
!

12.
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
!

13.
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
!

14.
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
!

15.
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
!

16. 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]
}

17. 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]
}

18. 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] = . . .
}

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

20. 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)
}

21. 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])

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

23. (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

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

28. 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]!
}!

29. 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 =>
}

30. 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]
}

31. 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])
}

32. 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]
}

33. 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]
}

34. 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

35. 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)

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

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

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

40. 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 = {
...
}
.
.
.
}

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

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

44. Thank
You