\documentclass[10pt,a4paper]{article}

% Packages
\usepackage{fancyhdr}           % For header and footer
\usepackage{multicol}           % Allows multicols in tables
\usepackage{tabularx}           % Intelligent column widths
\usepackage{tabulary}           % Used in header and footer
\usepackage{hhline}             % Border under tables
\usepackage{graphicx}           % For images
\usepackage{xcolor}             % For hex colours
%\usepackage[utf8x]{inputenc}    % For unicode character support
\usepackage[T1]{fontenc}        % Without this we get weird character replacements
\usepackage{colortbl}           % For coloured tables
\usepackage{setspace}           % For line height
\usepackage{lastpage}           % Needed for total page number
\usepackage{seqsplit}           % Splits long words.
%\usepackage{opensans}          % Can't make this work so far. Shame. Would be lovely.
\usepackage[normalem]{ulem}     % For underlining links
% Most of the following are not required for the majority
% of cheat sheets but are needed for some symbol support.
\usepackage{amsmath}            % Symbols
\usepackage{MnSymbol}           % Symbols
\usepackage{wasysym}            % Symbols
%\usepackage[english,german,french,spanish,italian]{babel}              % Languages

% Document Info
\author{Manon Gerrd (manongerard)}
\pdfinfo{
  /Title (scala.pdf)
  /Creator (Cheatography)
  /Author (Manon Gerrd (manongerard))
  /Subject (Scala Cheat Sheet)
}

% Lengths and widths
\addtolength{\textwidth}{6cm}
\addtolength{\textheight}{-1cm}
\addtolength{\hoffset}{-3cm}
\addtolength{\voffset}{-2cm}
\setlength{\tabcolsep}{0.2cm} % Space between columns
\setlength{\headsep}{-12pt} % Reduce space between header and content
\setlength{\headheight}{85pt} % If less, LaTeX automatically increases it
\renewcommand{\footrulewidth}{0pt} % Remove footer line
\renewcommand{\headrulewidth}{0pt} % Remove header line
\renewcommand{\seqinsert}{\ifmmode\allowbreak\else\-\fi} % Hyphens in seqsplit
% This two commands together give roughly
% the right line height in the tables
\renewcommand{\arraystretch}{1.3}
\onehalfspacing

% Commands
\newcommand{\SetRowColor}[1]{\noalign{\gdef\RowColorName{#1}}\rowcolor{\RowColorName}} % Shortcut for row colour
\newcommand{\mymulticolumn}[3]{\multicolumn{#1}{>{\columncolor{\RowColorName}}#2}{#3}} % For coloured multi-cols
\newcolumntype{x}[1]{>{\raggedright}p{#1}} % New column types for ragged-right paragraph columns
\newcommand{\tn}{\tabularnewline} % Required as custom column type in use

% Font and Colours
\definecolor{HeadBackground}{HTML}{333333}
\definecolor{FootBackground}{HTML}{666666}
\definecolor{TextColor}{HTML}{333333}
\definecolor{DarkBackground}{HTML}{89D0FE}
\definecolor{LightBackground}{HTML}{F0F9FE}
\renewcommand{\familydefault}{\sfdefault}
\color{TextColor}

% Header and Footer
\pagestyle{fancy}
\fancyhead{} % Set header to blank
\fancyfoot{} % Set footer to blank
\fancyhead[L]{
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{C}
    \SetRowColor{DarkBackground}
    \vspace{-7pt}
    {\parbox{\dimexpr\textwidth-2\fboxsep\relax}{\noindent
        \hspace*{-6pt}\includegraphics[width=5.8cm]{/web/www.cheatography.com/public/images/cheatography_logo.pdf}}
    }
\end{tabulary}
\columnbreak
\begin{tabulary}{11cm}{L}
    \vspace{-2pt}\large{\bf{\textcolor{DarkBackground}{\textrm{Scala Cheat Sheet}}}} \\
    \normalsize{by \textcolor{DarkBackground}{Manon Gerrd (manongerard)} via \textcolor{DarkBackground}{\uline{cheatography.com/195339/cs/44464/}}}
\end{tabulary}
\end{multicols}}

\fancyfoot[L]{ \footnotesize
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{LL}
  \SetRowColor{FootBackground}
  \mymulticolumn{2}{p{5.377cm}}{\bf\textcolor{white}{Cheatographer}}  \\
  \vspace{-2pt}Manon Gerrd (manongerard) \\
  \uline{cheatography.com/manongerard} \\
  \end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Cheat Sheet}}  \\
   \vspace{-2pt}Not Yet Published.\\
   Updated 14th November, 2024.\\
   Page {\thepage} of \pageref{LastPage}.
\end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Sponsor}}  \\
  \SetRowColor{white}
  \vspace{-5pt}
  %\includegraphics[width=48px,height=48px]{dave.jpeg}
  Measure your website readability!\\
  www.readability-score.com
\end{tabulary}
\end{multicols}}




\begin{document}
\raggedright
\raggedcolumns

% Set font size to small. Switch to any value
% from this page to resize cheat sheet text:
% www.emerson.emory.edu/services/latex/latex_169.html
\footnotesize % Small font.

\begin{multicols*}{2}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Divers}}  \tn
% Row 0
\SetRowColor{LightBackground}
\{ ... \} & optionnel : (lisibilité) groupe en blocs \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
";" ou "\{\{nl\}\}" & sépare des déclarations \tn 
% Row Count 5 (+ 2)
% Row 2
\SetRowColor{LightBackground}
indentation & 2 espaces \tn 
% Row Count 6 (+ 1)
% Row 3
\SetRowColor{white}
a: B & a est de type A \tn 
% Row Count 7 (+ 1)
% Row 4
\SetRowColor{LightBackground}
object A: ...\{\{nl\}\}  def main(args: Array{[}String{]}): Unit = ...\{\{nl\}\}ou @main def a(...) = & main \tn 
% Row Count 12 (+ 5)
% Row 5
\SetRowColor{white}
private def/val .. & méthode/variable privées \tn 
% Row Count 14 (+ 2)
% Row 6
\SetRowColor{LightBackground}
sealed class/trait & peut être étendu seulement dans le même fichier \tn 
% Row Count 17 (+ 3)
% Row 7
\SetRowColor{white}
type x = ... & alias ou synonyme de type \tn 
% Row Count 19 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Chaque valeur est un objet\{\{nl\}\}Chaque objet peut avoir 1 ou plus de membres\{\{nl\}\}Module: objet dont le but principal est de donner à ses membres un espace de noms}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{1.6 cm} x{6.4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Variables}}  \tn
% Row 0
\SetRowColor{LightBackground}
val x = 1 & variables immuables /!\textbackslash{} éviter var \tn 
% Row Count 2 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{2.72 cm} x{5.28 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Class}}  \tn
% Row 0
\SetRowColor{LightBackground}
class C ... & classe \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
var c = new C(...) & crée un nouvel objet \tn 
% Row Count 3 (+ 2)
% Row 2
\SetRowColor{LightBackground}
object O ... & singleton = classe avec 1 seule instance \tn 
% Row Count 5 (+ 2)
% Row 3
\SetRowColor{white}
case class C ... & case classes sont des classes spéciales qui ont :\{\{nl\}\}• Une liste de paramètres qui agit comme constructeur.\{\{nl\}\}• Ne nécessitent pas le mot-clé new.\{\{nl\}\}• Tous les paramètres sont immuables et {\bf{publics}}.\{\{nl\}\}• Les instances sont comparées par structure et non par référence. \tn 
% Row Count 17 (+ 12)
% Row 4
\SetRowColor{LightBackground}
abstract class C ... & classe abstraite \tn 
% Row Count 19 (+ 2)
% Row 5
\SetRowColor{white}
class C extends D ... & classe héritée \tn 
% Row Count 21 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{"this" fait références à l'object\{\{nl\}\}pour accéder a des "champs": this.champ ou c.champ}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Méthodes}}  \tn
% Row 0
\SetRowColor{LightBackground}
def a(b: C) {\emph{{[}: D{]}}} = ... & méthode {\emph{A}} avec comme argument {\emph{b}} de type {\emph{C}} qui retourne un objet de type {\emph{D}}\{\{nl\}\}signature = définition \tn 
% Row Count 6 (+ 6)
% Row 1
\SetRowColor{white}
def a{\emph{{[}}}T, U{\emph{{]}}}(b: T, c: U) {\emph{{[}: D{]}}} = ... & méthode polymorphique (= avec paramètre(s) de type) \tn 
% Row Count 9 (+ 3)
% Row 2
\SetRowColor{LightBackground}
{\emph{{[}}}T \textless{}: U{\emph{{]}}} & Borne supérieure\{\{nl\}\}T doit être un sous-type de U \tn 
% Row Count 12 (+ 3)
% Row 3
\SetRowColor{white}
{\emph{{[}}}T :\textgreater{} U{\emph{{]}}} & Borne inférieure\{\{nl\}\}T doit être un super-type de U \tn 
% Row Count 15 (+ 3)
% Row 4
\SetRowColor{LightBackground}
def a(b: C*) = ... & fonctions variadiques : 0 ou plusieurs arguments\{\{nl\}\}b: C* = b est un objet séquence (Seq) d'éléments de type C \tn 
% Row Count 21 (+ 6)
% Row 5
\SetRowColor{white}
(x, y) =\textgreater{} x + y\{\{nl\}\}ou \_ + \_    ou ... & fonctions anonymes ou littérales = sans nom \tn 
% Row Count 24 (+ 3)
% Row 6
\SetRowColor{LightBackground}
@annotation.tailrec\{\{nl\}\}def ... & optimise une fonction récursive terminale \tn 
% Row Count 27 (+ 3)
% Row 7
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{\textbackslash{}textcolor\{red\}\{\textbackslash{}warning\} Scala accepte toute définition de fonction récursive syntaxiquement correcte, même si la fonction ne peut jamais se terminer. C'est au développeur de savoir si, pour un domaine donné, le calcul se terminera toujours.} \tn 
% Row Count 32 (+ 5)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{\textbackslash{}textcolor\{red\}\{\textbackslash{}warning\} ne pas utiliser "\textbackslash{}texttt\{return\}" : la valeur de la dernière instruction est renvoyée\{\{nl\}\}le type de retour n'est pas obligatoire si assez clair, mais le prof le préfère\{\{nl\}\}les fonctions sont typés donc ça permet d'avoir des fonctions d'ordre supérieur}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Fonctions d'ordre supérieur}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{def partial{\emph{{[}}}A, B, C{\emph{{]}}}(a: A, f: (A, B) =\textgreater{} C): B =\textgreater{} C =\{\{nl\}\}  (b) =\textgreater{} f(a, b)\{\{nl\}\}  val plus = (x: Int, y:Int) =\textgreater{} x + y\{\{nl\}\}  val plus1 = partial(1, plus)\{\{nl\}\}plus1(5) // returns 6} \tn 
% Row Count 4 (+ 4)
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{fonction prenant en argument une autre fonction ou renvoyant une fonction comme résultat}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Currying}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{def mul(x: Int, y: Int): Int = x * y\{\{nl\}\}def curriedMul(x: Int)(y: Int): Int = x * y} \tn 
% Row Count 2 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{convertir une fonction prenant en entrée plusieurs arguments en une séquence de fonctions prenant chacune un seul argument}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{3.2 cm} x{4.8 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Comparaison}}  \tn
% Row 0
\SetRowColor{LightBackground}
a equals b\{\{nl\}\}a.equals(b) & égalité par rapport à la valeur\{\{nl\}\}erreur si null \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
a == b & dépend de equals de {\emph{a}}\{\{nl\}\}gère correctement la valeur null \tn 
% Row Count 6 (+ 3)
% Row 2
\SetRowColor{LightBackground}
a eq b & égalité des références \tn 
% Row Count 8 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{3.6 cm} x{4.4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Stratégies d'évaluation}}  \tn
% Row 0
\SetRowColor{LightBackground}
val a = 1 & évaluée lorsqu'elle est définie \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
lazy val a = 1 & Appel par nécessité: 1 seule fois quand utilisé puis mémoïsé \tn 
% Row Count 5 (+ 3)
% Row 2
\SetRowColor{LightBackground}
def method(a: Int, b: =\textgreater{} Int) ... & fonction: évalué quand elle est appelée\{\{nl\}\}a: appel par valeur: évalué lors d'un appel et résultats sont copiés\{\{nl\}\}b: Appel par nom: évalué à chaque utilisation \tn 
% Row Count 13 (+ 8)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Méthodes importantes}}  \tn
% Row 0
\SetRowColor{LightBackground}
foldRight{[}B{]}(z: B)(f: (A, B) =\textgreater{} B): B & Applique f à chaque élément de droite à gauche en commençant avec z \tn 
% Row Count 4 (+ 4)
% Row 1
\SetRowColor{white}
foldLeft{[}B{]}(z: B)(f: (B, A) =\textgreater{} B): B & Applique f à chaque élément de gauche à droite en commençant avec z \tn 
% Row Count 8 (+ 4)
% Row 2
\SetRowColor{LightBackground}
take(n: Int): ...{[}A{]} & Sélectionne les n premiers éléments \tn 
% Row Count 10 (+ 2)
% Row 3
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{takeWhile} \tn 
% Row Count 11 (+ 1)
% Row 4
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{forall} \tn 
% Row Count 12 (+ 1)
% Row 5
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{exists} \tn 
% Row Count 13 (+ 1)
% Row 6
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{scanLeft} \tn 
% Row Count 14 (+ 1)
% Row 7
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{scanRight} \tn 
% Row Count 15 (+ 1)
% Row 8
\SetRowColor{LightBackground}
map{[}B{]}(f: A =\textgreater{} B): ...{[}B{]} & Crée un ... en appliquant f à chaque élément \tn 
% Row Count 18 (+ 3)
% Row 9
\SetRowColor{white}
flatMap{[}B{]}(f: A =\textgreater{} IterableOnce{[}B{]}): ...{[}B{]} & Crée un ... en appliquant f à chaque élément et en utilisant les éléments des collections résultantes \tn 
% Row Count 24 (+ 6)
% Row 10
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{groupMap} \tn 
% Row Count 25 (+ 1)
% Row 11
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{apply} \tn 
% Row Count 26 (+ 1)
% Row 12
\SetRowColor{LightBackground}
filter(p: A =\textgreater{} Boolean): ...{[}A{]} & Sélectionne tous les éléments qui satisfont un prédicat \tn 
% Row Count 29 (+ 3)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Gestion des exceptions}}  \tn
% Row 0
\SetRowColor{LightBackground}
Option{[}+A{]} & Le type de retour reflète la possibilité qu'un résultat ne soit pas défini \tn 
% Row Count 4 (+ 4)
% Row 1
\SetRowColor{white}
Some(A) & Résultat défini \tn 
% Row Count 5 (+ 1)
% Row 2
\SetRowColor{LightBackground}
None & Résultat indéfini \tn 
% Row Count 6 (+ 1)
% Row 3
\SetRowColor{white}
getOrElse{\emph{{[}B\textgreater{}:A{]}}}(default: =\textgreater{} B): B & Renvoie la valeur du Some, sinon defaut \tn 
% Row Count 8 (+ 2)
% Row 4
\SetRowColor{LightBackground}
orElse{\emph{{[}B\textgreater{}:A{]}}}(op: =\textgreater{} Option{[}B{]}): Option{[}B{]} & Renvoie le Some, sinon op \tn 
% Row Count 11 (+ 3)
% Row 5
\SetRowColor{white}
Either{\emph{{[}+E, +A{]}}} & Permet de stocker une valeur pour les exceptions \tn 
% Row Count 14 (+ 3)
% Row 6
\SetRowColor{LightBackground}
Left{\emph{{[}+E{]}}}(value: E) & erreur/exception \tn 
% Row Count 15 (+ 1)
% Row 7
\SetRowColor{white}
Right{\emph{{[}+A{]}}}(value: A) & correcte/succès \tn 
% Row Count 17 (+ 2)
% Row 8
\SetRowColor{LightBackground}
getOrElse{[}B \textgreater{}: A{]}(default: =\textgreater{} B): B & Renvoie la valeur de Right, sinon defaut \tn 
% Row Count 19 (+ 2)
% Row 9
\SetRowColor{white}
orElse{[}EE \textgreater{}: E, AA \textgreater{}: A{]}(op: =\textgreater{} Either{[}EE, AA{]}): Either{[}EE, AA{]} & Renvoie le Right, sinon op \tn 
% Row Count 23 (+ 4)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Collection immuable}}  \tn
% Row 0
\SetRowColor{LightBackground}
(1, a) & Tuple\{\{nl\}\}éléments peuvent être de différent type \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
a.\_nb\{\{nl\}\}a(nb) & accéder à un élément en fct de l'index (.\_ commence à 1, et () à 0) \tn 
% Row Count 7 (+ 4)
% Row 2
\SetRowColor{LightBackground}
val l: List{[}Int{]} = List(1, 2)\{\{nl\}\}val l: List{[}(Int, String){]} = List(...) & Liste\{\{nl\}\}les éléments doivent être du "type" mis entre {[}{]} \tn 
% Row Count 11 (+ 4)
% Row 3
\SetRowColor{white}
Nil equivalent à List{[}Nothing{]} & liste vide \tn 
% Row Count 13 (+ 2)
% Row 4
\SetRowColor{LightBackground}
1 :: 2 :: 3 :: Nil\{\{nl\}\}equivalent à List(1, 2, 3) & cons operator\{\{nl\}\}head :: tail (list) \tn 
% Row Count 16 (+ 3)
% Row 5
\SetRowColor{white}
val lz = LazyList(1, "a") & Liste paresseuse \tn 
% Row Count 18 (+ 2)
% Row 6
\SetRowColor{LightBackground}
1 \#:: (1+1) \#:: lz & cons qui retarder le calcul \tn 
% Row Count 20 (+ 2)
% Row 7
\SetRowColor{white}
\seqsplit{List.fill(n)(method(a))} & crée une liste de {\emph{n}} items contenant le résultat de {\emph{n}} évaluations de {\emph{method(a)}} \tn 
% Row Count 25 (+ 5)
% Row 8
\SetRowColor{LightBackground}
l.unzip & divise une liste de paires en une paire de listes \tn 
% Row Count 28 (+ 3)
% Row 9
\SetRowColor{white}
l.reduce((a, b) =\textgreater{} a.anonMethod(b)) & réduire les éléments d'une collection à 1élément\{\{nl\}\}Nécessite une fonction qui implémente une opération binaire (commutative et associative) \tn 
% Row Count 36 (+ 8)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Collection immuable (cont)}}  \tn
% Row 10
\SetRowColor{LightBackground}
l.groupBy(\_.champ) & crée un dictionnaire des champ (clés) vers une liste du type de {\emph{l}} \tn 
% Row Count 4 (+ 4)
% Row 11
\SetRowColor{white}
val m = Map("a" -\textgreater{} 1, "b" -\textgreater{} 2) & dictionnary qui map des clés a des valeurs \tn 
% Row Count 7 (+ 3)
% Row 12
\SetRowColor{LightBackground}
m.values & itérable contenant chaque valeur associée à une clé \tn 
% Row Count 10 (+ 3)
% Row 13
\SetRowColor{white}
m.keys & itérable contenant chaque clé \tn 
% Row Count 12 (+ 2)
% Row 14
\SetRowColor{LightBackground}
c.toList & transforme une collection en une liste \tn 
% Row Count 14 (+ 2)
% Row 15
\SetRowColor{white}
val s = Seq ??? & séquence = liste ordonnée \tn 
% Row Count 16 (+ 2)
% Row 16
\SetRowColor{LightBackground}
l.range(1,10{[},1{]}) & crée une collection allant de start à end (non compris) avec éventuellement un saut \tn 
% Row Count 21 (+ 5)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Nothing est un sous-type de toutes les classes =\textgreater{} Nil équivalent à List{[}Int{]}, List{[}String{]}, ...}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{1.2 cm} x{6.8 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Type}}  \tn
% Row 0
\SetRowColor{LightBackground}
Unit & tuple vide/void en tant qu'objet\{\{nl\}\}seule valeur : () \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
\seqsplit{Boolean} & true, false \tn 
% Row Count 4 (+ 2)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Int/Double/String} \tn 
% Row Count 5 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Ne pas utiliser la classe StringBuilder car elle n'est pas référentiellement transparente}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{2.72 cm} x{5.28 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Sucre syntactique}}  \tn
% Row 0
\SetRowColor{LightBackground}
sucre syntactique & équivalent à \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
\_.champ & (x) =\textgreater{} x.champ \tn 
% Row Count 3 (+ 1)
% Row 2
\SetRowColor{LightBackground}
\_ \seqsplit{method/opérateur} \_ & (x, y) =\textgreater{} x method y\{\{nl\}\}(x, y) =\textgreater{} x.method(y) \tn 
% Row Count 5 (+ 2)
% Row 3
\SetRowColor{white}
List{[}?{]} & Liste de n'importe quel type \{\{nl\}\}wildward argument \tn 
% Row Count 7 (+ 2)
% Row 4
\SetRowColor{LightBackground}
s* & opérateur splat : adapte une séquence pour qu'elle puisse être utilisée comme un nombre variable d'arguments \tn 
% Row Count 12 (+ 5)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{L'ordre des arguments est important, il n'y a pas moyen de l'inverser}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Import/packages}}  \tn
% Row 0
\SetRowColor{LightBackground}
import package.method\{\{nl\}\}import package.\{method1, method2\} & Importe des méthode(s) venant du package \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
import package.* & Importe toutes les méthodes venant du package \tn 
% Row Count 6 (+ 3)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Quand une méthode est importée, elle peut être utilisée de manière non qualifiée, sans préciser le package d'où elle vient.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Comments}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{// single line comment} \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{/* Multiline\{\{nl\}\}comment*/} \tn 
% Row Count 2 (+ 1)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{/** Documentation\{\{nl\}\}*comment\{\{nl\}\}*/} \tn 
% Row Count 3 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{2.64 cm} x{5.36 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Paramètres de type}}  \tn
% Row 0
\SetRowColor{LightBackground}
def a{\emph{{[}}}T, U{\emph{{]}}}... & 2 paramètres de types T et U \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
def a{\emph{{[}}}T \textless{}: U{\emph{{]}}}... & Borne supérieure\{\{nl\}\}T doit être un sous-type de U \tn 
% Row Count 5 (+ 3)
% Row 2
\SetRowColor{LightBackground}
def a{\emph{{[}}}T :\textgreater{} U{\emph{{]}}}... & Borne inférieure\{\{nl\}\}T doit être un super-type de U \tn 
% Row Count 8 (+ 3)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{0.836 cm} x{2.812 cm} x{3.952 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{3}{x{8.4cm}}{\bf\textcolor{white}{Variance}}  \tn
% Row 0
\SetRowColor{LightBackground}
List{[}+T{]} & covariant & List{[}S{]} est le sous-type de List{[}T{]} \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
List{[}-T{]} & contravariant & List{[}T{]} est le sous-type de List{[}S{]} \tn 
% Row Count 4 (+ 2)
% Row 2
\SetRowColor{LightBackground}
List{[}T{]} & Invariant\{\{nl\}\}par défaut & List{[}T{]} et List{[}S{]} ne sont pas liés \tn 
% Row Count 6 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}---}
\SetRowColor{LightBackground}
\mymulticolumn{3}{x{8.4cm}}{Supposons que nous ayons une classe générique qui a un paramètre de type \$T\$. Nous avons 2 types de liste, List{[}L{]} et List{[}S{]} où \$S\$ est un sous-type de \$T\$. Grâce à cela, nous pouvons définir les 3 types de variances pour le paramètre \$T\$ de la liste :}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}---}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Structure de contrôle}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{{\bf{if/then/else}}} \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{if cond then expr1\{\{nl\}\}  else if cond2 then expr2\{\{nl\}\}  else expr3} \tn 
% Row Count 3 (+ 2)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{if cond expr1\{\{nl\}\}équivalent à if cond expr1\{\{nl\}\}  else ()} \tn 
% Row Count 5 (+ 2)
% Row 3
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{can add an end if at the end of each expression} \tn 
% Row Count 6 (+ 1)
% Row 4
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{boucle {\bf{for}} : avec des effets de bord} \tn 
% Row Count 7 (+ 1)
% Row 5
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{for generator(s) do expr} \tn 
% Row Count 8 (+ 1)
% Row 6
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{generateur: p \textless{}- e où e est une collection, ou qqch to qqch \textbackslash{}textit\{{[}by qqch{]}\}\textbackslash{}newline peut avoir un if dedans (= garde)\textbackslash{}newline ou (clé, valeur) \textless{}- m où m est une map} \tn 
% Row Count 12 (+ 4)
% Row 7
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{{\bf{for expressions}}: retourne une valeur} \tn 
% Row Count 13 (+ 1)
% Row 8
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{for generateur(s)\{\{nl\}\}yield expr\{\{nl\}\}équivalent à val list = (x).map(p =\textgreater{} expr)\{\{nl\}\}si un garde est présent, replacer x par x.filter(IFexpr)} \tn 
% Row Count 16 (+ 3)
% Row 9
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{boucle {\bf{while}}} \tn 
% Row Count 17 (+ 1)
% Row 10
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{while cond do expr} \tn 
% Row Count 18 (+ 1)
% Row 11
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{{\bf{try/catch/finally}}} \tn 
% Row Count 19 (+ 1)
% Row 12
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{try expr\{\{nl\}\}catch\{\{nl\}\}    case ...\{\{nl\}\}finally} \tn 
% Row Count 20 (+ 1)
% Row 13
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{{\bf{match}} expressions} \tn 
% Row Count 21 (+ 1)
% Row 14
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{x match\{\{nl\}\}case 0 =\textgreater{} "zero"\{\{nl\}\}case \_ =\textgreater{} "autre" // attrape tout} \tn 
% Row Count 23 (+ 2)
% Row 15
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{filtrage par motif\{\{nl\}\}cible match cas\{\{nl\}\}possibilité d'ajouter un if dans le case = garde de motif} \tn 
% Row Count 26 (+ 3)
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{peut ajouter () autour des conditions/gardes}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Type algébrique de données}}  \tn
% Row 0
\SetRowColor{LightBackground}
enum C{[}+A{]}:\{\{nl\}\}  case D(...)\{\{nl\}\}  case E(...) & déclarer un type de données avec un ou plusieurs constructeurs de données\{\{nl\}\}Doit être importé \tn 
% Row Count 6 (+ 6)
% Row 1
\SetRowColor{white}
object C: ... & object compagnon = object avec le même nom qu'un type de données déclaré avec enum \tn 
% Row Count 11 (+ 5)
% Row 2
\SetRowColor{LightBackground}
trait C{[}+A{]}:\{\{nl\}\}interfaces et champs partagés & déclarer un type de données avec des interfaces et champs partagés \tn 
% Row Count 15 (+ 4)
% Row 3
\SetRowColor{white}
case class D(...) extends C{[}A{]} ... & on peut avoir accès a leurs champs \tn 
% Row Count 17 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{6.48 cm} p{1.52 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{?}}  \tn
% Row 0
\SetRowColor{LightBackground}
extension ... & ... \tn 
% Row Count 1 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}


% That's all folks
\end{multicols*}

\end{document}