This is a small console app to create scala based "tiny types".
Why tiny types? This way you pay no penalty in adding more domain specific information to your project. For example, a first name isn't the same as a last name. And your address isn't the same as your age, so why would you represent them the same?
To install run the install script.
Run tiny-types and give it the path to the defintions file (which is just a comma sepearated case class name followed by target type (Fully qualified)),
and the output package type of the form "com.foo.bar". It will write two files into "src/main/scala/com/foo/bar" being the case class tiny
definitions as well as the implicit conversions.
"io.paradoxical" %% "tiny-types" % "1.1"
tiny-types 1.0
Usage: tiny-types [options]
-d <value> | --definitionsFile <value>
The json definitions file
There are two camps of tiny type aliasing, one is case class wrapping (which is the default) and the other is type tagging.
Type tags are inspired by this blog post: https://coderwall.com/p/l-plmq/adding-semantic-to-base-types-parameters-in-scala
As an example, given the following input file
[
{
"package": "io.paradoxical.scala.tiny.data",
"folder": "src/test/scala",
"tiny": {
"bar": "String",
"foo": "String",
"bizBaz": "Int",
"Data" : "java.util.UUID"
}
}
]
We'll get
package io.paradoxical.scala.tiny.data
case class bar(data : String) extends AnyVal
case class foo(data : String) extends AnyVal
case class bizBaz(data : Int) extends AnyVal
case class Data(data : java.util.UUID) extends AnyVal
object Conversions{
implicit def convertbar(i : bar) : String = i.data
implicit def convertfoo(i : foo) : String = i.data
implicit def convertbizBaz(i : bizBaz) : Int = i.data
implicit def convertData(i : Data) : java.util.UUID = i.data
}With the following input file
[
{
"package": "io.paradoxical.scala.tiny.data.typetag2",
"folder": "src/test/scala",
"format": "TypeTag",
"tiny": {
"workId": "String",
"funId": "Int",
"barId": "Int",
"tableId": "java.util.UUID"
}
}
]
We'll get
package io.paradoxical.scala.tiny.data.typetag2
object TinyType {
type Tagged[U] = { type Tag = U }
trait TinyWorkId
type workId = String with Tagged[TinyWorkId]
def WorkId(rawType: String): workId = rawType.asInstanceOf[workId]
trait TinyFunId
type funId = Int with Tagged[TinyFunId]
def FunId(rawType: Int): funId = rawType.asInstanceOf[funId]
trait TinyBarId
type barId = Int with Tagged[TinyBarId]
def BarId(rawType: Int): barId = rawType.asInstanceOf[barId]
trait TinyTableId
type tableId = java.util.UUID with Tagged[TinyTableId]
def TableId(rawType: java.util.UUID): tableId = rawType.asInstanceOf[tableId]
}Which can be used now:
import io.paradoxical.scala.tiny.data.typetag2.TinyType._
val funId: funId = FunId(1)
val barId: barId = BarId(1)
acceptsAlias(FunId(1))
// acceptsAlias(barId) [ fails because barId is not a fooId even though they are both int ]
acceptsAlias(funId)
def acceptsAlias(funId: funId) = funId#compdef tiny-types
local arguments
arguments=(
'-d[Json tiny types descriptor]:descriptor file:_files'
)
_arguments -s $argumentsDrop this into your zsh functions folder as _tiny-types and you're good to go!
