diff --git a/languages/haskell.txt b/languages/haskell.txt new file mode 100644 index 0000000..02c061d --- /dev/null +++ b/languages/haskell.txt @@ -0,0 +1,479 @@ +CHEATSHEET HASKELL + +Use HASKELL + + Documentation + - Haskell API search: http://www.haskell.org/hoogle/ + - Haskell reference: ftp://ftpdeveloppez.com/cmaneu/langages/haskell/haskellreference.zip + + Basics + - Load file :load filename + - Reload file :reload + - Launch file editor with current file :edit + - Get information about a function :info command + +Comments + +A single line comment starts with ‘--’ and extends to the end of the line. +Multi-line comments start with ’{-’ and extend to ’-}’. Comments can be nested. + +Reserved words + + ! + ' + '' + - + -- + -< + -<< + -> + :: + ; + <- + , + = + => + > + ? + # + * + @ + [|, |] + \ + _ + ` + {, } + {-, -} + | + ~ + as + case, of + class + data + data family + data instance + default + deriving + deriving instance + do + forall + foreign + hiding + if, then, else + import + infix, infixl, infixr + instance + let, in + mdo + module + newtype + proc + qualified + rec + type + type family + type instance + where + +Data types + + All the data types must start by a capital letter. + + Int: Integer number with fixed precision + Integer: Integer number with virtually no limits + Float: Real floating point with single precision + Double: Real floating point with double the precision + Bool: Boolean + Char: Character, have to placed between quotes + String: A list of Chars + + Type redefinition + Type NewTypeName = TypeValue + Example: Type String = [Char] + +List & Numbers + + [] – Empty list + [1,2,3,4] – List of four numbers + 1 : 2 : 3 : 4 : [] - Write a lists using cons (:) and nil ([]) + [1..100] - List of number 1,2,3..,100 + [100..] - Infinite list of number 100,101,102,103,.. + [0,-1 ..] - Negative integers 0,-1,-2,.. + (h:q) - h stands for the first element of the list and q for the result + (f:s:t:q) - f is the first element, s is the second elemnt, t is the third and q is the rest of the elements of the list. + + It can be added the element e to the list l with e:l + +Basic functions for lists + + list1++list2 append two list + list!!n return element n + head takes a list and returns its head. The head of a list is basically its first element. + tail takes a list and returns its tail. In other words, it chops off a list's head. + last takes a list and returns its last element. + init takes a list and returns everything except its last element. + length takes a list and returns its length, obviously. + null checks if a list is empty. + reverse reverses a list. + take takes number and a list. It extracts that many elements from the beginning of the list. + drop works in a similar way as take, only it drops the number of elements from the beginning of a list. + maximum takes a list of stuff that can be put in some kind of order and returns the biggest element. + minimum returns the smallest. + sum takes a list of numbers and returns their sum. + product takes a list of numbers and returns their product. + elem takes a thing and a list of things and tells us if that thing is an element of the list. It's usually called as an infix function because it's easier to read that way. + +Function for infinite lists: + + cycle: takes a list and cycles it into an infinite list. If you just try to display the result, it will go on forever so you have to slice it off somewhere. + repeat: takes an element and produces an infinite list of just that element. It's like cycling a list with only one element. + replicate: takes the number of the same element in a list. + +List comprehension + + List comprehension is the process of generating a list using a mathematical expression. + + [body | generator] + + Examples: [x*a | a <- [1..3]] = [2,4,6] + [x*y | x <- [1..5], y <- [9..5] ] + [x | x <- [1,10,14,16,18], x>5 ] + +Tuples + + (1,"a") - 2-element tuple of a number and a string + (last, 4, 'b') - 3-element tuple of a function, a number and a character + +Note that the empty tuple () is also a type which can only have a single value: () + +Basic functions for Tuples + + fst: takes a pair and returns its first component. + snd: takes a pair and returns its second component. + zip: takes two lists and then zips them together into one list by joining the matching elements into pairs. + +Note: these functions operate only on pairs. They won't work on triples, 4-tuples, 5-tuples, etc. + + +Typeclasses + +A typeclass is a sort of interface that defines some behaviour. +If a type is a part of a typeclass, that means that it supports and implements the behavior the typeclass describes. +If you come from OPP you can think of them kind of as Java interfaces, only better. + +Everything before the => symbol is called a class constraint. + + Eq is used for types that support equality testing. Eq class constraint for a type variable in a function, it uses == or /= somewhere inside its definition + Ord is for types that have an ordering. Ord covers all the standard comparing functions such as >, <, >= and <= + Show can be presented as strings. show takes a value whose type is a member of Show and presents it to us as a string. + Read is sort of the opposite typeclass of Show. The read function takes a string and returns a type which is a member of Read. + Enum members are sequentially ordered types, they can be enumerated. Types in this class: (), Bool, Char, Ordering, Int, Integer, Float and Double. + Bounded members have an upper and a lower bound. All tuples are part of Bounded. Types in this class: Bool, Int and Char. + Num is a numeric typeclass. Types in this class: Int, Integer, Float and Double. + Integral is also a numeric typeclass. In this typeclass are Int and Integer. + Floating includes only floating point numbers. Types in this class: Float and Double. + +Functions + + Functions are defined by declaring their name, any arguments, and an equals sign. + + Declare a new function starting with explicit type declaration (optional) + functionName :: inpuntType1 [ -> inputTypeN ] -> outputType + + Declare a new function with pattern matching + intToChar 1 = "One" + intToChar 2 = "Two" + + Declare a new function with guards + intToChar x + | x==1 = "One" + | x==2 = "Two" + + Declare a new function with guards and pattern matching + allEmpty _ = falsePart + allEmpty [] = truePart + + alwaysEven n + | otherwise = False + | n 'div' 2 == 0 = True + + Declare a new function with record syntax + + Being this data type: + data Color = C { red, + , blue + , yellow :: Int } + + It can only be match on blue only: + + isBlueZero (C { blue = 0 }) = True + isBlueZero _ = False + + Defining a PixelColor type and a function replace values with non-zero blue components. + +Where and let + + Let must always be followed by in. The in must appear in the sale column as the let keyword. + In the following example, mult multiples its argument n by x, which passed to the original multiples. + multiples x = + let mult n = n * x + in map mult [1..10] + + + Where is similar to let. The scope of a where definition is the current function. + In the following example, the function result below has a different meaning depending on the arguments given to the function strlen: + strlen [] = result + where result = "No string given!" + strlen f = result ++ " characters long!" + where result = show (length f) + + + It is important to know that let ... in ... is an expression, that is, it can be written wherever expressions are allowed. + In contrast, where is bound to a surrounding syntactic construct, like the pattern matching line of a function definition. + + Advantage of where + Suppose you have the function + f :: s -> (a,s) + f x = y + where y = ... x ... + and later you decide to put this into the Control.Monad.State monad. + + However, transforming to + f :: State s a + f = State $ \x -> y + where y = ... x ... + will not work, because where refers to the pattern matching f =, where no x is in scope. In contrast, if you had started with let, then you wouldn't have trouble. + f :: s -> (a,s) + f x = + let y = ... x ... + in y + + This is easily transformed to: + f :: State s a + f = State $ \x -> + let y = ... x ... + in y + + Advantage of let + + Because "where" blocks are bound to a syntactic construct, they can be used to share bindings between parts of a function that are not syntactically expressions. + For example: + f x + | cond1 x = a + | cond2 x = g a + | otherwise = f (h x a) + where + a = w x + + In expression style, you might use an explicit case: + f x + = let a = w x + in case () of + _ | cond1 x -> a + | cond2 x -> g a + | otherwise -> f (h x a) + + or a functional equivalent: + f x = + let a = w x + in select (f (h x a)) + [(cond1 x, a), + (cond2 x, g a)] + or a series of if-then-else expressions: + f x + = let a = w x + in if cond1 x + then a + else if cond2 x + then g a + + +Anonymous Functions + + They are functions without names and can be defined at any time like so. + Example: \x -> x + 1 + +Case expressions + + case is to a switch statement in C# and Java. However, it can match a pattern. + Example: + data Choices = First String | Second | Third | Fourth + + case can be used to determine which choice was given + + whichChoice ch = + case ch of + First _ -> "1st!" + Second -> "2nd!" + _ -> "Something else." + + +Conditionals + + Identify == + Non identify /n + Comparatives where the type must a subclass of Ord <,>,<=,>= + + The if statement has this “signature”: if-then-else :: Bool -> a -> a -> a + +Maps and filters + + map takes a function and a list and applies that function to every element in the list, producing a new list. + Examples: + map :: (a -> b) -> [a] -> [b] + map _ [] = [] + map f (x:xs) = f x : map f xs + + filter is a function that takes a predicate and nd a list and then returns the list of elements that satisfy the predicate + Examples: + filter :: (a -> Bool) -> [a] -> [a] + filter _ [] = [] + filter p (x:xs) + | p x = x : filter p xs + | otherwise = filter p xs + +Folds + + foldl function folds the list up from the left side. + foldr works in a similar way to the left fold, only the accumulator eats up the values from the right. + + The foldl1 and foldr1 functions work much like foldl and foldr, only you don't need to provide them with an explicit starting value. + + scanl and scanr are like foldl and foldr, only they report all the intermediate accumulator states in the form of a list. + +Function application with $ + + The $ function has the lowest precedence and the function with $ is rigth-associate + +Default + + Default implementations can be given for function in a class. + + The default is defined by giving a body to one of the members' functions. + Example == can be defined in terms of /=: + (==) a b = not (a/b) + +Data + + Algebraic data types can be declared as: data MyType = MyValue1 | MyValue2 + +Note that type and constructor names must start with a capital letter. It is a syntax error otherwise. + + +Constructors with arguments + + Constructors that take arguments can be declared, allowing more information to be stored. + + data Point = TwoD Int Int + | ThreeD Int Int Int + +Notice that the arguments for each constructor are type names, not constructors. + +Type and constructor names + + Both names can be the same since they will never be used in a place that would cause confusion. + data User = User String | Admin String + + Using this type in a function makes difference clear: + whatUser (User _) = "normal user" + whatUser (Admin _) = "admin user" + +Type Variables + + Plymorphic data types are easy to be declared just by adding type varialbe in the declaration: + data Slot a = Slot1 a | Empty1 + + It can also be mix type variable and specific types in constructors: + data Slot2 a = Slot2 a Int | Empty2 + +Record syntax + + Constructors arguments can also be declared by using record syntax which gives a name to each argument. + For example: + data Contact = Contact { ctName :: String + , ctEmail :: String + , ctPhone :: String } + +Note: Multiple constructors of the same type can use the same accessor function name for values of the same type. + +Deriving + + The capabilities to convert to and from strings, compare +for equality, or order in a sequence are defined as Typeclasses and Haskell provides the deriving keyboard to automatically implement the typeclass on the associated type supported which are: Eq, Read, Show, Ord, Enum, Ix, and +Bounded. + + Two forms of deriving are possible. + + The first is used when a type only derives one class: + data Priority = Low | Medium | High + deriving Show + + The second is used when multiple classes are derived: + data Alarm = Soft | Loud | Deafening + deriving (Read, Show) + +Class constraint + + In any case, the syntax used is: + data (Num a) => SomeNumber a = Two a a + | Three a a a + + This declares a type SomeNumber which has one type variable argument. + Valid types are those in the Num class. + +Do + + Do indicates that the code to follow will be in a monadic context. + Statements are separated by newlines, the assignment is indicated by <, and a let form is introduced which does not require the in the keyboard. + +If, Then, Else + + This function tests if the string is given starts with a lower case letter and, if so, convert it to upper case: + + sentenceCase (s:rest) = + if isLower s + then toUpper s : rest + else s : result + sentenceCase _ = [] + +Deconstruction + + The left-hand side of a let definition can also destructive its argument, in case sub-components are to be accessed. + Examples: + firstThree str = + let (a:b:c:_) = str + in "Initial three characters are: " ++ + show a ++ ", " ++ + show b ++ ", and " ++ + show c + + Note that this is different than the following, which only works if the string has exactly three characters: + onlyThree str = + let (a:b:c:[]) = str + in "The characters given are: " ++ + show a ++ ", " ++ + show b ++ ", and " ++ + show c + +Modules + + A module is a compilation unit which export functions, tyñes, classes, instances, and other modules. + To make a Haskell file a module just add at the top of it: + module MyModule where + +Imports + + To import everything (functions, data types and constructors, class declarations, and even other modules imported) exported by a library, just use the module name: + import Text.Read + + To import selectively: + import Text.Read (readParen, lex) + + To import data types and no constructors: + import Text.Read (Lexeme) + + To import data types and one or more constructors explicitly + import Text.Read (Lexeme(Ident, Symbol)) + + To import all constructors for a given type: + import Text.Read (Lexeme()) diff --git a/languages/java.txt b/languages/java.txt new file mode 100644 index 0000000..514b946 --- /dev/null +++ b/languages/java.txt @@ -0,0 +1,344 @@ +Java Cheatsheet + +HELLO WORLD + +//Text file name HelloWorld.java +public class HelloWorld { + // main() is the method + public static void main (String[] arfs) + //Prints "Hello World" in the terminal window. + System.out.pritn("Hello World"); +} + +DATA TYPES + +Type Set of values Values Operators +int integers between -2^31 and + (2^31)-1 + - * / % +double floating-point numbers real numbers + - * / +boolean boolean values true or false && || ! +char characters +String sequences of characters + +DECLARATION AND ASSIGNMENT STATEMENTS + +//Declaration statement +int a,b; + +//Assignment statement +a = 13212; //a is the variable name; 13212 is the literal which is assign to the variable a + +//Initialization statement +int c = a + b; + +COMPARISON OPERATORS + +Operation Meaning + == equal + != not equal + < less than + > greater than + <= less than or equal + >= greater than or equal + + +PRINTING + + void System.out.print(String s) //print s + void System.out.println(String s) //print s, followed by a newline + void System.out.println() //print a newline + +PARSING COMMAND-LINE ARGUMENTS + + int Integer.parseInt(String s) //convert s to an int value + double Double.parseDouble(String) //convert s to a double value + long Long.parseLong(String s) // convert s to a long value + +MATH LIBRARY + + Public Class Math + double abs(double a) // absolute value of a + double max(double a, double b) //maximum of a and b + double min(double a, dobule a) //minimum of a and b + double sin(double theta) //sine of theta + double cos(double theta) //cosine of theta + double tan(double theta) //tangent of theta + double toRadians(double degrees) // convert angle from degrees to radians + double toDegreestouble radians) // convert angle from radians to degrees + double exp(doube a) // exponential (e^a) + double pow(double a, double p) //raise a to the bth power (a^b) + double random() //random in [0,1) + double sqrt(double a) //square root of a + + +EXAMPLES OF TYPE CONVERSION + + Expression Expression type Expression value + (1 + 2 + 3 + 4) / 4.0 double 2.5 + Math.sqrt(4) double 2.0 + "123343" + 99 String "12334399" + 11 * 0.25 double 2.75 + (int) 11 * 0.25 double 2.75 + 11 * (int) 0.25 int 0 + (int) (11 * 0.25) int 2 + + +ANATOMY OF AN IF STATEMENT + + if (x>y) { // x > y is the boolean expression + //Sequence of statements + x = y; + } + +IF AND IF-ELSE STATEMENT + + if (BOOLEAN EXPRESSION) { + //Sequence of statements + } else { + //Sequence of statements + } + +ANATOMY OF A WHILE LOOP + + //Initialization is a separate statement + int power = 1; + + while ( power <= n/2 ) // power <= n/2 is an example of the loop-continuation condition + { + //Statements + } + +ANATOMY OF A WHILE LOOP + + //Initialize another variable in a separate statement + int power = 1; + + for (declare and initialize a loop control variable; loop-continuation condition/s; increment or decrement of the variable of control) + { + //Statement + } + + Example: + for (int i = 0; i <= n; i++) { + //Statement + } + +DO-WHILE LOOP + + do{ + //Statement + } while(lopp-continuation condition); + +SWITCH STATEMENT + + switch (VARIABLE TO EVALUATE ITS VALUE) { + case value: Statement; break; + ... + default: Statement; break; + } + + Example: + + int month = 8; + String monthString; + switch (month) { + case 1: monthString = "January"; + break; + case 2: monthString = "February"; + break; + case 3: monthString = "March"; + break; + case 4: monthString = "April"; + break; + case 5: monthString = "May"; + break; + case 6: monthString = "June"; + break; + case 7: monthString = "July"; + break; + case 8: monthString = "August"; + break; + case 9: monthString = "September"; + break; + case 10: monthString = "October"; + break; + case 11: monthString = "November"; + break; + case 12: monthString = "December"; + break; + default: monthString = "Invalid month"; + break; + } + +ARRAY DECLARATION + + int[] ai; // array of int + short[][] as; // array of array of short + short s, // scalar short + aas[][]; // array of array of short + Object[] ao, // array of Object + otherAo; // array of Object + Collection[] ca; // array of Collection of unknown type + +DECLARATION OF ARRAY VARIABLE + + Exception ae[] = new Exception[3]; + Object aao[][] = new Exception[2][3]; + int[] factorial = { 1, 1, 2, 6, 24, 120, 720, 5040 }; + char ac[] = { 'n', 'o', 't', ' ', 'a', ' ', + 'S', 't', 'r', 'i', 'n', 'g' }; + String[] aas = { "array", "of", "String", }; + +FUNCTIONS + + public static double sum (int a, int b) { //double is the return type, sum is the method's name, a and b are two arguments of type int; + int result; //local variable + result = a + b; + return result;//return statement; + } + +USING AN OBJECT + + //Declare a a variable, object name + String s; + + //Invoke a contructor to create an object + s = new String ("Hello World"); + + //Invoke an instance method that operates on the object's value + char c = s.chartAt(4); + +INSTANCE VARIABLES + + public class Charge { + //Instance variable declarations + private final double rx, ry; + private final double q; + } + + //private, final and public are access modifiers + + +CONSTRUCTORS + + //A class contains constructors that are invoked to create objects from the class blueprint. + //Constructor declarations look like method declarations—except that they use the name of the class and have no return type + + public Bicycle(int startCadence, int startSpeed, int startGear) { + gear = startGear; + cadence = startCadence; + speed = startSpeed; +} + +DECLARING CLASSESS + + +class MyClass { + // field, constructor, and + // method declarations +} + +Example: + + public class Bicycle { + // the Bicycle class has + // three fields + public int cadence; + public int gear; + public int speed; + // the Bicycle class has + // one constructor + public Bicycle(int startCadence, int startSpeed, int startGear) { + gear = startGear; + cadence = startCadence; + speed = startSpeed; + } + // the Bicycle class has + // four methods + public void setCadence(int newValue) { + cadence = newValue; + } + public void setGear(int newValue) { + gear = newValue; + } + public void applyBrake(int decrement) { + speed -= decrement; + } + public void speedUp(int increment) { + speed += increment; + } + +DECLARING CLASSESS IMPLEMENTATING AN INTERFACE + +class MyClass extends MySuperClass implements YourInterface { + // field, constructor, and + // method declarations +} + +// MyClass is a subclass of MySuperClass and that it implements the YourInterface interface. + + +STACK DATA TYPE + + public class Stack implements Iterable + + Stack() //create an empty stack + boolean isEmpthy() //return if the stack empthy + void push(Item item) // push an item onto the stack + Item pop() //return and remove the item that was inserted most recently + int size() //number of item on stack + +QUEUE DATA TYPE + + public class Queue implements Iterable + + Queue() //create an emptyh queue + boolean isEmpthy() //return if the queue empthy + void enqueue(Item item) // insert an item onto queue + Item dequeue() //return and remove the item that was inserted least recently + int size() //number of item on queue + +ITERABLE + +//import Iterator +import java.util.Iterator; + +public class Queue implements Iterable { + +//FIFO queue + private Node first; + private Node last; + private class Node { + Item item; + Node next; + } + + public void enqueue (Item item) + ... + + public Item dequeue() + ... + +} + +SYMBOL TABLE DATA TYPE + + public class ST, Value> + + ST() //create and empthy symbol table + void put(Key key, Value val) //associate val with key + Value get(Key key) //value associated with key + void remove(Key key) //remove key (and its associated value) + boolean contains (Key key) //return if there is a value associated with key + int size() //number of key-value pairs + Iterable keys() // all keys in the symbol table + +SET DATA TYPE + + public class SET> implements Iterable + SET() //create an empthy set + boolean isEmpthy() //return if the set is empthy + void add (Key key) //add key to the set + void remove(Key key) //remove key from set + boolean contains(Key key) //return if the key is in the set + int size() //number of elements in set +