#scala-tutorial

My Emacs Config

My config for emacs and ensime usage. Emacs looks for a file called init.el under ~/.emacs.d to load all the required plugins,settings and config. In this post Im detailing my emacs configuration. The varios sections are explain one by one so as a reader you can just copy the contents from top to bottom and paste it in your init.el file before you start using Ensime in Emacs.

The entire config can be found here

Disclaimer : The steps explained here are done in my Macbook. The same should work for linux machines as well excpet for few configs

Defining Package Management and archives

Like any other text editor emacs also have a lot of plugins solving various purposes. Package are hosted in a repository called melpa. The first thing is to configure those repository and install use-package whcih is like the seed package to download others.

;; the package manager ;; =================== (require 'package) (setq package-archives '(("gnu" . "http://elpa.gnu.org/packages/") ("org" . "http://orgmode.org/elpa/") ("melpa" . "http://melpa.org/packages/") ("melpa-stable" . "http://stable.melpa.org/packages/")) package-archive-priorities '(("melpa-stable" . 1))) (package-initialize) (when (not package-archive-contents) (package-refresh-contents) (package-install 'use-package)) (require 'use-package)

Configuring packages

the below section details about the various plugins which I've configured. This section is heavily inpired from here. Thanks to Fommil the maintainer of Ensime project / comminity.

ensime

the fist package we are going to install is ensime which pulls out the ensime server and other goodies like code autocompletion, formatting and sbt compatibility etc. The complete features and functionalities of ensime is listed here

(use-package ensime :ensure t :pin melpa-stable)

Projectile

simple project management as seen in Eclispe,IDEA but without lot of config files .idea or .project etc its similar to .gitconfig.

(use-package projectile :demand :init (setq projectile-use-git-grep t) :config (projectile-global-mode t) :bind (("s-f" . projectile-find-file) ("s-F" . projectile-grep)))

Undo Tree

simple visualization of changes happed to the buffer undo-tree

(use-package undo-tree :diminish undo-tree-mode :config (global-undo-tree-mode) :bind ("C-S-t" . undo-tree-visualize))

flx-ido

emacs minor mode auto complete

(use-package flx-ido :demand :init (setq ido-enable-flex-matching t ido-show-dot-for-dired nil ido-enable-dot-prefix t) :config (ido-mode 1) (ido-everywhere 1) (flx-ido-mode 1))

misc

(use-package highlight-symbol :diminish highlight-symbol-mode :commands highlight-symbol :bind ("C-S-h" . highlight-symbol) ) (use-package goto-chg :commands goto-last-change :bind (("C-." . goto-last-change) ("C-," . goto-last-change-reverse))) (use-package popup-imenu :commands popup-imenu :bind ("M-i" . popup-imenu))

magit

the awesome git client for emacs

(use-package magit :commands magit-status magit-blame :init (setq magit-revert-buffers nil)) (use-package git-gutter)

**helm & helm projectile **

its documentation provides much more info and its a worthy read :)

;; the great helm mode (use-package helm :diminish helm-mode :init (progn (require 'helm-config) (setq helm-candidate-number-limit 100) ;; From https://gist.github.com/antifuchs/9238468 (setq helm-idle-delay 0.0 ; update fast sources immediately (doesn't). helm-input-idle-delay 0.01 ; this actually updates things ; reeeelatively quickly. helm-yas-display-key-on-candidate t helm-quick-update t helm-M-x-requires-pattern nil helm-ff-skip-boring-files t helm-autoresize-mode t) (helm-mode)) :bind (("C-c h" . helm-mini) ("C-h a" . helm-apropos) ("C-x C-b" . helm-buffers-list) ("C-x b" . helm-buffers-list) ("M-y" . helm-show-kill-ring) ("M-x" . helm-M-x) ("C-x c o" . helm-occur) ("C-x c s" . helm-swoop) ("C-x c y" . helm-yas-complete) ("C-x c Y" . helm-yas-create-snippet-on-region) ("C-x c b" . my/helm-do-grep-book-notes) ("C-x c SPC" . helm-all-mark-rings))) (use-package helm-projectile :init (progn (require 'helm-projectile) (helm-projectile-on)) :bind (("C-x t" . helm-projectile)))

move or swap lines

move lines or selection up and down

;; move lines with ease (use-package drag-stuff :init (progn (drag-stuff-mode t) (drag-stuff-define-keys) (drag-stuff-global-mode 1)))

smooth scrolling

much refined scrolling in emacs

(use-package smooth-scrolling :init (progn (require 'smooth-scrolling) (smooth-scrolling-mode 1)))

persistent scratch

(use-package persistent-scratch :init (progn (persistent-scratch-setup-default)))

only for Mac users

emacs confuses between the command , option and control keys in Mac keyboard, hence we can remap them using the following config. We also enable copy paste by cmd + c and cmd + v like any other mac app.

;; changing the command to control mac specific (setq mac-command-modifier 'control) (setq mac-option-modifier 'meta) ;; mac specific (cua-mode t)

Configuring the Plugins

now that we have installed the plugins though most of them does not really need special configurations but few of them needs. The comments in-line explain their purpose.

;; show line numbers globally (global-linum-mode 1) ;; let the buffer fringe on the left show git status (global-git-gutter-mode +1) ;; highlight matching parenthesis (show-paren-mode 1) (column-number-mode 1) ;; don't show tool bar : use more screen space (tool-bar-mode -1) ;; modes (electric-indent-mode 0) ;; global keybindings (global-unset-key (kbd "C-z")) ;; keep emacs maximised while startup (add-to-list 'default-frame-alist '(fullscreen . maximized)) ;; use default font across buffer, replace with your fav one (set-frame-font "PragmataPro 14")

Shortcuts

line any IDE emacs has many many shortcuts for various actions. Besides the stock ones its also let us to define our own and here are the ones which I configured , feel free to configure your own :)

There’s a sorted List[Long], and we would like to insert a separator between 2 elements where their number of digits differ. For example, there should be a separator between 99 and 100, but there shouldn’t be a separator between 98 and 99.

The easiest (not simplest) solution is to change List[Long] to a mutable list, iterate through it, and insert separator when needed.

However, we like a solution which doesn't require a mutable data structure. And here is one way to do it:

We want to pivot an array of arrays:

> pivot(Seq(Seq(1, 2, 3), Seq(4, 5, 6), Seq(7, 8, 9))) Seq(Seq(1, 4, 7), Seq(2, 5, 6), Seq(3, 6, 9))

Please take 5 minutes to solve this problem. If you cannot solve it in time, just scroll down to see the answer.

.

.

.

.

Here's our solution:

def pivot(seqOfSeqs: Seq[Seq[Int]]): Seq[Seq[Int]] = { if (seqOfSeqs.head.isEmpty) { Nil } else { seqOfSeqs.map(_.head) +: pivot(seqOfSeqs.map(_.tail)) } }

Now the above solution assumes that all Seqs have the same length. What if all Seqs do not have the same legnth?

Let's define the requirement first. Maybe it should work like this:

> pivot(Seq(Seq(1), Seq(2, 3), Seq(4, 5, 6))) Seq(Seq(1, 2, 4), Seq(3, 5), Seq(6))

We can modify the above solution a bit to handle this:

def pivot(seqOfSeqs: Seq[Seq[Int]]): Seq[Seq[Int]] = { val filtered = seqOfSeqs.filter(_.nonEmpty) if (filtered.isEmpty) { Nil } else { filtered.map(_.head) +: pivot(filtered.map(_.tail)) } }

Structural typing as defined by Wikipedia

"A structural type system (or property-based type system) is a major classof type system, in which type compatibility and equivalence are determined by the type's structure, and not by other characteristics such as its name or place of declaration "

Strutural types in scala allows code modularity for some specific situations.For instance, if a behaviour is implemented across several classes and those behaviours need to invoked by the structure of the type. 

This approach rules out the need for an abstract class or trait merely for the purpose of calling single overridden method. Structural typing not onlyadds syntatic sugar but also makes the code much modular. 

Lets consider a behaviour 'walk' in classes Cat and Dog. The StrucType class's whoIsWalking takes a type param which states that

  - "Accept any object which has a method walk and that returns a string"

type is aliazed with a variable 'c' and with in the method the aliazed variable can invoke 'walk'.

class StrucType { def whoIsWalking(c:{def walk():String}) = println(c.walk) }

Below are the classes which has the method commons.class

class Cat { def walk():String = "Cat walking" } class Dog { def walk():String = "Dog walking" }

/** * * object Main { def main(args:Array[String]) { println("Hello Scala") val walkerStruct = new StrucType(); walkerStruct.whoIsWalking(new Cat()); walkerStruct.whoIsWalking(new Dog()); } } */