Please enable JavaScript.

Coggle requires JavaScript to display documents.

Scheme (Lecture (Errors in Scheme (Unspecified Behavior ((eq? '(a b)…

- - - - (define (reverse ls)
        (let revapp ((ls2 ls)(a '()))
        (if (null? ls2)
        a
        (revapp (cdr ls2)
        (cons (car ls2) a)))))
        
        Recursive helper function
        
        Difference between ocaml
        
        Reverse Order
        
        Scheme: Textual Order = Order of execution
        
        Ocaml you make revapp then call
        Call is actually executed first
        
        Scheme naturally more tail recursive
        
        Revapp takes ls2 and a
        
        NOT ACTUALLY LS2, can be Ls
  - - - If call is at end of body
        
        (if E1 E2 E3)
        
        E2 and E3 are tail recursive
        
        (lambda)
        
        (cond ((E1 F1) (E2 F2_ ... (else Fn))
        
        Fs are tail
        
        (and E1 E2 ... En)
        
        En is tail recursive since and must execute and return regardless
      - Machine code is more efficient
        
        call instruction -> jump instruction
  - - - Controversial
        
        Too powerful, causes trouble
        
        Essence of scheme
      - Exposes future
        
        Cheap to do
      - Interpreter
        
        Has instruction pointer (ip)
        What executes next
        no ip = no code running
        
        Points to machine/byte code
        
        Less well known
        
        Environment Pointer(ep)
        
        Pointer to stack frame for current function
        
        Linked list of eps = continuation
        
        Future of program
        
        callers ip
        callers ep
      - call-with-current-continuation p(call//cc p)
        
        Creating current continuation
        
        Calls p with k as arg, returns it
        (p k)
        
        Create a continuation k
        k = pair of ip and ep
        
        Using continuation
        
        Can only call
        
        (k v)
        
        Sets ip to k's ip
        Sets ep to k's ep
        Return with value of v
      - Without Call cc
        
        Continuation Passing Style
        
        Convention: Each arg has extra arg for continuation
        
        Continuation tells you what to do with result
        
        Every function accepts an extra argument k,
        To return a value v, we pass v to k
        
        Object Oriented in C Version
        
        Extra arg would be object
        
        The object this method is being invoked on
        
        This or self
        
        product function
        
        (define (prod ls break)
        (let pr ((ls ls) (k break))
        (cond ((null?? ls) (k 1)
        ((zero? (car ls))(break 0))
        (else (pr (cdr ls)
        (lambda (v)(k(* v (car ls))))))
        
        Passing larger continuation and passing it
        
        Homework 2
        
        Acceptor is continuation :star:
        Used for backtracking
    - - No more stack
      - Extra argument that's a function
        Do some work
        Pass result into function
        
        No longer worry about returns
        
        Continuation argument handles it
      - History
      - Flow Control
      - Links
        
        https://www.youtube.com/watch?v=Ju3KKu_mthg
        
        https://www.youtube.com/watch?v=zB5LTkaJaqk
      - Example
        
        Continuation = function
        
        When you pass it an argument it jumps into the stack info with the argument passed
        
        You can pass the continuation down
  - - - Not actually multiple threads with ip
      - Co routines
        
        Equal
      - (define gtl '())
        (define (gt thunk)
        (set! gtl (append gtl (list thunk))))
        (define (start)
        (let ((firstthread (car gtl))
        (set! gtl (cdr gtl))
        (ft)))
        
        Thunks are end of list
        
        Does thunk then removes from list
        
        Cooperative
      - Thunk
        
        Parameterless
        
        Executed for side effect
      - Putting it together
        
        (gt (lambda ()(let f ()(display "h")(yield)(f))))
        (gt (lambda ()(let f ()(display "i")(yield)(f))))
        (gt (lambda ()(let f ()(newline)(yield)(f))))
        (start)
        
        Has 3 threads
        
        Grabs first thunk, then yeilds
        
        Eventually gets back to it and calls f again
        
        prints hi infinite number of times
      - Quasi parallel
        
        Not great with async commands
    - - Suppends current thread, next availablle runs
      - (define (yield)
        (call/cc (k)
        (gt (lambda()(k 42)))
        (start)))
  - - - Most serious
        
        Not defined
        
        (car 0)
    - - open_input_file "foo"
        
        If no file foo, implementation checks for file
        
        Tells you about error
    - - Doesn't signal
        Can't do anything like undefined
      - (eq? '(a b) '(a b))
        
        Create both list and compare
        
        Compiler makes single copy, so they point to same place in memory
        
        Could return true or false
      - Ambiguity
      - Programmer's responsibility
    - - Memory exhaustion
      - Ex
        
        (cons 3 4)
        
        Fails due to memory
- - - - Program code as data structure
        
        Meta programming
      - Scope
        
        Static Scope :star:
        
        Run at compile time
        
        Closest in distance
        
        Dynamic Scoping
        
        Looks at stack
        
        Callers scope
      - Dynamic Typing
    - - cond
        
        Short circuits
      - let
        
        last part is expr
        
        useful for simplifying expressions
      - Quotes
        
        Treat it literally
        
        No evaluation
      - Pair
        
        Functions
        
        (define (rev . l ) (revlist l))
        
        The first part of the pair is the function name rev
        
        The second part of the pair is a list
        
        Forces a size
        
        Type inferene
  - - - %
    - - Use !
        
        a!b means a interchangable with b