Racket Questions and Answers for Viva

Answer-1: car returns the first element of a list, while cdr returns the rest of the list.

Answer-2: Custom data structures can be created using struct, e.g., (struct point (x y)).

Answer-3: A lambda is an anonymous function, created using the lambda keyword, e.g., (lambda (x) (* x x)).

Answer-4: Libraries are imported using the require keyword, e.g., (require racket/math).

Answer-5: Syntax objects encapsulate code and its syntactic context, used in macros and compiler extensions.

Answer-6: Racket emphasizes immutability by default, with immutable data structures like lists and strings.

Answer-7: match is a pattern-matching construct for destructuring and conditional execution based on data shapes.

Answer-8: set! updates the value of an existing variable, typically avoided in functional programming for immutability.

Answer-9: Strings are manipulated using functions like string-append, substring, and string-length.

Answer-10: begin groups multiple expressions, ensuring they are executed sequentially.

Answer-11: Errors are handled using with-handlers and exception-catching constructs.

Answer-12: define creates new bindings, while set! modifies existing ones.

Answer-13: Loops are implemented using recursion or constructs like for, while, and do.

Answer-14: #lang specifies the language for a Racket module, e.g., #lang racket.

Answer-15: State is managed using mutable data structures, set!, or constructs like parameterize.

Answer-16: Vectors are mutable, indexed collections created using (vector 1 2 3).

Answer-17: Classes are defined using the class and define constructs, e.g., (define my-class (class object% ...)).

Answer-18: equal? checks structural equality, while eq? checks reference equality.

Answer-19: Contracts specify function input and output types, enforced at runtime, e.g., (provide/contract (add (-> number? number? number?))).

Answer-20: Promises represent deferred computations, evaluated using force.

Answer-21: Modules are created using the module keyword or #lang directive.

Answer-22: delay creates a promise for lazy evaluation.

Answer-23: Performance is optimized using techniques like tail recursion, lazy evaluation, and efficient data structures.

Answer-24: Immutable pairs are created using cons and cannot be modified after creation.

Answer-25: provide exports functions or variables from a module for use by other modules.

Answer-26: Racket includes rackunit, a testing library for unit tests and assertions.

Answer-27: Continuations represent the rest of the computation at any point, manipulated using call/cc.

Answer-28: racket/gui provides tools for creating graphical user interfaces.

Answer-29: Debugging in Racket is done using the DrRacket IDE's debugger or trace for tracing function calls.

Answer-30: syntax-case enables pattern matching on syntax objects in macro definitions.

Answer-31: Custom languages are implemented by defining modules with the #lang directive and using Racket's language creation tools.

Answer-32: Streams are lazy lists, evaluated only when needed.

Answer-33: map applies a function to each list element, returning a new list, while for is more general for iteration.

Answer-34: Parallel processing is done using libraries like future or racket/place.

Answer-35: Racket is a general-purpose programming language derived from Scheme, designed for both scripting and programming language design.

Answer-36: Racket supports functional programming, macros, a rich standard library, and tools for language creation and embedding.

Answer-37: Racket extends Scheme with a more robust standard library, language-oriented programming tools, and enhanced macros.

Answer-38: DrRacket is the integrated development environment (IDE) for Racket, providing features like a debugger, syntax highlighting, and interactive REPL.

Answer-39: REPL (Read-Eval-Print Loop) is an interactive shell for executing Racket code and seeing results immediately.

Answer-40: Modules are units of code organization in Racket, defined with the #lang directive to specify a language.

Answer-41: Variables are defined using the define keyword, e.g., (define x 10).

Answer-42: Lists are ordered collections of elements, created using '(1 2 3) or (list 1 2 3).

Answer-43: Functions are created using the define keyword with a lambda expression or direct syntax, e.g., (define (add x y) (+ x y)).

Answer-44: cond is used for multi-branch conditional expressions, similar to a switch or if-else if ladder.

Answer-45: let binds variables to values within a limited scope.

Answer-46: Macros are tools for generating code programmatically, allowing syntax extension and metaprogramming.

Answer-47: Recursion is handled by defining functions that call themselves, commonly used for operations on lists and trees.

Answer-48: First-class functions can be passed as arguments, returned from other functions, and stored in variables.

Answer-49: Tail recursion is a form of recursion where the recursive call is the last operation in the function, optimizing memory usage.

Answer-50: Higher-order functions like map, filter, and fold operate on functions and collections, e.g., (map add1 '(1 2 3)).