Introduction to functional programming and Emacs lisp Kun-Yuan Hsieh

Introduction to functional programming and Emacs lisp

Kun-Yuan Hsieh

Outline

Tool: Emacs Introduction to functional language Emacs lisp

Emacs tutorial

Emacs?

Unix editor An integrated programming development

environment Maintain your programming style Edit, compile, read and write email and

new…

Starting Emacs Under unix shell:

> emacs filename (sometimes you need to use -nw)

When using emacs, the files are actually being stored to RAM as a buffer.

Any editing you do applies to the buffer, and then when you save, emacs writes the contents of the buffer to the disk.

Screen layout

keyboard bindings C for Ctrl M for meta(ESC) Ex:

C-x C-f M-x

Files Open a file: C-x C-f

Type a filename to open or create a file

Save a file: C-x C-s Wite to a new file (save as…): C-x C-w

Cursor

Leave the arrow along C-f = forward to next character C-b = back to previous character C-n = move to next line C-p = move to previous line C-e = move to the end of the line C-a = move to the start of the line

Scroll the screen

Scroll the display screen forward: C-v Scroll the display screen backward: M-v Go to line M-x goto-line +number To the beginning: M-< To the end: M->

Editing text

C-j: newline Delete:

C-d:delete-char <DEL>: delete-backward-char

Quit Emacs: C-x C-c

Editing text

C-k: kill to the end of the line (kill-line). C-y:yank last killed text (yank). M-y: replace text just yanked with an

earlier batch of killed text (yank-pop).

Search and replace C-s: Incremental search forward (isearch-

forward). C-r: Incremental search backward (isearch-

backward). Search and replace:

M-% SPACE,y: replacing currrent !: replace all match <DEL>,n: do not replace current <ESC>,q: quit …

Splitting the windows C-x 2:

into two row C-x 3:

into two column

Change the working window

C-x o: to the next window M -1 C-x o: to the previous window C-x 0: close working window

Open a new frame

A new frame: C-x 5 2 Open a file in new frame:C-x 5 f Close a frame: C-x 5 0

Shell

M-x shell

Functional programming

Introduction So far we have discussed imperative and O-

O languages Imperative languages are design to meet the

von Neumann archi. Functional programming is based on

mathematical functions, and it’s non-imperative

Functional programming is style of programming in which the primary method of computation is the application of functions to arguments

Brief history

AI in the mid-1950s Linguistics interest in natural language

processing Psychologies interest in modeling human

info. and the process of brain Computer must be able to process

symbolic data and linked lists

Some languages Language categories:

imperative: Ada, C, Pascal, … object: Java, C++, Smalltalk … logic: Prolog, ... functional: Haskell, ML, Lisp, Scheme, …

LISP(List Processing Language) is purely functional but added some imperative features for efficiency concern

Scheme is a dialect of LISP We will introduce Emacs Lisp

Mathematical function Mathematical function: a mapping of members

of one set to another set Described by an expression or a table The evaluation order is controlled by recursion

and conditional expressions

I F O

Domain set range set

Functions

Functions are defined by their names followed by parameterse.g. cube(x) = x*x*x

domain set: realrange set: real

Lambda expression Alonzo Church, 1941 A method for defining nameless function A lambda expression is the function itself

e.g. (x)x*x*x

evaluated for 2:((x)x*x*x)(2) => 8

-expression The continuing influence of the -calculus to

(language design in) Functional Programming is in its typed varieties, i.e. all expressions in a typed -calculus have a type, and so do formal parameters

LISP took the idea of parameter abstractions from the -calculus and combined it with notations that were particularly suitable for symbolic manipulation

Overview

everything is a function every function has a type FP consists of

defining types defining functions applying functions and calculating the resulting expression

finputsoutput

Emacs lisp

Introduction

GNU Emacs contains a complete Lisp system that allows the user to control the editor

Some apps runs in the editor were written in Emacs LISPe.g.calendar (M-x calendar)

Running Emacs LISP On UNIX system, execute emacs M-x ielm to enter iteractive mode

*** Welcome to IELM *** Type (describe-mode) for help. ELISP> (+ 2 2)4

C-x C-e after the right hand parenthesis (+ 2 2)

--1-:**-F1 ex1.el (Emacs-Lisp)--L11--Top-------------------------4

First glance: expressions LISP has simple syntax Recall: everything is a function ELISP> (+ 1 2)

3 ELISP> (- 3 4) -1 ELISP> (length ”mormo") 5ELISP> (concat ”cs" ”2403") ”cs2403”…

Everything is a function

(+ 2 2)

Function name

Arguments, supposed to be passed numbers

Arguments’ data types

Type of data is passed to a function depends on what kind of information it usese.g. + need numbers as arguments

Variable Number of Arguments

concat, + or *, take any number of arguments. e.g.(+) => 0(*) => 1 (+ 3) => 3 (* 3 4 5) => 60

List Lisp handle lists by putting them between

parentheses, sometimes by a single quote List is the central element of Lisp which

represents program code and data e.g.'(rose violet daisy buttercup)

Number, lists inside a list List can have number in it

e.g. (+ 2 2) In Lisp, both data and programs are

represented the same way which are both lists of words, numbers, or other lists, separated by whitespace and surrounded by parentheses. E.g.'(this list has (a list inside of it))

Atoms We call words atoms Which cannot be divided into any smaller parts

e.g. numbers and single character symbols like +.

Unlike an atom, a list can be split into parts. In a list, atoms are separated from each other

by whitespace

Some lisp expressions

Nested expression:(* (+ 1 2) (- 4 5)) => (1 + 2)*(4 - 5)

Substring:ELISP> (substring (concat "abc" "def") 2 5)

”cde”

message:(message "This message appears in the echo area!")(message "There are %d %s in the office!”

(- fill-column 14) "pink elephants")

Comparison t if successful and nil if not:

e.g.ELISP> (< 1 2) t ELISP> (< 1 0) nil ELISP> (= (+ 3 4) (- 10 2 1)) t ELISP> (string< "abc" "def") t ELISP> (string= "abc" "def") nil

Comparison function

The not function inverts t or nil: e.g.ELISP> (not t) nil ELISP> (not nil) t ELISP> (not (string< "x" "y")) nil

Setting a variable

Setq:setq carnivores '(lion tiger leopard))

Multiple setting(setq trees '(pine fir oak maple)

herbivores '(gazelle antelope zebra))

Ex:(setting a counter)(setq counter 0) ;the initializer.(setq counter (+ counter 1));incrementer.counter; This is the counter.

List functions car: yields the first item of the list

e.g. ELISP> (car '(1 2 3 4))1

cdr ("could-er") produces the tail of a liste.g.ELISP> (cdr ‘(1 2 3 4) (2 3 4) ELISP> (car (cdr (cdr ‘(1 2 3 4))))3

List functions: cons cons: creates a list from a head and a tail

e.g.ELISP> (cons 1 '(a b c)) (1 a b c) ELISP> (setq L (cons '(a b c) '(1 2 3))) ((a b c) 1 2 3)ELISP> (car L) (a b c) ELISP> (cdr L) (1 2 3)

List functions: length

length: find out # of elements in a liste.g.ELISP> (length '(buttercup))1ELISP> (length '(daisy buttercup))2ELISP> (length (cons 'violet '(daisy buttercup)))3

Define functions (defun function-name (arguments...) "optional-

documentation..." body...)e.g.(defun multiply-by-seven (number) "Multiply NUMBER by seven." (* 7 number))

Load functions

Save your source as xxx.el M-x load-file

Let let: special form to attach or bind a symbol

to a value during a limited timee.g.(let ((birch 3) pine fir (oak 'some)) (message "Here are %d variables with %s, %s, and %s value." birch pine fir oak))

Control- while

form: (while test-expr expr1 ... exprN) e.g.

(while (< counter 10) body... (setq counter (+ counter) 1))

Recursion (defun triangle-using-cond (number)

(cond ((<= number 0) 0) ((= number 1) 1) ((> number 1) (+ number (triangle-using-cond (1- number))))))

Project 5 quick sort

Goal Define a function named uID to perform

quick sort to sort a number list

IO Input: a number list variety length

e.g. ‘(1 4 5 8 9 6 3 5 4 )‘(100 589 32 1 5 844 58 5 2 12 6 8 )

Output: Message of sorting process(no specified form and conten )

e.g. “pick 1 as pilot”“pick 3 as pilot”…

The sorted liste.g.(1 3 4 4 5 5 6 8 9)

Print in the echo area, we will check your source code one by one

Requirements

Name your source ID.ele.g. 123456.el

Name your function uID.ele.g. (defun u123456 (alist)“SAMPLE FUNCTION”(cdr alist))

Testing environment and flow Under cs20., Emacs We will load your function first by:

e.g.M-x load-fileID.el

Then feed some list to your function:e.g.(setq list1 ‘( 9 8 5 4 6 3 2 1))(uID list1); evaluating your function

Reference

The Emacs editorhttp://www.gnu.org/software/emacs/manual/emacs.html

Programming in Emacs LISPhttp://www.gnu.org/software/emacs/emacs-lisp-intro/emacs-lisp-intro.html