AIMMOTH: oktober 2016

2016-10-23

Rains Poncho (gul) 890kr

Jackor & Ytterplagg, stl. 50 (M), herr
Supersnygg poncho i gult av Rains. Säljes i befintligt skick för 890kr.

https://www.blocket.se/stockholm/Rains_Poncho__gul__69843575.htm?ma=1

Stripe byrå (Sara Larsson) 9 990kr

Supersnygga designbyrån Stripe finns i nyskick! Säljes i befintligt skick för 9 990kr. Nypris cirka 13 000kr.

Från den exklusiva möbelkedjan Svensson i Lammhult: Stripe är en vacker, uppseendeväckande byrå som bär tydliga kännetecken av formgivare Sara Larssons kärlek till det färgstarka. Som vanligt när det gäller A2 Designers är det hantverksmässig tillverkning och hög kvalitet som är ledorden.

Kartell Optic (kub, förvaring) 1000kr

Som nya! Tre i färgerna lila och röd. Dörrar ingår (360kr) men med trasiga fästen.

Säljes i befintligt skick. 500kr/st

Från Kartell: Denna mångsidiga kub är ett spännande inredningsobjekt. Optic är en förvaring i form av en kvadratisk box med antingen en öppen sida eller med dörr. Tack vare att man kan stapla dem på varandra uppstår möjligheten att skapa en vacker hylla, pelare eller ett enstaka litet bord. Ytan är utformad med kvadratiska låga pyramider, vilket skapar en mycket vacker visuell effekt och en "relief" i ytan. Går även att ha utomhus.

Mått: 41 x 41 x 41 cm

https://www.blocket.se/stockholm/Kartell_Optic__kub__forvaring__69842998.htm?ma=1

2016-10-13

Scala Request Uri Combinator Parser

URI Combinator Parser

In my last blog I created a URL parser but the HttpServletRequest is providing only path and query with the method getRequestUri() so I made a request URI parser too.

Code

This code needs the URL parser, see below.

	import scala.util.parsing.combinator.RegexParsers

	case class RequestUriTokens(path : Option[String], query : Option[String])

	/**
	* Useful parser when using HttpServletRequest.getRequestUri()
	*
	* @see javax.servlet.http.HttpServletRequest.getRequestUri()
	*/
	class RequestUriParser extends RegexParsers {

	private val requestUriParser = someRequest

	val notQuestionmark = """[^\?]*""".r
	val any = """.*""".r

	def someRequest = "/" ~> opt(notQuestionmark) ~ opt("?" ~> any) ^^ {
	case path ~ query => new RequestUriTokens(path, query)
	}

	def applyOnUri(uri : String) = parseAll(requestUriParser, uri) match {
	case Success(result, _) => Right(result)
	case Failure(failure, _) => Left(failure)
	case Error(error, _) => Left(error)
	}
	}

	object RequestUriParser {
	lazy val requestUriParser = new RequestUriParser

	def apply(uri : String) = requestUriParser.applyOnUri(uri)
	}

view raw HttpServletRequest Request Uri Parser.scala hosted with ❤ by GitHub

See

Link to the URL parser:
https://gist.github.com/AIMMOTH/b9903387cdf6b9377e9a7f6ca8887281

2016-10-12

Scala URL Parser Combinator

URL Parser Combinator

(updated 2016-10-16)

It has bugged me that there is no parser of an URL so I made one.

Parser Combinator

Scala provides an excellent tool of parsing using a mix of code in DSL (domain specific language) and regular expressions. Together with unapply it's easy to match and take out the matching pieces.

URL

From Wikipedia there are the following parts of an URL (some are optional):

scheme:[//[user:password@]host[:port]][/]path[?query][#fragment]

Code

Enjoy, I won't go into detail other than it breaks down the URL in the following order:

Split URL by

Mandatory scheme
Optional domain
Mandatory path
Optional query and fragment

Domain is split by

Authorization
Domain
Port

Usually a greedy regexp matcher is used until a delimiter.

	// https://github.com/scala/scala-parser-combinators
	import scala.util.parsing.combinator.RegexParsers

	case class UrlTokens(
	scheme : String,
	authorization : Option[(String, Option[String])],
	domain : Option[String],
	port : Option[Int],
	path : String,
	query : Option[String],
	fragment : Option[String]) extends RegexParsers {

	lazy val splitPath = HelperParser.splitPathBySlash(path)
	lazy val splitQueryToValuePairs = query map (HelperParser.splitIntoValuePairs)
	lazy val splitFragmentToValuePairs = fragment map (HelperParser.splitIntoValuePairs)
	}

	/**
	* <p>
	* From Wikipedia:
	* <pre>
	* scheme:[//[user:password@]host[:port]][/]path[?query][#fragment]
	* </pre>
	* </p>
	*
	* <p>
	* Parsing an URL:
	* </p>
	* <ol>
	* <li>Split by mandatory scheme, optional domain, mandatory path and then optional query and fragment</li>
	* <li>If there's a domain split by optional authorization, mandatory domain and optional port</li>
	* <ol>
	* <p>
	* Usually a parser is used by greedy regexp matching until a delimiter.
	* </p>
	*
	* @see http://www.scala-lang.org/files/archive/api/2.11.2/scala-parser-combinators/#scala.util.parsing.combinator.RegexParsers
	*/
	class UrlParser extends RegexParsers {

	def urlParser = scheme ~ opt(domain) ~ path ~ opt(query) ~ opt(fragment) ^^ {
	case scheme ~ domain ~ path ~ query ~ fragment => domain match {
	case Some((authorization, domain, port)) =>
	Right(new UrlTokens(scheme, authorization, Some(domain), port, path, query, fragment))
	case None =>
	Right(new UrlTokens(scheme, None, None, None, path, query, fragment))
	}
	}

	val notSlash = """[^\/]+""".r
	val notDot = """[^\.]+""".r
	val notColon = """[^:]+""".r
	val notAt = """[^@]+""".r
	val notColonOrSlash = """[^:\/]+""".r
	val numbers = """\d+""".r
	val notQuestionmarkOrHash = """[^\?#]+""".r
	val notHash = """[^\#]*""".r
	val any = """.*""".r

	def scheme = notColon <~ ":"

	def domain = "//" ~> opt(authorization <~ "@") ~ notColonOrSlash ~ opt(":" ~> port) <~ "/" ^^ {
	case optionalAuthorization ~ domains ~ optionalPort => (optionalAuthorization, domains, optionalPort)
	}
	def authorization = notColon ~ opt(":" ~> notAt) ^^ { case user ~ optionalPassword => (user, optionalPassword) }
	def port = numbers ^^ { case number => number.toInt }

	def path = notQuestionmarkOrHash
	def query = "?" ~> notHash
	def fragment = "#" ~> any

	def apply(url : String) = toResult(url, urlParser)
	def applyWith(url : String, parser : Parser[_]) = toResult(url, parser)

	def toResult(text : String, parser : Parser[_]) = {
	parseAll(parser, text) match {
	case Success(result, _) => Right(result)
	case Failure(error, _) => Left(error)
	case Error(error, _) => Left(error)
	}
	}
	}

	object UrlParser {
	lazy val urlParser = new UrlParser

	def apply(url : String) = urlParser(url)
	}

	/**
	* Parse common patterns.
	* <ul>
	* <li>Split domain with dot</li>
	* <li>Split path with slash</li>
	* <li>Split query or fragment with ampersand and then create value pairs by split by equals</li>
	* </ul>
	*/
	object HelperParser extends RegexParsers {

	implicit def parserToOption[T](parserResult : ParseResult[T]) = parserResult match {
	case Success(result, _) => Some(result)
	case _ => None
	}

	val notDot = """[^\.]+""".r
	def domainsByDot = repsep(notDot, ".")
	def splitDomainByDot(domain : String) : Option[List[String]] = parseAll(domainsByDot, domain)

	val notSlash = """[^\/]*""".r
	def pathBySlash = repsep(notSlash, "/")
	def splitPathBySlash(path : String) : Option[List[String]] = parseAll(pathBySlash, path)

	val notEquals = """[^\=]+""".r
	def valuePairs = repsep(pair, "&")
	def pair = notEquals ~ "=" ~ opt(notEquals) ^^ {
	case key ~ equal ~ optionalValue => (key, optionalValue)
	}
	/**
	* Split by ambersand (&) and then equals (=)
	*/
	def splitIntoValuePairs(text : String) : Option[List[(String, Option[String])]] = parseAll(valuePairs, text)
	}

view raw UrlParser.scala hosted with ❤ by GitHub

2016-10-11

Javascript monad Maybe with Monet

The Monad Maybe

Maybe aka option or optional is very useful for preventing null. Using the Javascript library Monet it's quite easy to use this monad.

Preventing null

You have a variable but don't know if it's null. With Maybe, you wrap it and test if it is "some".

	var couldBeNull = Maybe.fromNull(suspiciousVariable);
	if (couldBeNull.isSome()) {
	// Ok
	} else {
	// KO!
	}

view raw Monet Maybe.js hosted with ❤ by GitHub

Transform or map

Monads are also useful to transform a value to another. Think of this example:

	var text = "10";
	var integer = parseInt(text);
	var array = new Array(integer);
	for (var i=0; i<integer; i++) {
	array[i] = i;
	}
	console.log(array); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

view raw Old.js hosted with ❤ by GitHub

Each step is instancing a variable and making a "halt". With a monad, you can "go with the flow" and do it all in one step:

	console.log(
	Some("10").map(function(text) {
	return parseInt(text);
	}).map(function(integer) {
	return new Array(integer);
	}).map(function(array) {
	for (var i=0; i<array.length; i++) {
	array[i] = i;
	}
	return array;
	}).some();
	); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

view raw Monet Maybe Mapping.js hosted with ❤ by GitHub

Sample

https://jsfiddle.net/yapdd5xv/15/

2016-10-07

Monad implementation in Scala with example

Monad in Scala

Monad

Difficult to explain but useful for nice code.

Implementation in Scala

This is a simple implementation of a monad in Scala which makes Any able to use monad's definition called flatmap (>>=).

/**

* Monad implementation

final case class Monad[T](val value : T) {

def >>=[S](f : T => S) : Monad[S] = {

new Monad(f(value))

}

override def toString = String.valueOf(value)

}

/**

* Implicit wrap Any to a Monad.

implicit def anyToMonad[T](value : T): Monad[T] = new Monad[T](value)

Example

Using this implementation, Any can use flatmap wihch could be used as follows.

// Example

"10" >>= Integer.parseInt >>= (_ + 10) >>= (0 to _) >>= println

Prints

Range(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)

Fiddle

Try it out at Scala Fiddle!

https://scalafiddle.io/sf/nMVS7E1/2