Racket Introduction

1
Racket Introduction

• CSC270 Pepper

major portions credited to http//learnxinymin
utes.com/docs/racket/
2
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

3
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

4
Imperative vs. Functional (Declarative)
From https//msdn.microsoft.com/en-us/library/bb
669144.aspx
5
Contrast Imperative Types

• Pure Imperative
• SQL Data Manip Lang (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

6
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.

7
Declarative types

• Logic Relationships defined in terms of
  inference rules
• Prolog
• Functional Relationships defined in terms of
  functions
• Haskell,
• Subset of Racket
• Subset of F
• Excel
• Domain specific
• Regular Expressions
• SQL Select

8
Some Functional Advantages

• Readability and Maintainability
• One task and no reliance on an external state
• Refactoring
• Because the insides of the function do not effect
  anything outside itself, as long as the output is
  the same, refactoring is fine
• Testing
• Tested in isolation

9
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
• Can pass it like an object
• Remembers variable values of creation time scope

10
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 racket language with lang racket
• Context sensitive F1 help

11
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

12
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

13
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

14
Comments

• Block comments
• Single comments
• lang racket
• define a function called sayhi
• (define (sayhi ) "Hello from the function")
• and now call it
• (sayhi)

15
Rules about literals

• String " " (use \" to type a text quote)
• number 1, 1.3, 1/2, 12i, 6.003e15, 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

16
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

17
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

18
Pictures

• Variable can contain a picture
• (require picturing-programs)
• (define dog1 )
• (define cat1 )
• ( above dog1 cat1)
• (above (flip-vertical dog1)
• (above dog1 cat1))

19
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))

20
Arithmetic

• All arithmetic is a function
• syntax ( operator operand1 operand2)
• operators ,-,/,,expt,quotient, remainder,
• special operators exact-gtinexact (from rational
  to real), gcd, lcm
• ( 1 2)
• (/ 5 2) not integer division!
• (expt 2 3) 2 to the 3rd power
• (remainder 11 3)

21
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"

22
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

23
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
• lt, gt , lt, gt,

24
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

25
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

26
Dice Roll

• (define (roll )
• ( ( (random 6 ) 1)
• ( (random 6 ) 1) ))
• (roll)
• (roll)
• (roll)

27
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

28
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

29
Test Cases before coding

• (require test-engine/racket-tests)
• 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)

30
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 lt 0 ) 0
• else )

31
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 (lt num 0 ) 0
• else num addnum(num-1) )

32
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