Place this code in a file named HelloWorld.scala:
object Hello {
def main(args: Array[String]): Unit = {
println("Hello World!")
}
}
Live demo
To compile it to bytecode that is executable by the JVM:
$ scalac HelloWorld.scala
To run it:
$ scala Hello
When the Scala...
This example assumes Ruby and Ruby on Rails have already been installed properly.
If not, you can find how to do it here.
Open up a command line or terminal. To generate a new rails application, use rails new command followed by the name of your application:
$ rails new my_app
If you want to c...
Using the def statement is the most common way to define a function in python. This statement is a so called single clause compound statement with the following syntax:
def function_name(parameters):
statement(s)
function_name is known as the identifier of the function. Since a function def...
Decorators normally strip function metadata as they aren't the same. This can cause problems when using meta-programming to dynamically access function metadata. Metadata also includes function's docstrings and its name.
functools.wraps makes the decorated function look like the original function b...
Standard Creation
It is recommended to use this form only when creating regex from dynamic variables.
Use when the expression may change or the expression is user generated.
var re = new RegExp(".*");
With flags:
var re = new RegExp(".*", "gmi");
With a backsl...
git remote add upstream git-repository-url
Adds remote git repository represented by git-repository-url as new remote named upstream to the git repository
git add -A
2.0
git add .
In version 2.x, git add . will stage all changes to files in the current directory and all its subdirectories. However, in 1.x it will only stage new and modified files, not deleted files.
Use git add -A, or its equivalent command git add --all, to stage all ch...
Use the import statement:
>>> import random
>>> print(random.randint(1, 10))
4
import module will import a module and then allow you to reference its objects -- values, functions and classes, for example -- using the module.name syntax. In the above example, the random module...
#include <stdio.h>
/* increment: take number, increment it by one, and return it */
int increment(int i)
{
printf("increment %d by 1\n", i);
return i + 1;
}
/* decrement: take number, decrement it by one, and return it */
int decrement(int i)
{
printf("...
from module_name import *
for example:
from math import *
sqrt(2) # instead of math.sqrt(2)
ceil(2.7) # instead of math.ceil(2.7)
This will import all names defined in the math module into the global namespace, other than names that begin with an underscore (which indicates that the wri...
Arrays can be created by enclosing a list of elements in square brackets ([ and ]). Array elements in this notation are separated with commas:
array = [1, 2, 3, 4]
Arrays can contain any kind of objects in any combination with no restrictions on type:
array = [1, 'b', nil, [3, 4]]
The groupingBy(classifier, downstream) collector allows the collection of Stream elements into a Map by classifying each element in a group and performing a downstream operation on the elements classified in the same group.
A classic example of this principle is to use a Map to count the occurrence...
In order to access the value of an Optional, it needs to be unwrapped.
You can conditionally unwrap an Optional using optional binding and force unwrap an Optional using the ! operator.
Conditionally unwrapping effectively asks "Does this variable have a value?" while force unwrapping sa...
Arguments are defined in parentheses after the function name:
def divide(dividend, divisor): # The names of the function and its arguments
# The arguments are available by name in the body of the function
print(dividend / divisor)
The function name and its list of arguments are called...
Optional arguments can be defined by assigning (using =) a default value to the argument-name:
def make(action='nothing'):
return action
Calling this function is possible in 3 different ways:
make("fun")
# Out: fun
make(action="sleep")
# Out: sleep
# The argumen...
One can give a function as many arguments as one wants, the only fixed rules are that each argument name must be unique and that optional arguments must be after the not-optional ones:
def func(value1, value2, optionalvalue=10):
return '{0} {1} {2}'.format(value1, value2, optionalvalue1)
Wh...
Arbitrary number of positional arguments:
Defining a function capable of taking an arbitrary number of arguments can be done by prefixing one of the arguments with a *
def func(*args):
# args will be a tuple containing all values that are passed in
for i in args:
print(i)
fun...
