Elance Scala Test Answers



When importing all the names of a package or class, which character do you use instead of " * "?

"_"
"$"
"@"
"&"

 

 

What is the defaut parameter call semantics?

By Inference
By Value
By Name
By Reference

 

 

What is the largest Tuple that Scala supports?

16
22
20
2

 

 

What is a higher-order function?

Scala does not support higher-order functions
Higher-order functions are parameterless functions that return themselves
Higher-order functions are functions that return functions
Higher-order functions are functions that take other functions as parameters.

 

 

When a class inherits from a trait, it inherits all the code contained in the trait and implements the trait's:

Arguments
Interface
Framework
Platform

 

 

Everything, including numbers and functions, are _______ in Scala.

Objects
Operations
Methods
Booleans

 

 

Scala's "Unit" roughly corresponds to which Java type?

"get"
"null"
"void"
"bool"

 

 

What is a class with a single instance?

A mono object
A singleton object
A static object
A single argument

 

 

When no super-class is specified, ______ is implicitly used.

scala.importRef
You must always specify super-class
scalac use.ref
scala.AnyRef

 

 

What is the name of the Scala compiler?

"cScala"
"scala.comp"
"scalacom"
"scalac"

 

 

Which of the following best describes Scala?

An object oriented language
A functional language
All of these choices describe Scala
A language that runs on the VM

 

 

True or False? Like pre 1.5 Java, Scala suffers from lack of genericity.

True
False

 

 

Does Scala support the return keyword?

Yes, but it is not idiomatic Scala and therefor discouraged.
No
Yes, all methods and functions must have at least one return statement.
Yes, but only for traits.

 

 

True or False? Multiple classes can be imported from the same package by enclosing them in curly braces {}.

False
True

 

 

Scala is:

An advanced Java language implemented by Martin Odersky
An object-functional language that supports functional programming constructs
A pure functional programming language
A dynamic language that can be used to program in object-oriented style efficiently
An advanced Object-Oriented Language much better than Java that runs on the JVM

 

 

What is an expression following the "if" keyword?

A tree
An array
A guard
A wild-card

 

 

Which statement best describes an Iterator

Scala does not support Iterators
An Iterator is a stream of incoming items where advancing to the next item consumes the current item
An Iterator trait is mixed into all collection types
An iterator is a collection type

 

 

True or False? Methods taking one argument can be used with infix syntax?

False
True

 

 

Explain how "abc".length returns 3

A subclass of java.lang.String is generated at runtime, adding the `length` method to its signature.
All string literals can be processed by Scala String interpreter.
All string literals are an instance of scala.collection.immutable.StringOps
An implicit conversion converts the java.lang.String into a scala.collection.immutable.StringOps, which supports a length method.

 

 

True or False? Scala compiler will never require you to specify the result type of a function.

False
True

 

 

What is the value of the following expression? { val a = List(1,2,3) val b = List(4,5,6) (a,b).zipped.map(_+_) }

List(1,2,3,4,5,6)
(List(1,2,3),List(4,5,6))
List(5,7,9)
21
List((1,4),(2,5),(3,6))

 

 

Which of the following is a pattern matching any value, without giving it a name, represented by " _ "?

A simple class
A function
A placeholder
A guard

 

 

Witch one of the following operators is use for sequencing Parsers

!
*
~
|

 

 

It is possible to override methods inherited from a _____ in Scala.

Function-class
Base-class
Super-script
Super-class

 

 

Which statement is true about sealed classes.

A sealed class' instances cannot be modified.
A sealed class may not be directly inherited, except if it is defined in the same source file.
There is no such thing as a sealed class.
A subclass of a sealed class can inherited anywhere only within the same package.

 

 

Does Scala support tail-call recursion?

Yes, the JVM runtime supports tail-call optimization.
Partly, because the stack is infinite in Scala.
No
Partly at the compiler level. The compiler will try and unwind the recursive call into a loop.

 

 

Which statement best describes a partial function?

A partially defined function.
An internal function type that is used by the scala.collection.immutable package.
A function that support currying
When applying the function, you do not pass in arguments for all of the parameters defined by the function, but only for some of them, leaving the remaining ones blank

 

 

What is the tool "schema2src" used for?

Currying
Unifying types
Sealing classes
Data-binding

 

 

Describe class AnyRef

AnyRef is the root Object in Scala
All types except the value types descend from AnyRef
AnyRef is derived from AnyVal
There is no such class

 

 

Scala supports which types of polymorphism?

None of these
Subtype and parametric
Parametric
Subtype, ad-hoc and parametric polymorphism
Ad-hoc and parametric

 

 

In the expression: List(1,2,3) reduceLeft ( (a,b) => a+b ) `b` refers to:

The next element in the list
The current sum while iterating through the list
The "fold" operation
The return value for the expression

 

 

Classes in Scala, in contrast to Java, can have ______.

Constructs
Functions
Concepts
Parameters

 

 

Which statement about case classes is false?

You can construct instances of these classes without using the new keyword
Case classes as sealed and therefor cannot be extended
The toString method is automatically redefined
The equals method is automatically redefined

 

 

What is the result type of the following expression? List(1, 2, true, false)

List[AnyVal]
List[Boolean]
List[Int]
List[Any]
List[AnyRef]

 

 

The following code will > var x=100; var y=200; x->y

a Tuple with Arity 2
automatically create a List[T] with x and y as members with T of 'Int' type
assign 100 to variable y
treat x and y as same references in the further code
produce a compile error

 

 

A valid description of a covariant type parameter would be:

A type parameter which is allowed to vary up for super types.
A type parameter which is allowed to vary down as the class is subtyped.
A type parameter which is fixed for super types.
A type parameter which is fixed when the class is subtyped.

 

 

`Nil` is generally the same as:

List()
Nothing
null
None

 

 

In Scala, type parameters and abstract types may be constrained by a _____.

Type call
Type bound
Type safe
Type function

 

 

If you are defining scala classes in a 'package examplepackage', and want to ensure that a function 'foo' is only accessible by classes defined in the same package, how would you declare that function?

def foo={...} //default access
private[examplepackage] def foo = {...}
package def foo={...}//package private
[examplepackage]private def foo={...}
package[examplepackage] def foo={...}

 

 

What would be the result of: Option[String]("hi") match { case None=> "hello!" }

Nothing would happen because "hi" is not of type "None"
The statement would return "hello!"
A NullPointerException would be thrown.
A MatchError would be thrown.

 

 

In the expression: List(1,2,3).foldLeft(x){case (a,b) => a+b} `x` is:

A default value, only used if the list is empty
The "accumulator," which is the initial value for `a`
A list, to which the results are appended.
The "accumulator," which is the initial value for `b`

 

 

True or False? Scala provides static members (members or fields).

False
True

 

 

Which statement about pattern matching is true?

Patterns do not work with structural types
The order of the pattern match is irrelevant
The case set must be exhaustive
Pattern matching does not work with case classes

 

 

Which statement about List is false?

List is a proxy for java.util.ArrayList
A List is covariant
A List is optimal for last-in-first-out (LIFO), stack-like access patterns
A List is a finite immutable sequence

 

 

How would you define the method: def +(a:Int):Int in a Java interface that will be overriden or used in Scala code?

public int $plus(int a)
public int %plus(int a)
private int $plus(int a)
You can't define a scala operator using Java source code.
public int #plus(int a)

 

 

True or False? In the Interpreter, you can define a new val with a name that was already used before.

False
True

 

 

What would be returned by the following function: def foo(l:List[Int]) = { var x=l.head; l.collect{ case a:Int if a>x => x=a; a }; x } When passed: List(2,4,6,8,6,3,1)

1
8
Nothing, there's no return value.
2
30

 

 

`() => Unit` is best described as

`() => Unit` is not valid Scala
A pure function
A function literal
A procedure type definition

 

 

What is a lazy var?

A variable that is only evaluated once
A variable that once evaluated can only be referenced by the creating scope.
An immutable variable
`lazy var` is not supported by Scala

 

 

What will the following function return: def foo(o:Any) = { o match { case Option(x) => "hi!" case anything => anything } } When passed a 'None' object?

it will return the None because it matches on 'anything'
It won't compile
It will return 'anything'
It will return "hi!" because a 'None' is a type of 'Option'

 

 

How would you get a List that was the result of appending `5:Int` to a `List(1,2,3)`. The order of the elements in the resulting List is irrelevant.

List(1,2,3) :: 5
List(1,2,3) :+ 5
List(1,2,3) ::= 5
List(1,2,3) + 5
List(1,2,3) :: List(5)

 

 

Which of these are NOT ways in which case classes differ from standard classes?

Getter functions are automatically defined for the constructor parameters
A default definition for method "toString" is provided, and prints the value in a source form
Default definitions for the methods "equals" and "hashCode" are not provided
The "new" keyword is not mandatory to create instances of case classes

 

 

What is the data type of myVariable in the following: val myVariable = if (true) "Hello"

String
Any
Unit

 

 

Are parenthesis `(` and curly braces `{` interchangeable?

Only if the method expects a partial function.
Not unless the function supports contravariant type parameters.
Not unless the function supports covariant type parameters.
Only if the method expects a single parameter.

 

 

Is it possible in Scala to declare a variable of type `Int` with a value of `null`?

Yes
No

 

 

Which statement about the Option[+A] class is false?

Option[+A] is meant to replace the usage of null.
Option[+A] is abstract.
scala.Nothing is derived from Option[+A]
None is derived from Option[+A]

 

 

Which predicate tests whether x is object identical to y?

x = y
x eq y
x == y
x.object == y.object

 

 

Which of the following descriptions of case classes is *NOT* correct:

Case classes can be used in matchers.
Case classes come with apply and unapply methods.
Case classes are always immutable.
Case classes have default serializers

 

 

def g(): Int = try { 1 } finally { 2 } Calling g() results in

Exception
2
1

 

 

Which of the following is not one of the ways to increment the value of a variable i of type Int by 1.

i = i + 1
i += 1
ii+
i++

 

 

"Option" is:

an abstract class
an interface
a trait
a concrete class
a case class

 

 

What is the Scala development environment designed for use in schools?

Venner
FODEM
Typesafe
Kojo

 

 

What is the runtime class of Unit?

Class[Unit]
Nothing
Unit
type[Unit]

 

 

A function which associates a value to a (variable) name is known as a(n):

Class
Environment
Method
Operation

 

 

def f(): Int = try { return 1 } finally { return 2 } Calling f() results in

1
2
Exception

 

 

True or False? Scala compiler automatically infers function parameter types.

False
True

No comments:

Post a Comment