Mutability for sequences _only_ guarantees that you&#39;ll be able to swap out the items for different ones (via the `update` method), as you can with e.g. primitive arrays.  It does _not_ guarantee that you&#39;ll be able to make the sequence larger (that&#39;s what the [`Growable`][2] trait is for) or smaller ([`Shrinkable`][3]).

[`Buffer`][1] is the abstract trait that contains `Growable` and `Shrinkable`, not [`Seq`][4].


  [1]: http://www.scala-lang.org/api/current/scala/collection/mutable/Buffer.html
  [2]: http://www.scala-lang.org/api/current/scala/collection/generic/Growable.html
  [3]: http://www.scala-lang.org/api/current/scala/collection/generic/Shrinkable.html
  [4]: http://www.scala-lang.org/api/current/scala/collection/mutable/Seq.html

I&#39;m trying to get hold of the largest value in an array, while still preserving the item labels. I know I can do this by running sort(), but if I do so I simply lose the labels - which makes it pointless for what I need. Here&#39;s the array:

    array(&quot;a&quot;=&gt;1,&quot;b&quot;=&gt;2,&quot;c&quot;=&gt;4,&quot;d&quot;=&gt;5);

Any ideas?

PHP Get Highest Value from Array

I&#39;ve read two really interesting pieces of advice, recently:

 1. In the comments to [this StackOverflow answer][1], @Mike Weller says to leave your asserts on in production code... what&#39;s the performance hit, really? Is there any reason NOT to leave them in? 
 2. In [Vincent Gable&#39;s blog][2], he states that you should prefer `assert` over `NSAssert`... is there any reason NOT to use `assert`? (it&#39;s less letters :))


  [1]: https://stackoverflow.com/questions/1375786/whats-the-point-of-nsassert-actually/1375819#1375819
  [2]: http://vgable.com/blog/2008/12/04/nsassert-considered-harmful/

NSAssert vs. assert: Which do you use, and when?

There&#39;s something I don&#39;t understand about Scala&#39;s [`collection.mutable.Seq`](http://www.scala-lang.org/api/current/index.html#scala.collection.mutable.Seq). It describes the interface for all mutable sequences, yet I don&#39;t see methods to append or prepend elements without creating a new sequence. Am I missing something obvious here?

There are `:+` and `+:` for append and prepend, respectively, but they create new collections — in order to be consistent with the behavior of immutable sequences, I assume. This is fine, but why is there no method like `+=` and `+=:`, like `ArrayBuffer` and `ListBuffer` define, for in-place append and prepend? Does it mean that I cannot refer to a mutable seq that&#39;s typed as `collection.mutable.Seq` if I want to do in-place append?

Again, I must have missed something obvious, but cannot find what…

How to append or prepend on a Scala mutable.Seq

There's something I don't understand about Scala's <a href="http://www.scala-lang.org/api/current/index.html#scala.collection.mutable.Seq" target="_blank" rel="noopener noreferrer"><code>collection.mutable.Seq</code></a>. It describes the interface for all mutable sequences, yet I don't see methods to append or prepend elements without creating a new sequence. Am I missing something obvious here?
There are <code>:+</code> and <code>+:</code> for append and prepend, respectively, but they create new collections — in order to be consistent with the behavior of immutable sequences, I assume. This is fine, but why is there no method like <code>+=</code> and <code>+=:</code>, like <code>ArrayBuffer</code> and <code>ListBuffer</code> define, for in-place append and prepend? Does it mean that I cannot refer to a mutable seq that's typed as <code>collection.mutable.Seq</code> if I want to do in-place append?
Again, I must have missed something obvious, but cannot find what…

Isn&#39;t toList a method that converts something into a List?

If yes so why can&#39;t I use parenthesis with it? I must be missing something more fundamental here.

Here is the example:

    val l = Array(1,2,3).toList // works fine
    
    val l = Array(1,2,3).toList() // gives the error below

&gt; Not enough arguments for method apply: (n: Int)Int in trait
&gt; LinearSeqOptimized. Unspecified value parameter n.



What is the rule for parenthesis in Scala method invocation?

My method definition looks as follows

    def processLine(tokens: Array[String]) = tokens match { // ...

Suppose I wish to know whether the second string is blank

    case &quot;&quot; == tokens(1) =&gt; println(&quot;empty&quot;)

Does not compile.  How do I go about doing this?


  

How do I pattern match arrays in Scala?

E.g. why does

    val list:List[Any] = List[Int](1,2,3)

work, but

    val arr:Array[Any] = Array[Int](1,2,3)

fails (because arrays are invariant). What is the desired effect behind this design decision?

Why are Arrays invariant, but Lists covariant?

Specifically I&#39;m looking at Problem 1 here

http://pavelfatin.com/scala-for-project-euler/

The code as listed is as follows

    val r = (1 until 1000).view.filter(n =&gt; n % 3 == 0 || n % 5 == 0).sum

I can follow everything except for &quot;view&quot;.  In fact if I take out view the code still compiles and produces exactly the same answer.

In Scala, what does &quot;view&quot; do?

In Scala one can write (curried?) functions like this

    def curriedFunc(arg1: Int) (arg2: String) = { ... }

What is the difference between the above `curriedFunc` function definition with two parameters lists and functions with multiple parameters in a single parameter list: 

    def curriedFunc(arg1: Int, arg2: String) = { ... }

From a mathematical point of view this is `(curriedFunc(x))(y)` and `curriedFunc(x,y)` but I can write `def sum(x) (y) = x + y` and the same will be `def sum2(x, y) = x + y`

I know only one difference - this is partially applied functions. But both ways are equivalent for me.

Are there any other differences?

What&#39;s the difference between multiple parameters lists and multiple parameters per list in Scala?

I have the data.frame below. I want to add a column &#39;g&#39; that classifies my data according to consecutive sequences in column `h_no`. That is, the first sequence of h_no `1, 2, 3, 4` is group 1, the second series of `h_no` (1 to 7) is group 2, and so on, as indicated in the last column &#39;g&#39;.

    h_no   h_freq    h_freqsq g
    1     0.09091 0.008264628 1
    2     0.00000 0.000000000 1
    3     0.04545 0.002065702 1
    4     0.00000 0.000000000 1  
    1     0.13636 0.018594050 2
    2     0.00000 0.000000000 2
    3     0.00000 0.000000000 2
    4     0.04545 0.002065702 2
    5     0.31818 0.101238512 2
    6     0.00000 0.000000000 2
    7     0.50000 0.250000000 2 
    1     0.13636 0.018594050 3 
    2     0.09091 0.008264628 3
    3     0.40909 0.167354628 3
    4     0.04545 0.002065702 3



Create a group number for each consecutive sequence

Is there an SQL instruction to retrieve the value of a sequence that does not increment it.

Thanks.

**EDIT AND CONCLUSION** 

As stated by Justin Cave It&#39;s not useful to try to &quot;save&quot; sequence number so


    select a_seq.nextval from dual;

is good enough to check a sequence value.

I still keep Ollie answer as the good one because it answered the initial question. but ask yourself about the necessity of not modifying the sequence if you ever want to do it.



How to retrieve the current value of an oracle sequence without increment it?

Data:
```R
df &lt;- data.frame(
    type   = c(&quot;T&quot;, &quot;F&quot;, &quot;P&quot;, &quot;T&quot;, &quot;F&quot;, &quot;P&quot;, &quot;T&quot;, &quot;F&quot;, &quot;P&quot;, &quot;T&quot;, &quot;F&quot;, &quot;P&quot;), 
    size   = c(&quot;50%&quot;, &quot;50%&quot;, &quot;50%&quot;, &quot;100%&quot;, &quot;100%&quot;, &quot;100%&quot;, &quot;150%&quot;, &quot;150%&quot;, &quot;150%&quot;, &quot;200%&quot;, &quot;200%&quot;, &quot;200%&quot;),
    amount = c(48.4, 48.1, 46.8, 25.9, 26, 24.9, 21.1, 21.4, 20.1, 20.8, 21.5, 16.5)
)
```

	

I need to plot a bargraph of the above data using ggplot (x-axis -&gt; `type`, y-axis -&gt; `amount`, group by `size`). When I used the following code, I am not getting the variable `type` and as well as `size` in the order shown in the data. Please see the figure. I have used the following code for that. 

     ggplot(df, aes(type, amount , fill=type, group=type, shape=type, facets=size)) + 
      geom_col(width=0.5, position = position_dodge(width=0.6)) + 
      facet_grid(.~size) + 
      theme_bw() + 
      scale_fill_manual(values = c(&quot;darkblue&quot;,&quot;steelblue1&quot;,&quot;steelblue4&quot;), 
                        labels = c(&quot;T&quot;, &quot;F&quot;, &quot;P&quot;))

![enter image description here][1] .

For fixing the order issue, I have used a factor method for the variable &quot;type&quot; using the following. Please see the figure also.

    temp$new = factor(temp$type, levels=c(&quot;T&quot;,&quot;F&quot;,&quot;P&quot;), labels=c(&quot;T&quot;,&quot;F&quot;,&quot;P&quot;)) 

![enter image description here][2]

However, now I don&#39;t know how to fix the order for the variable `size`. It should be 50%, 100%. 150%, and 200%.


  [1]: http://i.stack.imgur.com/bPkne.png
  [2]: http://i.stack.imgur.com/qNHnv.png


Fixing the order of facets in ggplot

Assuming that I have a list with a huge number of items,

    l = [ 1, 4, 6, 30, 2, ... ]

I want to get the number of items from that list, where an item satisfies a certain condition. My first thought was:

    count = len([i for i in l if my_condition(l)])

But if the filtered list also has a great number of items, I think that
creating a new list for the filtered result is just a waste of memory.  For efficiency, IMHO, the above call can&#39;t be better than:

    count = 0
    for i in l:
        if my_condition(l):
            count += 1

Is there any functional-style way to get the # of items that satisfy the condition without generating a temporary list?

Get number of items from list (or other iterable) with certain condition

Is there any command that I can run so that I can get all the sequences? 
I am using Oracle 11g. I am using Toad for Oracle to connect to it. I can visually see the sequences in Toad, but I like to know the command line for it.

How can I get all sequences in an Oracle database?

It seems that `Vector` was late to the Scala collections party, and all the influential blog posts had already left.

In Java `ArrayList` is the default collection - I might use `LinkedList` but only when I&#39;ve thought through an algorithm and care enough to optimise. In Scala should I be using `Vector` as my default `Seq`, or trying to work out when `List` is actually more appropriate?

When should I choose Vector in Scala?

I have looked at [this question][1] but still don&#39;t understand the difference between Iterable and Traversable traits. Can someone explain ?


  [1]: https://stackoverflow.com/questions/2602379/in-scala-2-8-collections-why-was-the-traversable-type-added-above-iterable

Scala: What is the difference between Traversable and Iterable traits in Scala collections?

Being new to Scala (2.9.1), I have a `List[Event]` and would like to copy it into a `Queue[Event]`, but the following Syntax yields a `Queue[List[Event]]` instead:

    val eventQueue = Queue(events)

For some reason, the following works:

    val eventQueue = Queue(events : _*)

But I would like to understand what it does, and why it works? I already looked at the signature of the `Queue.apply` function:

    def apply[A](elems: A*)

And I understand why the first attempt doesn&#39;t work, but what&#39;s the meaning of the second one? What is `:`, and `_*` in this case, and why doesn&#39;t the `apply` function just take an `Iterable[A]` ?


What does param: _* mean in Scala?

In [`scala.collection`](http://www.scala-lang.org/api/current/index.html#scala.collection.package), there are two very similar objects [`JavaConversions`](http://www.scala-lang.org/api/current/scala/collection/JavaConversions$.html) and [`JavaConverters`](http://www.scala-lang.org/api/current/scala/collection/JavaConverters$.html). 

* What is the difference between these two objects? 
* Why do they both exist?
* When do I want to use one vs. the other?

What is the difference between JavaConverters and JavaConversions in Scala?

given:

    val m = Map[String, Int](&quot;a&quot; -&gt; 1, &quot;b&quot; -&gt; 2, &quot;c&quot; -&gt; 3)
    m.foreach((key: String, value: Int) =&gt; println(&quot;&gt;&gt;&gt; key=&quot; + key + &quot;, value=&quot; + value))

why does the compiler complain 

    error: type mismatch
    found   : (String, Int) =&gt; Unit
    required: (String, Int) =&gt; ?




Scala Map foreach

Is it bad practice to use mutable objects as Hashmap keys?  What happens when you try to retrieve a value from a Hashmap using a key that has been modified enough to change its hashcode?

For example, given

    class Key
    {
        int a; //mutable field
        int b; //mutable field
    
        public int hashcode()
            return foo(a, b);
        // setters setA and setB omitted for brevity
    }

with code

    HashMap&lt;Key, Value&gt; map = new HashMap&lt;Key, Value&gt;();

    Key key1 = new Key(0, 0);
    map.put(key1, value1); // value1 is an instance of Value

    key1.setA(5);
    key1.setB(10);

What happens if we now call `map.get(key1)`?  Is this safe or advisable?  Or is the behavior dependent on the language?

Are mutable hashmap keys a dangerous practice?

I&#39;m confused on what an immutable type is. I know the `float` object is considered to be immutable, with this type of example from my book:

    class RoundFloat(float):
        def __new__(cls, val):
            return float.__new__(cls, round(val, 2))

Is this considered to be immutable because of the class structure / hierarchy?, meaning `float` is at the top of the class and is its own method call. Similar to this type of example (even though my book says `dict` is mutable):

    class SortedKeyDict(dict):
        def __new__(cls, val):
            return dict.__new__(cls, val.clear())

Whereas something mutable has methods inside the class, with this type of example:
    
    class SortedKeyDict_a(dict):
        def example(self):
            return self.keys()

----------

Also, for the last `class(SortedKeyDict_a)`, if I pass this type of set to it:

    d = ((&#39;zheng-cai&#39;, 67), (&#39;hui-jun&#39;, 68),(&#39;xin-yi&#39;, 2))

without calling the `example` method, it returns a dictionary. The `SortedKeyDict` with `__new__` flags it as an error. I tried passing integers to the `RoundFloat` class with `__new__` and it flagged no errors.

Immutable vs Mutable types

I am writing an Array-derived class in JavaScript and need to know which functions to overload so that I can be aware of changes made to the array.

I know `Array.push()` and `Array.splice()` are mutating. Is there a definitive list of any others?

Which JavaScript Array functions are mutating?

It is a common mistake in Python to set a mutable object as the default value of an argument in a function. Here&#39;s an example taken from [this excellent write-up by David Goodger][1]:

    &gt;&gt;&gt; def bad_append(new_item, a_list=[]):
            a_list.append(new_item)
            return a_list
    &gt;&gt;&gt; print bad_append(&#39;one&#39;)
    [&#39;one&#39;]
    &gt;&gt;&gt; print bad_append(&#39;two&#39;)
    [&#39;one&#39;, &#39;two&#39;]

The explanation why this happens is [here][2].

And now for my question: **Is there a good use-case for this syntax?** 

I mean, if everybody who encounters it makes the same mistake, debugs it, understands the issue and from thereon tries to avoid it, what use is there for such syntax?

  [1]: http://www.omahapython.org/IdiomaticPython.html
  [2]: http://www.omahapython.org/IdiomaticPython.html#default-parameter-values

Good uses for mutable function argument default values?

I have an array I&#39;d like to turn into a `List`, in order to modify the contents of the array.

Stack Overflow has plenty of questions/answers that address `Arrays.asList()` and how it only provides a List view of the underlying array, and how attempting to manipulate the resulting List will generally throw an `UnsupportedOperationException` as methods used to manipulate the list (e.g. `add()`, `remove()`, etc.) are not implemented by the List implementation provided by `Arrays.asList()`.

But I can&#39;t find an example of how to turn an array into a mutable List.  I suppose I can loop through the array and `put()` each value into a new List, but I&#39;m wondering if there&#39;s an interface that exists to do this for me.

Content Type	Original Author	Original Content on Stackoverflow
Question	Jean-Philippe Pellet	View Question on Stackoverflow
Solution 1 - Scala	Rex Kerr	View Answer on Stackoverflow

How to append or prepend on a Scala mutable.Seq

Scala Problem Overview

Scala Solutions

Solution 1 - Scala

NSAssert vs. assert: Which do you use, and when?

PHP Get Highest Value from Array

Attributions