You can also just use `Option(myValue)` which will convert null to `None` and non-null to `Some`.

You can wrap any object in an `Option` like this:

    val opt = Some(&quot;foo&quot;)

You can just wrap your object in Some class

    val myField = Some(myValue)

Or if you dont have Anything, pass 

    None

Its called Option pattern

http://www.codecommit.com/blog/scala/the-option-pattern

If you want to convert empty string to None more universal solution is: `Option(str).filter(_.nonEmpty)`



I am new to Javascript and just started fiddling around with Meteor out of curiosity. What really surprises me, is that it seems that all HTML content gets combined into a single page.

I suspect there is a way to introduce some handling of URLs directing to special pages. It seems that the &quot;todo&quot; example is capable of doing this via some kind of `Router` class. Is that the &quot;canonical&quot; way of URL handling?

Assuming I can handle URLs, how would I structure my HTML code to display separate pages? In my case they could each have completely separate sets of data, so no HTML code needs to be shared at all.

How do I create multi-page applications with Meteor?

Seems like the following code should return a true, but it returns false. 

    var a = {};
    var b = {};
    
    console.log(a==b); //returns false
    console.log(a===b); //returns false


How does this make sense?

Why are two identical objects not equal to each other?

When I&#39;m trying to affect a value of type String in a field of type Option[String] I get the following error :


    type mismatch; found : String required: Option[String]


How can I affect value `myValue:String` into field `myField:Option[String]` ?

How to set a String in a Option[String]?

When I'm trying to affect a value of type String in a field of type Option[String] I get the following error :
<pre><code class="hljs language-rust">type mismatch; found : String required: Option[String]
</code></pre>
How can I affect value <code>myValue:String</code> into field <code>myField:Option[String]</code> ?

I am trying to issue a simple POST request to a webservice which returns some XML in Scala.

It seems that [Dispatch][1] is the standard library used for this task, but I cannot find documentation for it. The main site, which I link above, explains at length what is a promise and how to do asynchronous programming, but does not actually document the API. There is a [periodic table][2] - which looks a bit scary - but it only seems useful to people who already know what to do and only need a reminder for the cryptic syntax.

It also seems that [Scalaz has some facility for HTTP][3], but I cannot find any documentation for it either.


  [1]: http://dispatch.databinder.net/Dispatch.html
  [2]: http://www.flotsam.nl/dispatch-periodic-table.html
  [3]: http://scalaz.github.com/scalaz/scalaz-2.9.1-6.0.4/doc.sxr/scalaz/http/request/Method.scala.html

Doing HTTP request in Scala

I am really interested in finding out where the differences are, and more generally, to identify canonical use cases where HLists cannot be used (or rather, don&#39;t yield any benefits over regular lists).

(I am aware that there are 22 (I believe) ``TupleN`` in Scala, whereas one only needs a single HList, but that is not the kind of conceptual difference I am interested in.)

I&#39;ve marked a couple of questions in the text below. It might not actually be necessary to answer them, they are more meant to point out things that are unclear to me, and to guide the discussion in certain directions.

### Motivation

I&#39;ve recently seen a couple of answers on SO where people suggested to use HLists (for example, as provided by [Shapeless][1]), including a deleted answer to [this question][2]. It gave rise to [this discussion][3], which in turn sparked this question.

### Intro

It seems to me, that hlists are only useful when you know the number of elements and their precise types statically. The number is actually not crucial, but it seems unlikely that you ever need to generate a list with elements of varying but statically precisely known types, but that you don&#39;t statically know their number. **Question 1:** Could you even write such an example, e.g., in a loop? My intuition is that having a statically precise hlist with a statically unknown number of arbitrary elements (arbitrary relative to a given class hierarchy) just isn&#39;t compatible.

### HLists vs. Tuples

If this is true, i.e, you statically know number and type - **Question 2:** why not just use an n-tuple? Sure, you can typesafely map and fold over an HList (which you can also, but **not** typesafely, do over a tuple with the help of ``productIterator``), but since number and type of the elements are statically known you could probably just access the tuple elements directly and perform the operations.

On the other hand, if the function ``f`` you map over an hlist is so generic that it accepts all elements - **Question 3:** why not use it via ``productIterator.map``? Ok, one interesting difference could come from method overloading: if we had several overloaded ``f``&#39;s, having the stronger type information provided by the hlist (in contrast to the productIterator) could allow the compiler to choose a more specific ``f``. However, I am not sure if that would actually work in Scala, since methods and functions are not the same.

### HLists and user input

Building on the same assumption, namely, that you need to know number and types of the elements statically - **Question 4:** can hlists be used in situations where the elements depend on any kind of user interaction? E.g., imagine populating an hlist with elements inside a loop; the elements are read from somewhere (UI, config file, actor interaction, network) until a certain condition holds. What would the type of the hlist be? Similar for an interface specification getElements: HList[...] that should work with lists of statically unknown length, and that allows component A in a system to get such a list of arbitrary elements from component B.
 
  [1]: https://github.com/milessabin/shapeless
  [2]: https://stackoverflow.com/questions/11815908/valid-type-casting-of-both-covariant-and-contravariant-class-at-runtime-in-scala
  [3]: https://chat.stackoverflow.com/rooms/14938/discussion-between-mhs-and-edmondo1984

Are HLists nothing more than a convoluted way of writing tuples?

How do you declare and initialize a variable to be used locally in a Play2 Scala template?

I have this:

    @var title : String = &quot;Home&quot;

declared at the top of the template, but it gives me this error:


    illegal start of simple expression &quot;&quot;&quot;),_display_(Seq[Any](/*3.2*/var)),format.raw/*3.5*/(&quot;&quot;&quot; title : String = &quot;Home&quot;


Declare variable in a Play2 scala template

How do I split a sequence into two lists by a predicate?

Alternative: I can use `filter` and `filterNot`, or write my own method, but isn&#39;t there a better more general (built-in) method ?

How to split a sequence into two pieces by predicate?

All I know about TypeTags is that they somehow replaced Manifests. Information on the Internet is scarce and doesn&#39;t provide me with a good sense of the subject.

So I&#39;d be happy if someone shared a link to some useful materials on TypeTags including examples and popular use-cases. Detailed answers and explanations are also welcome.

Content Type	Original Author	Original Content on Stackoverflow
Question	i.am.michiel	View Question on Stackoverflow
Solution 1 - Scala	Channing Walton	View Answer on Stackoverflow
Solution 2 - Scala	Kim Stebel	View Answer on Stackoverflow
Solution 3 - Scala	FUD	View Answer on Stackoverflow
Solution 4 - Scala	Roman Kazanovskyi	View Answer on Stackoverflow

How to set a String in a Option[String]?

Scala Problem Overview

Scala Solutions

Solution 1 - Scala

Solution 2 - Scala

Solution 3 - Scala

Solution 4 - Scala

Why are two identical objects not equal to each other?

How do I create multi-page applications with Meteor?

Attributions