Alternatively, save the program to a file and run racket from the command line on the file. Racket is an implementation of Scheme. If you know Racket, please write code for some of the tasks not implemented in Racket. Listed below are all of the tasks on Rosetta Code which have been solved using Racket. This programming language may be used to instruct a computer to perform a task.
For additional reference, see the Racket Guide.Racket, the child of Scheme and grandchild of LISP, falls into a broad category of programming languages often called functional programming languages. Lexical Scope via Environments and ClosuresThe Racket language is our first lens for examining programming language design in CS 251.This document introduces the same kernel of the Racket language as covered in lecture. Example with Environments, Bindings, and Variables Defining Racket: Expressions and Values
Racket Programming Examples How To Compute It
GoalsOur top-level goals in studying Racket are several, including: Functional languages are closer to math imperative languages are closer to the model presented by most modern computer hardware systems. In some sense, functional languages are a little closer to expressing what to compute, while imperative (command-, statement-, and assignment-focused) languages are closer to expressing how to compute it. Functional languages are built around the evaluation of expressions and the application of functions for their results, rather than the execution of sequences of commands for their effects on mutable stored data. Unfortunately, the term can be a bit confusing, since many other languages (such C, Python, and others) use constructs called functions, even though they do not always follow a “functional” style.
First-class functions, higher-order functions, function closures Expressions, values, variables, bindings, environments Define and understand the syntax and dynamic semantics of a small programming language kernel: This experience (probably new to many of you) not only introduces you to a powerful, expressive, and elegant approach to programming, but it also helps you learn to think about problems in new ways.
Hence our references to using the language as a “lens” for studying big PL ideas. Certainly you will learn Racket and other languages (a nice side effect of the course), but we are big picture goals are skills that are more transferable than intimate knowledge of a single programming language. Semantics via judgments, inference rules, derivations, and the environment modelYou may be surprised that “learn the Racket language” is not listed as an explicit goal.
Racket is part of a family of closely related languages supported by DrRacket. ToolsWe will use the DrRacket environment for Racket programming. Before long we will move on to use a new lens, but there is much more Racket to explore beyond our coverage.
An expression is evaluated to a value according to a set of evaluation rules. Define its evaluation rules (dynamic semantics): What is its meaning? How is it evaluated?An expression e may or may not have a value v. Define its syntax: What is its form? How is it written? (The same holds for any well-defined programming language and the related tools and implementations.) Defining Racket: Expressions and ValuesA Racket program consists of definitions and expressions, evaluated in order.
The evaluation rule for values is that a value evaluates to itself. The number 251 is written in Racket as the series of digits 251. ValuesThe simplest kind of expression is a value.
Other ValuesBesides number values, Racket has several other types of values, including boolean values, with syntax #t (true) and #f (false). semantics: how to evaluate a number value ( i.e., evaluation rules)As we build up the core of the Racket language we will continue in this manner, rapidly adding more constructs to the language by describing their syntax and semantics (evaluation rules). We specified two things about number values: In other words, values are expressions that cannot be evaluated any further.Trivial as number values may seem, the way we defined them is important. All values are expressions, but not all expressions are values.
For example, we could write ( + 251 251 ) and we could also write ( + ( + 240 251 ) ( + 235 301 )) or even ( + #t 251 ). The syntax of a Racket addition expression is:Here, e1 and e2 are expressions. Arithmetic ExpressionsAs an example of a (slightly) more interesting expression, let us consider addition. The syntax for different types of values differs, but their evaluation rules remain the same: a value evaluates to itself.
The evaluation rule for Racket + makes it clear that Racket does dynamic type-checking, meaning it checks specific types of values when evaluation reaches an operation that actually requires a particular type of value. For example, 251 is a number value, while #t is a boolean value. If both v1 and v2 are numbers, then the result is a number value that is the arithmetic sum of v1 and v2, otherwise a type error occurs.There are two interesting considerations arising from the syntax and evaluation rules for Racket addition:Dynamic Type-Checking: Every value has a type. Evaluate expression e1 to value v1 and then evaluate expression e2 to value v2 then The latter approach, familiar from many other programming languages, is called infix notation.The evaluation rule for an addition expression is: Racket uses prefix notation, where operators in expressions like addition are written before their operands rather than between.
Since the structure of an expression may be arbitrarily deep, its evaluation must proceed recursively. This is visible in the syntax. Static type-checking later.Recursive Structure and Evaluation: Expressions that are not values contain other expressions, meaning the structure of an expression is recursive in nature. We will return to discuss dynamic vs. This is in contrast to compile-time static type-checking that you know from the Java language or others.
(For now, rather than quoting all terminals and angle bracketing all non-terminals, we use different font faces to distinguish grammar elements. (CS 235 includes extended study of context-free grammars and the languages they can describe.) We use a notation similar to Backus-Naur Form (BNF). Formally, grammars are powerful tools with many variations. Syntax Definitions with Grammars\newcommandTo define the syntax of a language, we will use grammars. To meet this need, we will use formal notations or meta-languages to give more precise definitions.
0 kommentar(er)
