Transcript Racket Intro

Racket Introduction
CSC270 Pepper
major portions credited to http://learnxinyminutes.com/docs/racket/
What is Dr. Racket?
• Racket
– Full spectrum programming language with roots in
functional programming which is a type of the
declarative paradigm
• Lisp / Scheme
• Formerly called PLT Scheme
• Objects, types, laziness, macros, new syntax builder
• Dr. Racket
– Integrated Development Environment
Declarative vs Imperative
Declarative
• What not how
• Language can figure
out how when you
tell it what
• No side effects –
• No mutatable
variables
• Express data flow
Imperative
• Commands
manipulate state of
system and
variables.
• Many side effects
• Mutable variables
• Control flow
Contrast: Imperative Types
• Pure Imperative
– SQL DML (insert, update, delete)
• Procedural
– Exactly how algorithms
– First do this and next do that
–C
• Object Oriented
–
–
–
–
Manipulate objects through predefined methods
Classes
Send messages between objects
C++, Java
Another Functional Language: Excel
• Formulas express data flow
• Command sequence is not a consideration
when coding Excel formulas
• Cells hold one target value – changing inputs
will change the value, but you never do
anything with its value over time.
Declarative types
• Logic:
– Prolog
– Relationships defined in terms of inference rules
• Functional:
– Haskell, Excel, Subset of Racket
– Relationships defined in terms of functions
Racket Strengths
• Language syntax builder
• Continuations (capture future value of a
computation and pass it around)
• Dynamic typing
• Manages its own memory
• Function creation on the fly (lambda)
• Function closure
How to install Racket
• Panther will run Racket programs without IDE
– racket programfile
• Panther will run IDE with SSH X Forwarding to
allow X Window System GUI
– http://aruljohn.com/info/x11forwarding/
– drracket
• See a racket window good
• See Gtk initialization failed for display – no x windows
• Download on PC or Mac
– http://download.racket-lang.org/
• IDE
– choice : advanced language
– Context sensitive F1 help
Hello Racket
• Program
#lang racket
"Hello Racket"
• Save as hello.rkt
– IDE: File / save definition
• Running the program
– IDE : run button
– Panther without xterm: racket hello.rkt
Hello Racket with a defined variable
#lang racket
(define hellovar "Hello Racket again")
Hellovar
• Notice that a variable is defined inside
parentheses
• All commands inside parentheses
Hello Racket With a Function
#lang racket
(define (sayhi ) "Hello from the function")
(sayhi)
• Notice how the function call is in ()
• Notice the function definition syntax used
here: (define (function name ) (stuff function
does))
– Balanced parentheses
Comments
• Block comments: #| … |#
• Single comments: ;
#lang racket
; define a function called sayhi
(define (sayhi ) "Hello from the function")
; and now call it
(sayhi)
Rules about literals
• String: " " (use \" to type a text quote)
• number: 1, 1.3, 1/2, 1+2i, 6.003e+15, #x1A,
#b10111, #o737, 8888888888888888888
– will store a rational
• true/false : #t for true, #f for false
• logical: not, and, or : ex: (not #t) is false and (and
1 2) is false
• Suppress expansion: just one leading ' :
'(function a b) will be text not a function
Parentheses
• Do not put a literal inside ()or Racket will evaluate it as
a function
#lang racket
(define x 3)
x
(x) ; racket hates this
(define (sayhi ) "Hello from the function")
(sayhi)
sayhi
; racket does not hate this, but wont run the sayhi
function
Variable use
;Define for the program
(define x "outside")
;Define locally
(let ([x "inside"])
x) ; displays "inside"
x ; displays "outside"
; Define function argument
(define (myfunc num)
(+ num 3)) ;
(myfunc 4) ; displays 7
; Change a variable (let's avoid it)
(set! x 8)
x; displays 8
Pictures
• Variable can contain a picture
(require picturing-programs)
(define dog1
(define cat1
)
)
( above dog1 cat1)
(above (flip-vertical dog1)
(above dog1 cat1))
Variables Rules Summary
• definition: (define varname value)
– example: (define x 3)
• use: just use the name; example: x
• define locally inside a let expression: (let ([varname
value]) expression )
– use let * if you want to use the first set of variables to
define another set
• use a variable: just the name - do not put a variable
inside () or Racket will evaluate it as a function
• change a variable – let's avoid it: (set! varname value)
example: (set! n (add1 n))
Arithmetic:
•
•
•
•
All arithmetic is a function
syntax: ( operator operand#1 operand#2)
operators: +,-,/,*,expt,quotient, remainder,
special operators: exact->inexact (from rational to
real), gcd, lcm
(+ 1 2)
(/ 5 2) ; not integer division!
(expt 2 3) ; 2 to the 3rd power
(remainder 11 3) ;
Functions
• Already defined functions with parms
• Return is value of last expression
(define (add8 num)
"hello"
(+ num 8)
"hello again")
(add8 3)
• Resolves to "hello again"
Simulate Excel
• Define 2 cells, one for income and one for
deductions
• Define another cell that represents your gross
income (income – deduction)
• Define another cell that represents your taxes
at 30%
Booleans
• #t is true; #f is false
• = or eq? are functions
– Use = for numbers only
(= 3 3.0) will be #t
(eq? 3 3.0) will be #f
(eq? "abc" "abc") will be #t
(not (eq? "abc" "def")) will be #t
<, > , <=, >=,
Decision - Cond
(cond [ (= 1 x) (add1 x) ]
[ (= 2 x) (+ x 4) ]
[ else (+ x 6 ) ] )
• 2 when x = 1;
• 6 when x = 2
• 13 when x = 7
Random
(random 6) ; gives 0 to 5
(+ (random 6 ) 1 ) gives a dice value
Create a throw dice function that rolls 2 dice and
returns the total.
What are your inputs?
What is your output?
What is your function name?
No need to display the individual dice
Dice Roll
(define (roll )
( + (+ (random 6 ) 1)
(+ (random 6 ) 1) ))
(roll)
(roll)
(roll)
Repetition - Recursion
• add from 1 to a max value
(define (addnum max)
(cond [ ( = max 0) 0 ]
[ else ( + max
(addnum (- max 1))) ]
))
(addnum 5) ; gives 15
Recursion Thought Process
• 1) What is true about the problem? (truth
statements will end up in your code)
• 2) What are the base cases? (small simple truths
- adding up 0 numbers yields 0)
• 3) What are you taking in and what is being
returned ? ( give a max and get a total)
• 4) Make some samples:
–
–
–
–
–
Addnum(0) should give 0
Addnum(1) should give 1
Addnum(2) should give 3
Addnum(3) should give 6
Addnum(4) should give 10
Test Cases before coding
;; addnum function adds from 1 to a max argument
;; input max number
;; output total of 1 to argument
(define (addnum 0) 0)
(require test-engine/racket-tests)
(check-expect (addnum 0 ) 0)
(check-expect (addnum 1 ) 1)
(check-expect (addnum 3 ) 6)
(check-expect (addnum 4 ) 10)
(check-expect (addnum 10 ) 55)
(check-expect (addnum -1 ) 0)
(test)
Coding the recursion
• Define the function without a body giving names
to input arguments
(define (addnum num )
)
• Fill in the body with a cond
(cond [ ( )
]
[ else
])
• Put the base case into the first condition
(cond [ ( num <= 0 ) 0 ]
[ else
])
Coding the Recursive Call
• Consider how to handle one pass of the
repetition;
– think about one of the later calls as a sample
(addnum 4)
• Write what is available to you
• Your input arguments
• Good return values from your function (see your tests)
• Define the rest of the information when one part
is removed
– Call that part recursively
(cond [ (<= num 0 ) 0 ]
[ else num + addnum(num-1) ])
Summary
•
•
•
•
•
•
•
•
Define Functional Programming
Declarative vs Imperative paradigms
How to enter literals
Create and use variables
Create and use functions
Decisions
Recursive functions
Parentheses, Parentheses, Parentheses