Re: Download Stack Mac
Lorean Hoefert
Welcome to the Haskell programming language and theHaskell Tool Stack (Stack)! Stack is a program for developing Haskell projects.It is aimed at Haskellers both new and experienced. It is cross-platform andaims to support fully users on Linux, macOS and Windows.
In addition to the methods described below, Stack can also be installedusing the separate GHCup installer forHaskell-related tools. GHCup provides Stack for some combinations of machinearchitecture and operating system not provided elsewhere. By default, thescript to install GHCup (which can be run more than once) also configuresStack so that if Stack needs a version of GHC, GHCup takes over obtainingand installing that version.
The script at get.haskellstack.org willask for root access using sudo. It needs such access in order to useyour platform's package manager to install dependencies and to installto /usr/local/bin. If you prefer more control, follow the manualinstallation instructions in theinstall and upgrade guide.
The script at get.haskellstack.orgwill ask for root access using sudo. It needs such access in orderto use your platform's package manager to install dependencies andto install to /usr/local/bin. If you prefer more control, followthe manual installation instructions in theinstall and upgrade guide.
The Windows installer for Stack 2.9.1, 2.9.3 and 2.11.1 (only) willreplace the user PATH environment variable (rather than append to it)if a 1024 character limit is exceeded. If the content of your existinguser PATH is long, preserve it before running the installer.
As your project develops, you may need to depend on a library provided byanother Haskell package. If you do, then add the name of that new package to thefile package.yaml, in its dependencies: section.
If Stack reports that the Stack configuration has no specified version for thenew package, then follow Stack's likely recommended action to add a specificversion of that package your project's stack.yaml file, in its extra-deps:section.
Stack is a build tool for Haskell designed to answer the needs of Haskell users,both new and experienced. It has a strong focus on reproducible build plans,multi-package projects, and a consistent, easy-to-learn set of Stack commands.It also aims to provide the customizability and power that experienceddevelopers need.
Stack is provided by a team of volunteers and companies under the auspices ofthe Commercial Haskell group. The project wasspearheaded by FP Complete to answer the needs ofcommercial Haskell users. It has since become a thriving open source projectmeeting the needs of Haskell users of all stripes.
Additionally, a peek operation can, without modifying the stack, return the value of the last element added. The name stack is an analogy to a set of physical items stacked one atop another, such as a stack of plates.
The order in which an element added to or removed from a stack is described as last in, first out, referred to by the acronym LIFO.[nb 1] As with a stack of physical objects, this structure makes it easy to take an item off the top of the stack, but accessing a datum deeper in the stack may require removing multiple other items first.[1]
Considered a linear data structure, or more abstractly a sequential collection, a stack has one end which is the only position at which the push and pop operations may occur, the top of the stack, and is fixed at the other end, the bottom. This data structure makes it possible to implement a stack as a singly linked list and as a pointer to the top element. A stack may be implemented to have a bounded capacity. If the stack is full and does not contain enough space to accept another element, the stack is in a state of stack overflow.
Stacks entered the computer science literature in 1946, when Alan Turing used the terms "bury" and "unbury" as a means of calling and returning from subroutines.[2][3] Subroutines and a two-level stack had already been implemented in Konrad Zuse's Z4 in 1945.[4][5]
Klaus Samelson and Friedrich L. Bauer of Technical University Munich proposed the idea of a stack called Operationskeller ("operational cellar") in 1955[6][7] and filed a patent in 1957.[8][9][10][11] In March 1988, by which time Samelson was deceased, Bauer received the IEEE Computer Pioneer Award for the invention of the stack principle.[12][7] Similar concepts were independently developed by Charles Leonard Hamblin in the first half of 1954[13][7] and by Wilhelm Kmmerer [de] with his automatisches Gedchtnis ("automatic memory") in 1958.[14][15][7]
Stacks are often described using the analogy of a spring-loaded stack of plates in a cafeteria.[16][1][17] Clean plates are placed on top of the stack, pushing down any plates already there. When the top plate is removed from the stack, the one below it is elevated to become the new top plate.
In many implementations, a stack has more operations than the essential "push" and "pop" operations. An example of a non-essential operation is "top of stack", or "peek", which observes the top element without removing it from the stack.[18] Since this can be broken down into a "pop" followed by a "push" to return the same data to the stack, it is not considered an essential operation. If the stack is empty, an underflow condition will occur upon execution of either the "stack top" or "pop" operations. Additionally, many implementations provide a check if the stack is empty and an operation that returns its size.
A stack can be easily implemented either through an array or a linked list, as it is merely a special case of a list. In either case, what identifies the data structure as a stack is not the implementation but the interface: the user is only allowed to pop or push items onto the array or linked list, with few other helper operations. The following will demonstrate both implementations using pseudocode.
An array can be used to implement a (bounded) stack, as follows. The first element, usually at the zero offset, is the bottom, resulting in array[0] being the first element pushed onto the stack and the last element popped off. The program must keep track of the size (length) of the stack, using a variable top that records the number of items pushed so far, therefore pointing to the place in the array where the next element is to be inserted (assuming a zero-based index convention). Thus, the stack itself can be effectively implemented as a three-element structure:
Using a dynamic array, it is possible to implement a stack that can grow or shrink as much as needed. The size of the stack is simply the size of the dynamic array, which is a very efficient implementation of a stack since adding items to or removing items from the end of a dynamic array requires amortized O(1) time.
Some languages, such as Perl, LISP, JavaScript and Python, make the stack operations push and pop available on their standard list/array types. Some languages, notably those in the Forth family (including PostScript), are designed around language-defined stacks that are directly visible to and manipulated by the programmer.
The following is an example of manipulating a stack in Common Lisp (".mw-parser-output .monospacedfont-family:monospace,monospace>" is the Lisp interpreter's prompt; lines not starting with ">" are the interpreter's responses to expressions):
Several of the C++ Standard Library container types have push_back and pop_back operations with LIFO semantics; additionally, the stack template class adapts existing containers to provide a restricted API with only push/pop operations. PHP has an SplStack class. Java's library contains a Stack class that is a specialization of Vector. Following is an example program in Java language, using that class.
A typical stack is an area of computer memory with a fixed origin and a variable size. Initially the size of the stack is zero. A stack pointer, usually in the form of a processor register, points to the most recently referenced location on the stack; when the stack has a size of zero, the stack pointer points to the origin of the stack.
There are many variations on the basic principle of stack operations. Every stack has a fixed location in memory at which it begins. As data items are added to the stack, the stack pointer is displaced to indicate the current extent of the stack, which expands away from the origin.
Stack pointers may point to the origin of a stack or to a limited range of addresses above or below the origin (depending on the direction in which the stack grows); however, the stack pointer cannot cross the origin of the stack. In other words, if the origin of the stack is at address 1000 and the stack grows downwards (towards addresses 999, 998, and so on), the stack pointer must never be incremented beyond 1000 (to 1001 or beyond). If a pop operation on the stack causes the stack pointer to move past the origin of the stack, a stack underflow occurs. If a push operation causes the stack pointer to increment or decrement beyond the maximum extent of the stack, a stack overflow occurs.
Stacks are often visualized growing from the bottom up (like real-world stacks). They may also be visualized growing from left to right, where the top is on the far right, or even growing from top to bottom. The important feature is for the bottom of the stack to be in a fixed position. The illustration in this section is an example of a top-to-bottom growth visualization: the top (28) is the stack "bottom", since the stack "top" (9) is where items are pushed or popped from.
A stack is usually represented in computers by a block of memory cells, with the "bottom" at a fixed location, and the stack pointer holding the address of the current "top" cell in the stack. The "top" and "bottom" nomenclature is used irrespective of whether the stack actually grows towards higher memory addresses.
7fc3f7cf58