In this chapter, we describe the syntax and informal semantics of Haskell declarations.
| module | → | module modid [exports] where body | |
| | | body | ||
| body | → | { impdecls ; topdecls } | |
| | | { impdecls } | ||
| | | { topdecls } | ||
| topdecls | → | topdecl1 ; … ; topdecln | (n ≥ 1) |
| topdecl | → | type simpletype = type | |
| | | data [context =>] simpletype [= constrs] [deriving] | ||
| | | newtype [context =>] simpletype = newconstr [deriving] | ||
| | | class [scontext =>] tycls tyvar [where cdecls] | ||
| | | instance [scontext =>] qtycls inst [where idecls] | ||
| | | default (type1 , … , typen) | (n ≥ 0) | |
| | | foreign fdecl | ||
| | | decl | ||
| decls | → | { decl1 ; … ; decln } | (n ≥ 0) |
| decl | → | gendecl | |
| | | (funlhs | pat) rhs | ||
| cdecls | → | { cdecl1 ; … ; cdecln } | (n ≥ 0) |
| cdecl | → | gendecl | |
| | | (funlhs | var) rhs | ||
| idecls | → | { idecl1 ; … ; idecln } | (n ≥ 0) |
| idecl | → | (funlhs | var) rhs | |
| | | (empty) | ||
| gendecl | → | vars :: [context =>] type | (type signature) |
| | | fixity [integer] ops | (fixity declaration) | |
| | | (empty declaration) | ||
| ops | → | op1 , … , opn | (n ≥ 1) |
| vars | → | var1 , … , varn | (n ≥ 1) |
| fixity | → | infixl | infixr | infix |
The declarations in the syntactic category topdecls are only allowed at the top level of a Haskell module (see Chapter 5), whereas decls may be used either at the top level or in nested scopes (i.e. those within a let or where construct).
For exposition, we divide the declarations into three groups: user-defined datatypes, consisting of type, newtype, and data declarations (Section 4.2); type classes and overloading, consisting of class, instance, and default declarations (Section 4.3); and nested declarations, consisting of value bindings, type signatures, and fixity declarations (Section 4.4).
Haskell has several primitive datatypes that are “hard-wired” (such as integers and floating-point numbers), but most “built-in” datatypes are defined with normal Haskell code, using normal type and data declarations. These “built-in” datatypes are described in detail in Section 6.1.
Haskell uses a traditional Hindley-Milner polymorphic type system to provide a static type semantics [4, 6], but the type system has been extended with type classes (or just classes) that provide a structured way to introduce overloaded functions.
A class declaration (Section 4.3.1) introduces a new type class and the overloaded operations that must be supported by any type that is an instance of that class. An instance declaration (Section 4.3.2) declares that a type is an instance of a class and includes the definitions of the overloaded operations—called class methods—instantiated on the named type.
For example, suppose we wish to overload the operations (+) and negate on types Int and Float. We introduce a new type class called Num:
This declaration may be read “a type a is an instance of the class Num if there are class methods (+) and negate, of the given types, defined on it.”
We may then declare Int and Float to be instances of this class:
where addInt, negateInt, addFloat, and negateFloat are assumed in this case to be primitive functions, but in general could be any user-defined function. The first declaration above may be read “Int is an instance of the class Num as witnessed by these definitions (i.e. class methods) for (+) and negate.”
More examples of type classes can be found in the papers by Jones [8] or Wadler and Blott [13]. The term ‘type class’ was used to describe the original Haskell 1.0 type system; ‘constructor class’ was used to describe an extension to the original type classes. There is no longer any reason to use two different terms: in this report, ‘type class’ includes both the original Haskell type classes and the constructor classes introduced by Jones.
To ensure that they are valid, type expressions are classified into different kinds, which take one of two possible forms:
Kind inference checks the validity of type expressions in a similar way that type inference checks the validity of value expressions. However, unlike types, kinds are entirely implicit and are not a visible part of the language. Kind inference is discussed in Section 4.6.
| type | → | btype [-> type] | (function type) |
| btype | → | [btype] atype | (type application) |
| atype | → | gtycon | |
| | | tyvar | ||
| | | ( type1 , … , typek ) | (tuple type, k ≥ 2) | |
| | | [ type ] | (list type) | |
| | | ( type ) | (parenthesised constructor) | |
| gtycon | → | qtycon | |
| | | () | (unit type) | |
| | | [] | (list constructor) | |
| | | (->) | (function constructor) | |
| | | (,{,}) | (tupling constructors) |
The syntax for Haskell type expressions is given above. Just as data values are built using data constructors, type values are built from type constructors. As with data constructors, the names of type constructors start with uppercase letters. Unlike data constructors, infix type constructors are not allowed (other than (->)).
The main forms of type expression are as follows:
Special syntax is provided for certain built-in type constructors:
Use of the (->) and [] constants is described in more detail below.
For example, the type expression IO a can be understood as the application of a constant, IO, to the variable a. Since the IO type constructor has kind ∗→∗, it follows that both the variable a and the whole expression, IO a, must have kind ∗. In general, a process of kind inference (see Section 4.6) is needed to determine appropriate kinds for user-defined datatypes, type synonyms, and classes.
Special syntax is provided to allow certain type expressions to be written in a more traditional style:
These special syntactic forms always denote the built-in type constructors for functions, tuples, and lists, regardless of what is in scope. In a similar way, the prefix type constructors (->), [], (), (,), and so on, always denote the built-in type constructors; they cannot be qualified, nor mentioned in import or export lists (Chapter 5). (Hence the special production, “gtycon”, above.)
Although the list and tuple types have special syntax, their semantics is the same as the equivalent user-defined algebraic data types.
Notice that expressions and types have a consistent syntax. If ti is the type of expression or pattern ei, then the expressions (\ e1 -> e2), [e1], and (e1,e2) have the types (t1 -> t2), [t1], and (t1,t2), respectively.
With one exception (that of the distinguished type variable in a class declaration (Section 4.3.1)), the type variables in a Haskell type expression are all assumed to be universally quantified; there is no explicit syntax for universal quantification [4]. For example, the type expression a -> a denotes the type ∀ a. a → a. For clarity, however, we often write quantification explicitly when discussing the types of Haskell programs. When we write an explicitly quantified type, the scope of the ∀ extends as far to the right as possible; for example, ∀ a. a → a means ∀ a. (a → a).
| context | → | class | |
| | | ( class1 , … , classn ) | (n ≥ 0) | |
| class | → | qtycls tyvar | |
| | | qtycls ( tyvar atype1 … atypen ) | (n ≥ 1) | |
| qtycls | → | [ modid . ] tycls | |
| tycls | → | conid | |
| tyvar | → | varid |
A class assertion has form qtycls tyvar, and indicates the membership of the type tyvar in the class qtycls. A class identifier begins with an uppercase letter. A context consists of zero or more class assertions, and has the general form ( C1 u1, …, Cn un ) where C1, …, Cn are class identifiers, and each of the u1, …, un is either a type variable, or the application of type variable to one or more types. The outer parentheses may be omitted when n = 1. In general, we use cx to denote a context and we write cx => t to indicate the type t restricted by the context cx. The context cx must only contain type variables referenced in t. For convenience, we write cx => t even if the context cx is empty, although in this case the concrete syntax contains no =>.
In this section, we provide informal details of the type system. (Wadler and Blott [13] and Jones [8] discuss type and constructor classes, respectively, in more detail.)
The Haskell type system attributes a type to each expression in the program. In general, a type is of the form ∀ u. cx ⇒ t, where u is a set of type variables u1, …, un. In any such type, any of the universally-quantified type variables ui that are free in cx must also be free in t. Furthermore, the context cx must be of the form given above in Section 4.1.3. For example, here are some valid types:
In the third type, the constraint Eq (f a) cannot be made simpler because f is universally quantified.
The type of an expression e depends on a type environment that gives types for the free variables in e, and a class environment that declares which types are instances of which classes (a type becomes an instance of a class only via the presence of an instance declaration or a deriving clause).
Types are related by a generalization preorder (specified below); the most general type, up to the equivalence induced by the generalization preorder, that can be assigned to a particular expression (in a given environment) is called its principal type. Haskell’s extended Hindley-Milner type system can infer the principal type of all expressions, including the proper use of overloaded class methods (although certain ambiguous overloadings could arise, as described in Section 4.3.4). Therefore, explicit typings (called type signatures) are usually optional (see Sections 3.16 and 4.4.1).
The type ∀ u. cx1 ⇒ t1 is more general than the type ∀ w. cx2 ⇒ t2 if and only if there is a substitution S whose domain is u such that:
A value of type ∀ u. cx ⇒ t, may be instantiated at types s if and only if the context cx[s∕u] holds. For example, consider the function double:
The most general type of double is ∀ a. Num a ⇒ a → a. double may be applied to values of type Int (instantiating a to Int), since Num Int holds, because Int is an instance of the class Num. However, double may not normally be applied to values of type Char, because Char is not normally an instance of class Num. The user may choose to declare such an instance, in which case double may indeed be applied to a Char.
In this section, we describe algebraic datatypes (data declarations), renamed datatypes (newtype declarations), and type synonyms (type declarations). These declarations may only appear at the top level of a module.
| topdecl | → | data [context =>] simpletype [= constrs] [deriving] | |
| simpletype | → | tycon tyvar1 … tyvark | (k ≥ 0) |
| constrs | → | constr1 | … | constrn | (n ≥ 1) |
| constr | → | con [!] atype1 … [!] atypek | (arity con = k, k ≥ 0) |
| | | (btype | ! atype) conop (btype | ! atype) | (infix conop) | |
| | | con { fielddecl1 , … , fielddecln } | (n ≥ 0) | |
| fielddecl | → | vars :: (type | ! atype) | |
| deriving | → | deriving (dclass | (dclass1, … , dclassn)) | (n ≥ 0) |
| dclass | → | qtycls |
The precedence for constr is the same as that for expressions—normal constructor application has higher precedence than infix constructor application (thus a : Foo a parses as a : (Foo a)).
An algebraic datatype declaration has the form: data cx => T u1 … uk = K1 t11 … t1k1 | | Kn tn1 … tnkn where cx is a context. This declaration introduces a new type constructor T with zero or more constituent data constructors K1, …, Kn. In this Report, the unqualified term “constructor” always means “data constructor”.
The types of the data constructors are given by: Ki :: ∀ u1 … uk. cxi ⇒ ti1 → → tiki → (T u1 … uk) where cxi is the largest subset of cx that constrains only those type variables free in the types ti1, …, tiki. The type variables u1 through uk must be distinct and may appear in cx and the tij; it is a static error for any other type variable to appear in cx or on the right-hand-side. The new type constant T has a kind of the form κ1 →… → κk →∗ where the kinds κi of the argument variables ui are determined by kind inference as described in Section 4.6. This means that T may be used in type expressions with anywhere between 0 and k arguments.
For example, the declaration
introduces a type constructor Set of kind ∗→∗, and constructors NilSet and ConsSet with types
NilSet | :: ∀ a. Set a |
ConsSet | :: ∀ a. Eq a ⇒ a → Set a → Set a |
the function f has inferred type Eq a => Set a -> a. The context in the data declaration has no other effect whatsoever.
The visibility of a datatype’s constructors (i.e. the “abstractness” of the datatype) outside of the module in which the datatype is defined is controlled by the form of the datatype’s name in the export list as described in Section 5.8.
The optional deriving part of a data declaration has to do with derived instances, and is described in Section 4.3.3.
Labelled Fields A data constructor of arity k creates an object with k components. These components are normally accessed positionally as arguments to the constructor in expressions or patterns. For large datatypes it is useful to assign field labels to the components of a data object. This allows a specific field to be referenced independently of its location within the constructor.
A constructor definition in a data declaration may assign labels to the fields of the constructor, using the record syntax (C { ... }). Constructors using field labels may be freely mixed with constructors without them. A constructor with associated field labels may still be used as an ordinary constructor; features using labels are simply a shorthand for operations using an underlying positional constructor. The arguments to the positional constructor occur in the same order as the labeled fields. For example, the declaration
defines a type and constructor identical to the one produced by
Operations using field labels are described in Section 3.15. A data declaration may use the same field label in multiple constructors as long as the typing of the field is the same in all cases after type synonym expansion. A label cannot be shared by more than one type in scope. Field names share the top level namespace with ordinary variables and class methods and must not conflict with other top level names in scope.
The pattern F {} matches any value built with constructor F, whether or not F was declared with record syntax.
Strictness Flags Whenever a data constructor is applied, each argument to the constructor is evaluated if and only if the corresponding type in the algebraic datatype declaration has a strictness flag, denoted by an exclamation point, “!”. Lexically, “!” is an ordinary varsym not a reservedop; it has special significance only in the context of the argument types of a data declaration.
Translation: A declaration of the form data cx => T u1 … uk = … | K s1 … sn | … where each si is either of the form !ti or ti, replaces every occurrence of K in an expression by (\ x1 … xn -> ( ((K op1 x1) op2 x2) … ) opn xn) where opi is the non-strict apply function $ if si is of the form ti, and opi is the strict apply function $! (see Section 6.2) if si is of the form ! ti. Pattern matching on K is not affected by strictness flags.
| topdecl | → | type simpletype = type | |
| simpletype | → | tycon tyvar1 … tyvark | (k ≥ 0) |
A type synonym declaration introduces a new type that is equivalent to an old type. It has the form type T u1 … uk = t which introduces a new type constructor, T . The type (T t1 …tk) is equivalent to the type t[t1∕u1, …, tk∕uk]. The type variables u1 through uk must be distinct and are scoped only over t; it is a static error for any other type variable to appear in t. The kind of the new type constructor T is of the form κ1 →… → κk → κ where the kinds κi of the arguments ui and κ of the right hand side t are determined by kind inference as described in Section 4.6. For example, the following definition can be used to provide an alternative way of writing the list type constructor:
Type constructor symbols T introduced by type synonym declarations cannot be partially applied; it is a static error to use T without the full number of arguments.
Although recursive and mutually recursive datatypes are allowed, this is not so for type synonyms, unless an algebraic datatype intervenes. For example,
is allowed, whereas
is not. Similarly, type Rec a = [Rec a] is not allowed.
Type synonyms are a convenient, but strictly syntactic, mechanism to make type signatures more readable. A synonym and its definition are completely interchangeable, except in the instance type of an instance declaration (Section 4.3.2).
| topdecl | → | newtype [context =>] simpletype = newconstr [deriving] | |
| newconstr | → | con atype | |
| | | con { var :: type } | ||
| simpletype | → | tycon tyvar1 … tyvark | (k ≥ 0) |
A declaration of the form newtype cx => T u1 … uk = N t introduces a new type whose representation is the same as an existing type. The type (T u1… uk) renames the datatype t. It differs from a type synonym in that it creates a distinct type that must be explicitly coerced to or from the original type. Also, unlike type synonyms, newtype may be used to define recursive types. The constructor N in an expression coerces a value from type t to type (T u1 … uk). Using N in a pattern coerces a value from type (T u1 … uk) to type t. These coercions may be implemented without execution time overhead; newtype does not change the underlying representation of an object.
New instances (see Section 4.3.2) can be defined for a type defined by newtype but may not be defined for a type synonym. A type created by newtype differs from an algebraic datatype in that the representation of an algebraic datatype has an extra level of indirection. This difference may make access to the representation less efficient. The difference is reflected in different rules for pattern matching (see Section 3.17). Unlike algebraic datatypes, the newtype constructor N is unlifted, so that N ⊥ is the same as ⊥.
The following examples clarify the differences between data (algebraic datatypes), type (type synonyms), and newtype (renaming types.) Given the declarations
the expressions (d1 ⊥), (d2 ⊥) and (d2 (D2 ⊥)) are all equivalent to ⊥, whereas (n ⊥), (n (N ⊥)), (d1 (D1 ⊥)) and (s ⊥) are all equivalent to 42. In particular, (N ⊥) is equivalent to ⊥ while (D1 ⊥) is not equivalent to ⊥.
The optional deriving part of a newtype declaration is treated in the same way as the deriving component of a data declaration; see Section 4.3.3.
A newtype declaration may use field-naming syntax, though of course there may only be one field. Thus:
brings into scope both a constructor and a de-constructor:
| topdecl | → | class [scontext =>] tycls tyvar [where cdecls] | |
| scontext | → | simpleclass | |
| | | ( simpleclass1 , … , simpleclassn ) | (n ≥ 0) | |
| simpleclass | → | qtycls tyvar | |
| cdecls | → | { cdecl1 ; … ; cdecln } | (n ≥ 0) |
| cdecl | → | gendecl | |
| | | (funlhs | var) rhs |
A class declaration introduces a new class and the operations (class methods) on it. A class declaration has the general form:
class cx => C u where cdecls |
The superclass relation must not be cyclic; i.e. it must form a directed acyclic graph.
The cdecls part of a class declaration contains three kinds of declarations:
The type of the top-level class method vi is: vi :: ∀u,w. (Cu,cxi) ⇒ ti The ti must mention u; it may mention type variables w other than u, in which case the type of vi is polymorphic in both u and w. The cxi may constrain only w; in particular, the cxi may not constrain u. For example:
Here the type of op is ∀ a, b. (Foo a, Num b) ⇒ a → b → a.
is not permitted, because the left hand side of the default declaration is a pattern.
Other than these cases, no other declarations are permitted in cdecls.
A class declaration with no where part may be useful for combining a collection of classes into a larger one that inherits all of the class methods in the original ones. For example:
In such a case, if a type is an instance of all superclasses, it is not automatically an instance of the subclass, even though the subclass has no immediate class methods. The instance declaration must be given explicitly with no where part.
| topdecl | → | instance [scontext =>] qtycls inst [where idecls] | |
| inst | → | gtycon | |
| | | ( gtycon tyvar1 … tyvark ) | (k ≥ 0, tyvars distinct) | |
| | | ( tyvar1 , … , tyvark ) | (k ≥ 2, tyvars distinct) | |
| | | [ tyvar ] | ||
| | | ( tyvar1 -> tyvar2 ) | (tyvar1 and tyvar2 distinct) | |
| idecls | → | { idecl1 ; … ; idecln } | (n ≥ 0) |
| idecl | → | (funlhs | var) rhs | |
| | | (empty) |
An instance declaration introduces an instance of a class. Let class cx => C u where { cbody } be a class declaration. The general form of the corresponding instance declaration is: instance cx′ => C (T u1 … uk) where { d } where k ≥ 0. The type (T u1 … uk) must take the form of a type constructor T applied to simple type variables u1, … uk; furthermore, T must not be a type synonym, and the ui must all be distinct.
This prohibits instance declarations such as:
The declarations d may contain bindings only for the class methods of C. It is illegal to give a binding for a class method that is not in scope, but the name under which it is in scope is immaterial; in particular, it may be a qualified name. (This rule is identical to that used for subordinate names in export lists — Section 5.2.) For example, this is legal, even though range is in scope only with the qualified name Data.Ix.range.
The declarations may not contain any type signatures or fixity declarations, since these have already been given in the class declaration. As in the case of default class methods (Section 4.3.1), the method declarations must take the form of a variable or function definition.
If no binding is given for some class method then the corresponding default class method in the class declaration is used (if present); if such a default does not exist then the class method of this instance is bound to undefined and no compile-time error results.
An instance declaration that makes the type T to be an instance of class C is called a C-T instance declaration and is subject to these static restrictions:
In fact, except in pathological cases it is possible to infer from the instance declaration the most general instance context cx′ satisfying the above two constraints, but it is nevertheless mandatory to write an explicit instance context.
The following example illustrates the restrictions imposed by superclass instances:
This example is valid Haskell. Since Foo is a superclass of Bar, the second instance declaration is only valid if [a] is an instance of Foo under the assumption Num a. The first instance declaration does indeed say that [a] is an instance of Foo under this assumption, because Eq and Show are superclasses of Num.
If the two instance declarations instead read like this:
then the program would be invalid. The second instance declaration is valid only if [a] is an instance of Foo under the assumptions (Eq a, Show a). But this does not hold, since [a] is only an instance of Foo under the stronger assumption Num a.
Further examples of instance declarations may be found in Chapter 9.
As mentioned in Section 4.2.1, data and newtype declarations contain an optional deriving form. If the form is included, then derived instance declarations are automatically generated for the datatype in each of the named classes. These instances are subject to the same restrictions as user-defined instances. When deriving a class C for a type T , instances for all superclasses of C must exist for T , either via an explicit instance declaration or by including the superclass in the deriving clause.
Derived instances provide convenient commonly-used operations for user-defined datatypes. For example, derived instances for datatypes in the class Eq define the operations == and /=, freeing the programmer from the need to define them.
The only classes in the Prelude for which derived instances are allowed are Eq, Ord, Enum, Bounded, Show, and Read, all mentioned in Figure 6.1. The precise details of how the derived instances are generated for each of these classes are provided in Chapter 11, including a specification of when such derived instances are possible. Classes defined by the standard libraries may also be derivable.
A static error results if it is not possible to derive an instance declaration over a class named in a deriving form. For example, not all datatypes can properly support class methods in Enum. It is also a static error to give an explicit instance declaration for a class that is also derived.
If the deriving form is omitted from a data or newtype declaration, then no instance declarations are derived for that datatype; that is, omitting a deriving form is equivalent to including an empty deriving form: deriving ().
| topdecl | → | default (type1 , … , typen) | (n ≥ 0) |
A problem inherent with Haskell-style overloading is the possibility of an ambiguous type. For example, using the read and show functions defined in Chapter 11, and supposing that just Int and Bool are members of Read and Show, then the expression
is ambiguous, because the types for show and read,
show | :: ∀ a. Show a ⇒ a → String |
read | :: ∀ a. Read a ⇒ String → a |
We say that an expression e has an ambiguous type if, in its type ∀ u. cx ⇒ t, there is a type variable u in u that occurs in cx but not in t. Such types are invalid.
For example, the earlier expression involving show and read has an ambiguous type since its type is ∀ a. Show a, Read a ⇒ String.
Ambiguous types can only be circumvented by input from the user. One way is through the use of expression type-signatures as described in Section 3.16. For example, for the ambiguous expression given earlier, one could write:
which disambiguates the type.
Occasionally, an otherwise ambiguous expression needs to be made the same type as some variable, rather than being given a fixed type with an expression type-signature. This is the purpose of the function asTypeOf (Chapter 9): x ‘asTypeOf‘ y has the value of x, but x and y are forced to have the same type. For example,
(See Section 6.4.6 for a description of encodeFloat and exponent.)
Ambiguities in the class Num are most common, so Haskell provides another way to resolve them—with a default declaration: default (t1 , … , tn) where n ≥ 0, and each ti must be a type for which Num ti holds. In situations where an ambiguous type is discovered, an ambiguous type variable, v, is defaultable if:
Each defaultable variable is replaced by the first type in the default list that is an instance of all the ambiguous variable’s classes. It is a static error if no such type is found.
Only one default declaration is permitted per module, and its effect is limited to that module. If no default declaration is given in a module then it assumed to be:
The empty default declaration, default (), turns off all defaults in a module.
The following declarations may be used in any declaration list, including the top level of a module.
| gendecl | → | vars :: [context =>] type | |
| vars | → | var1 , …, varn | (n ≥ 1) |
A type signature specifies types for variables, possibly with respect to a context. A type signature has the form: v1, …, vn :: cx => t which is equivalent to asserting vi :: cx => t for each i from 1 to n. Each vi must have a value binding in the same declaration list that contains the type signature; i.e. it is invalid to give a type signature for a variable bound in an outer scope. Moreover, it is invalid to give more than one type signature for one variable, even if the signatures are identical.
As mentioned in Section 4.1.2, every type variable appearing in a signature is universally quantified over that signature, and hence the scope of a type variable is limited to the type signature that contains it. For example, in the following declarations
the a’s in the two type signatures are quite distinct. Indeed, these declarations contain a static error, since x does not have type ∀ a. a. (The type of x is dependent on the type of f; there is currently no way in Haskell to specify a signature for a variable with a dependent type; this is explained in Section 4.5.4.)
If a given program includes a signature for a variable f, then each use of f is treated as having the declared type. It is a static error if the same type cannot also be inferred for the defining occurrence of f.
If a variable f is defined without providing a corresponding type signature declaration, then each use of f outside its own declaration group (see Section 4.5) is treated as having the corresponding inferred, or principal type . However, to ensure that type inference is still possible, the defining occurrence, and all uses of f within its declaration group must have the same monomorphic type (from which the principal type is obtained by generalization, as described in Section 4.5.2).
For example, if we define
then the principal type is sqr :: ∀ a. Num a ⇒ a → a, which allows applications such as sqr 5 or sqr 0.1. It is also valid to declare a more specific type, such as
but now applications such as sqr 0.1 are invalid. Type signatures such as
are invalid, as they are more general than the principal type of sqr.
Type signatures can also be used to support polymorphic recursion. The following definition is pathological, but illustrates how a type signature can be used to specify a type more general than the one that would be inferred:
If we remove the signature declaration, the type of f will be inferred as T Int -> Int due to the first recursive call for which the argument to f is T Int. Polymorphic recursion allows the user to supply the more general type signature, T a -> a.
| gendecl | → | fixity [integer] ops | |
| fixity | → | infixl | infixr | infix | |
| ops | → | op1 , … , opn | (n ≥ 1) |
| op | → | varop | conop |
A fixity declaration gives the fixity and binding precedence of one or more operators. The integer in a fixity declaration must be in the range 0 to 9. A fixity declaration may appear anywhere that a type signature appears and, like a type signature, declares a property of a particular operator. Also like a type signature, a fixity declaration can only occur in the same sequence of declarations as the declaration of the operator itself, and at most one fixity declaration may be given for any operator. (Class methods are a minor exception; their fixity declarations can occur either in the class declaration itself or at top level.)
There are three kinds of fixity, non-, left- and right-associativity (infix, infixl, and infixr, respectively), and ten precedence levels, 0 to 9 inclusive (level 0 binds least tightly, and level 9 binds most tightly). If the digit is omitted, level 9 is assumed. Any operator lacking a fixity declaration is assumed to be infixl 9 (See Section 3 for more on the use of fixities). Table 4.1 lists the fixities and precedences of the operators defined in the Prelude.
| Prec- | Left associative | Non-associative | Right associative |
| edence | operators | operators | operators |
| 9 | !! | . | |
| 8 | ^ , ^^ , ⋆⋆ | ||
| 7 | ⋆, /, ‘div‘, | ||
| ‘mod‘, ‘rem‘, ‘quot‘ | |||
| 6 | +, - | ||
| 5 | :, ++ | ||
| 4 | ==, /=, <, <=, >, >=, | ||
| ‘elem‘, ‘notElem‘ | |||
| 3 | && | ||
| 2 | || | ||
| 1 | >>, >>= | ||
| 0 | $, $!, ‘seq‘ | ||
Fixity is a property of a particular entity (constructor or variable), just like its type; fixity is not a property of that entity’s name. For example:
Here, ‘Bar.op‘ is infixr 7, ‘Foo.op‘ is infix 3, and the nested definition of op in f’s right-hand side has the default fixity of infixl 9. (It would also be possible to give a fixity to the nested definition of ‘op‘ with a nested fixity declaration.)
We distinguish two cases within this syntax: a pattern binding occurs when the left hand side is a pat; otherwise, the binding is called a function binding. Either binding may appear at the top-level of a module or within a where or let construct.
A function binding binds a variable to a function value. The general form of a function binding for variable x is:
x | p11 … p1k | match1 |
… |
||
x | pn1 … pnk | matchn |
= ei where { declsi } |
| gsi1 | = ei1 |
|
… |
||
| gsimi | = eimi |
|
where { declsi }
|
| True = ei where { declsi } |
Note that all clauses defining a function must be contiguous, and the number of patterns in each clause must be the same. The set of patterns corresponding to each match must be linear—no variable is allowed to appear more than once in the entire set.
Alternative syntax is provided for binding functional values to infix operators. For example, these three function definitions are all equivalent:
Note that fixity resolution applies to the infix variants of the function binding in the same way as for expressions (Section 10.6). Applying fixity resolution to the left side of the equals in a function binding must leave the varop being defined at the top level. For example, if we are defining a new operator ## with precedence 6, then this definition would be illegal:
because : has precedence 5, so the left hand side resolves to (a ## x) : xs, and this cannot be a pattern binding because (a ## x) is not a valid pattern.
A pattern binding binds variables to values. A simple pattern binding has form p = e. The pattern p is matched “lazily” as an irrefutable pattern, as if there were an implicit ~ in front of it. See the translation in Section 3.12.
The general form of a pattern binding is p match, where a match is the same structure as for function bindings above; in other words, a pattern binding is:
p | | gs1 | = e1 |
| gs2 | = e2 |
|
… |
||
| gsm | = em |
|
where { decls }
|
The static semantics of the function and pattern bindings of a let expression or where clause are discussed in this section.
In general the static semantics are given by applying the normal Hindley-Milner inference rules. In order to increase polymorphism, these rules are applied to groups of bindings identified by a dependency analysis.
A binding b1 depends on a binding b2 in the same list of declarations if either
A declaration group is a minimal set of mutually dependent bindings. Hindley-Milner type inference is applied to each declaration group in dependency order. The order of declarations in where/let constructs is irrelevant.
The Hindley-Milner type system assigns types to a let-expression in two stages:
For example, consider the declaration
The type of g’s definition is a → (a,a). The generalization step attributes to g the polymorphic type ∀ a. a → (a,a), after which the typing of the “...” part can proceed.
When typing overloaded definitions, all the overloading constraints from a single declaration group are collected together, to form the context for the type of each variable declared in the group. For example, in the definition:
The types of the definitions of g1 and g2 are both a → a → String, and the accumulated constraints are Ord a (arising from the use of >), and Show a (arising from the use of show). The type variables appearing in this collection of constraints are called the constrained type variables.
The generalization step attributes to both g1 and g2 the type ∀ a. (Ord a, Show a) ⇒ a → a → String Notice that g2 is overloaded in the same way as g1 even though the occurrences of > and show are in the definition of g1.
If the programmer supplies explicit type signatures for more than one variable in a declaration group, the contexts of these signatures must be identical up to renaming of the type variables.
As mentioned in Section 4.1.4, the context of a type may constrain only a type variable, or the application of a type variable to one or more types. Hence, types produced by generalization must be expressed in a form in which all context constraints have be reduced to this “head normal form”. Consider, for example, the definition:
Its type is given by
and not
Even though the equality is taken at the list type, the context must be simplified, using the instance declaration for Eq on lists, before generalization. If no such instance is in scope, a static error occurs.
Here is an example that shows the need for a constraint of the form C (m t) where m is one of the type variables being generalized; that is, where the class C applies to a type expression that is not a type variable or a type constructor. Consider:
The type of return is Monad m => a -> m a; the type of (==) is Eq a => a -> a -> Bool. The type of f should be therefore (Monad m, Eq (m a)) => a -> m a -> Bool, and the context cannot be simplified further.
The instance declaration derived from a data type deriving clause (see Section 4.3.3) must, like any instance declaration, have a simple context; that is, all the constraints must be of the form C a, where a is a type variable. For example, in the type
the derived Show instance will produce a context Show (a b), which cannot be reduced and is not simple; thus a static error results.
Sometimes it is not possible to generalize over all the type variables used in the type of the definition. For example, consider the declaration
In an environment where x has type a, the type of g’s definition is a → b → ([a],b). The generalization step attributes to g the type ∀ b. a → b → ([a],b); only b can be universally quantified because a occurs in the type environment. We say that the type of g is monomorphic in the type variable a.
The effect of such monomorphism is that the first argument of all applications of g must be of a single type. For example, it would be valid for the “...” to be
(which would, incidentally, force x to have type Bool) but invalid for it to be
In general, a type ∀ u. cx ⇒ t is said to be monomorphic in the type variable a if a is free in ∀ u. cx ⇒ t.
It is worth noting that the explicit type signatures provided by Haskell are not powerful enough to express types that include monomorphic type variables. For example, we cannot write
because that would claim that g was polymorphic in both a and b (Section 4.4.1). In this program, g can only be given a type signature if its first argument is restricted to a type not involving type variables; for example
This signature would also cause x to have type Int.
Haskell places certain extra restrictions on the generalization step, beyond the standard Hindley-Milner restriction described above, which further reduces polymorphism in particular cases.
The monomorphism restriction depends on the binding syntax of a variable. Recall that a variable is bound by either a function binding or a pattern binding, and that a simple pattern binding is a pattern binding in which the pattern consists of only a single variable (Section 4.4.3).
The following two rules define the monomorphism restriction:
The usual Hindley-Milner restriction on polymorphism is that only type variables that do not occur free in the environment may be generalized. In addition, the constrained type variables of a restricted declaration group may not be generalized in the generalization step for that group. (Recall that a type variable is constrained if it must belong to some type class; see Section 4.5.2.)
Motivation Rule 1 is required for two reasons, both of which are fairly subtle.
Now consider the following expression:
It looks as if len should be computed only once, but without Rule 1 it might be computed twice, once at each of two different overloadings. If the programmer does actually wish the computation to be repeated, an explicit type signature may be added:
Recall that reads is a standard function whose type is given by the signature
Without Rule 1, n would be assigned the type ∀ a. Read a ⇒ a and s the type ∀ a. Read a ⇒ String. The latter is an invalid type, because it is inherently ambiguous. It is not possible to determine at what overloading to use s, nor can this be solved by adding a type signature for s. Hence, when non-simple pattern bindings are used (Section <IP_ADDRESS>), the types inferred are always monomorphic in their constrained type variables, irrespective of whether a type signature is provided. In this case, both n and s are monomorphic in a.
The same constraint applies to pattern-bound functions. For example, in
both f and g are monomorphic regardless of any type signatures supplied for f or g.
Rule 2 is required because there is no way to enforce monomorphic use of an exported binding, except by performing type inference on modules outside the current module. Rule 2 states that the exact types of all the variables bound in a module must be determined by that module alone, and not by any modules that import it.
When type inference on module M1 is complete, len1 has the monomorphic type Num a => a (by Rule 1). Rule 2 now states that the monomorphic type variable a is ambiguous, and must be resolved using the defaulting rules of Section 4.3.4. Hence, len1 gets type Int, and its use in len2 is type-incorrect. (If the above code is actually what is wanted, a type signature on len1 would solve the problem.)
This issue does not arise for nested bindings, because their entire scope is visible to the compiler.
Consequences The monomorphism rule has a number of consequences for the programmer. Anything defined with function syntax usually generalizes as a function is expected to. Thus in
the function f may be used at any overloading in class Num. There is no danger of recomputation here. However, the same function defined with pattern syntax:
requires a type signature if f is to be fully overloaded. Many functions are most naturally defined using simple pattern bindings; the user must be careful to affix these with type signatures to retain full overloading. The standard prelude contains many examples of this:
Rule 1 applies to both top-level and nested definitions. Consider
Here, type inference finds that len1 has the monomorphic type (Num a => a); and the type variable a is resolved to Rational when performing type inference on len2.
This section describes the rules that are used to perform kind inference, i.e. to calculate a suitable kind for each type constructor and class appearing in a given program.
The first step in the kind inference process is to arrange the set of datatype, synonym, and class definitions into dependency groups. This can be achieved in much the same way as the dependency analysis for value declarations that was described in Section 4.5. For example, the following program fragment includes the definition of a datatype constructor D, a synonym S and a class C, all of which would be included in the same dependency group:
The kinds of variables, constructors, and classes within each group are determined using standard techniques of type inference and kind-preserving unification [8]. For example, in the definitions above, the parameter a appears as an argument of the function constructor (->) in the type of bar and hence must have kind ∗. It follows that both D and S must have kind ∗→∗ and that every instance of class C must have kind ∗.
It is possible that some parts of an inferred kind may not be fully determined by the corresponding definitions; in such cases, a default of ∗ is assumed. For example, we could assume an arbitrary kind κ for the a parameter in each of the following examples:
This would give kinds (κ →∗) → κ →∗ and κ →∗ for App and Tree, respectively, for any kind κ, and would require an extension to allow polymorphic kinds. Instead, using the default binding κ = ∗, the actual kinds for these two constructors are (∗→∗) →∗→∗ and ∗→∗, respectively.
Defaults are applied to each dependency group without consideration of the ways in which particular type constructor constants or classes are used in later dependency groups or elsewhere in the program. For example, adding the following definition to those above does not influence the kind inferred for Tree (by changing it to (∗→∗) →∗, for instance), and instead generates a static error because the kind of [], ∗→∗, does not match the kind ∗ that is expected for an argument of Tree:
This is important because it ensures that each constructor and class are used consistently with the same kind whenever they are in scope.


Such expressions can be simplified using the != operator.
!=
Example:
!(i == 1)
After the quick-fix is applied:
i != 1


Franz
Franz is an Apache Kafka 0.9.0 client for iOS and macOS.
Usage
import Franz
let cluster = Cluster(brokers: [("localhost", 9092)], clientId: "FranzExample")
let consumer = cluster.getConsumer(topics: ["test"], groupId: "group")
consumer.listen { message in
print(String(data: message.value, encoding: .utf8)!)
}
cluster.sendMessage("test", message: "Hello world!")
The current release of Franz should be considered beta. It is not necessarily ready for production code.
The repo has example projects for CocoaPods and Swift Package Manager.
Installation
CocoaPods
Add the following line to your Podfile
:
pod "Franz"
Swift Package Manager
Add the following dependency to your Package.swift
:
dependencies: [
.package(url: "https://github.com/kellanburket/franz.git", from: "1.0.0"),
],
targets: [
.target(name: "MyTarget", dependencies: ["Franz"])
]
Author
Kellan Cummings
Luke Lau
License
Franz is available under the MIT license. See the LICENSE file for more info.


{% extends 'business_profile/admin-base.html' %} {% load static %} {% load breadcrumbs from component_tags %} {% block breadcrumbs %} {% breadcrumbs 'Invite collaborators' %} great.gov.uk Business profile Profile settings {% endbreadcrumbs %} {% endblock %} {% block inner_content %} Invite collaborators Invite collaborators and select the role. {% csrf_token %} {{ form }} Help with roles Members can use the business profile to apply for export opportunities, apply to sell online overseas and apply for financing. Admins can do everything members can, plus edit, publish and delete the business profile invite, remove and change permissions of colloborators. Send invite Pending collaborator invitations Collaborators you've invited who haven't accepted yet. You'll get an email when an invite accepts. People Role Actions {% if collaborator_invites %} {% for invite in collaborator_invites %} {% if invite.sso_id != request.user.id %} {{ invite.collaborator_email }} {{ invite.role|title }} {% csrf_token %} {% endif %} {% endfor %} {% else %} You have no pending invitations. {% endif %} {% endblock %}
Invite collaborators and select the role.
Members can use the business profile to apply for export opportunities, apply to sell online overseas and apply for financing.
Admins can do everything members can, plus edit, publish and delete the business profile invite, remove and change permissions of colloborators.
Collaborators you've invited who haven't accepted yet. You'll get an email when an invite accepts.


This example simply loads images in three different ways.The first image is loaded by the DOM.The second image is loaded by setting its src attribute.Finally, the third image is loaded with an XMLHttpRequest.


R Kelly’s former manager set to testify about the singers marriage to Aaliyah
The singer is reportedly set to be prosecuted for bribery
by Clodagh MeaneyR Kelly’s former manager Demetrius Smith is set to testify about the singer’s controversial marriage to Aaliyah.
According to the New York Times, R Kelly, real name Robert Kelly, is set to be prosecuted for bribery after he reportedly obtained a fake ID in 1994 for an underage girl named only in court documents as Jane Doe.
However, it is believed to be Aaliyah that is referenced as the unknown woman in the documents given the timing of the alleged offence.
The alleged incident occurred just one day before the then 27-year-old married then 15-year-old singer Aaliyah.
In an interview with TMZ, Demetrius said that he will stand by revelations he made in his 2011 book The Man Behind the Man: Looking from the Inside Out – that R.Kelly’s team obtained a fake ID for Aaliyah so that he could marry the underage teen.
“I wrote the story 10 years ago about the documents and all that stuff and it was known back then and all of its coming out now but it’s after the fact,” he explained.
The music manager also spoke about the fake ID while giving an interview for the Lifetime documentary Surviving R.Kelly which detailed the many sexual abuse allegations against the Ignition singer.
The couple’s marriage was later annulled, and Aaliyah later died in 2001 aged 22.
Conscious of the fact the Aaliyah is not here to speak for herself, Demetrius said he doesn’t want to bring her into the conversation.
“Aaliyah is not here, and I really don’t wanna bring her back up in this.”
He also said that her family knew about the incident at the time and didn’t wish to pursue the matter any further.
“Her parents didn’t want to have nothing done. I wanna help out I wanna be used as a witness to…
Demetrius also said he didn’t think R. Kelly, real name Robert Kelly, to be prosecuted.
“I don’t wanna be used as a witness to hurt Robert Kelly.”
“I think Robert should get a psych evaluation that’s what I think and from there that’s where we should help him more so than hurt him.”


The Agent service is installed on a remote server and provides the exchange of configurations between the server and a workstation of an engineer who is working on a SCADA system project.
Agent works on Windows and Linux operating systems. Agent does not have a user interface and it works as a Windows service or as a Linux daemon. The step-by-step installation manual of Agent is in the distributive package.
To interact with Agent, the Administrator application <IP_ADDRESS> or higher is needed. Administrator is installed as a part of Rapid SCADA.
Initial condition: there is a remote server with installed Rapid SCADA and Agent, as well as an engineer's workstation which is used for the manipulations described in the article.
It is recommended to store Rapid SCADA configurations (projects) on a file server that is backed up, or use a version control system such as Git. To upload a configuration to a production server, edit the configuration on a workstation and use the Administrator application for transfer.
It is possible that a configuration of Rapid SCADA is stored only on a remote server. In this case, in order to edit the configuration, you have to download it to the workstation first. Before this, open the configuration database file in SDF format using Administrator. The configuration will be imported into this SDF database for editing. Then click the menu item Remote Server > Download configuration... to open the form shown in the figure below.
In the case of subsequent editing of the configuration, you have to set the download parameters exactly as shown in the figure. After the successful download, the form for importing the configuration from the DAT format to the SDF format will open. The cause is that a working copy of the configuration on the server is stored in the specialized DAT format, while the SDF format is used for editing. After successful import, edit the Rapid SCADA configuration database and settings of the all applications on the workstation.
Before the first using of the download and upload feature, create a connection to the server as shown in the following figure. The user name and password are verified by the Agent according to the configuration database deployed on the remote server. The specified user must have the Administrator role. The System instance and Secret key fields must match the corresponding Agent settings.
After the configuration editing is completed, upload it back to the remote server. To do this, choose the menu item Remote Server > Upload configuration... The following form appears:
First, tick the root node of the tree to select all the configuration files for uploading, and then expand each node in the tree to check the selected files and exclude redundant files if they are present. After successful uploading the configuration, the Agent restarts the Server and Communicator services on the remote server to apply the changes. Test the server is up after the configuration is uploaded.
This scenario is possible if there are test and production servers or main and standby servers. Consider the transfer of the configuration from the server 1 to the server 2.
Open the downloading dialog and set the download options as shown in the figure. The difference is that the configuration is saved into the archive, the server-specific files are not downloaded, and the configuration database import is not executed. After the download is complete, it is a good idea to open the saved archive file and check the configuration files it contains.
Then, open the upload dialog and create a connection to the server 2. Select the previously saved configuration archive file as the source and untick the checkbox of clearing server-specific files. After uploading the configuration, verify that the server 2 works well.
Check the server status with help of the form which is called from the menu Remote Server > Server Status... Select the connection to the server and click the Connect button. In case of the error status of the Server or Communicator service, connect to the file system of the remote server and analyze the Rapid SCADA application logs. In addition, this form allows to remotely restart the the Server and Communicator services.


David Dobrik Officially Signs Divorce Papers After Marrying Jason Nash's Mom
David Dobrik is a single man once again!
The 23-year-old YouTuber married his friend Jason Nash‘s mom Lorraine back in May after Jason said no one would ever marry David.
David and Lorraine split the following month and now David has officially signed the divorce paperwork.
“After a long few months, I officially signed the divorce papers to my wife, Lorraine. Jason your mother was a real treat. With that being said I also reactivated my @bumble account and I’m ready to start swiping. See you soon ladies,” David wrote on his Instagram.


To let Heinzelmannchen access Github issues on your behalf, you need to generate a personal access token and put it in the input field below.
auth token
Github Personal Access Token
Done
search_circle
Search for an Issue
Reset


SURVEY FORM
Microverse Collab
Name:
Email:
Number:
Select your gender:
Female
Male
Geek
Choose something:
123
456
"hello"
"world"
2.46
3.14
Select a color:
Green
Red
Blue
Comments Here:
Submit


THE ART OF WAR
Review by John Beachem
* *
Directed by: Christian Duguay Written by: Wayne Beach, Simon Barry
Agent Neil Shaw (Wesley Snipes) is a covert ops agent for the UN (I didn't even know the UN had a covert ops unit). He and his teammate, Bly (Michael Biehn), are employed by the Secretary General, Douglas Thomas (Donald Sutherland), and his right-hand man (his words, not mine), Eleanor Hooks (Anne Archer).  Soon Shaw is on his own, after his teammates are killed, and he's running from both the Chinese and the Americans, since they believe he killed the diplomat. Thrown into the mix is a Chinese version of Donald Trump (movie's words, not mine), David Chan (Cary-Hiroyuki Tagawa), who may know more about the assassination than he's letting on. The only person on his side is a Chinese reporter, Julia Fang (the very cute Marie Matiko), who knows he wasn't the assassin. Against him is FBI agent Frank Capella (Maury Chaykin), who is investigating a different crime which seems to link to the slain diplomat. Now Shaw and Julia have only 24 hours to clear his name, before...
... where was I? Sorry, I sort of drifted off for a minute there. "The Art of War" is something of an anomaly amongst action movies. It's an action movie which is intent on featuring as little action as possible. That's why, despite the fact that I'd had plenty of sleep, I was drifting off every twenty minutes or so. So what does Duguay ("Screamers") insert instead of action? Some of the worst dialogue you're likely to hear. "The Art of War" is an action movie with no action; a political thriller with no thrills; and a mystery you'll have figured out in the first twenty five minutes. Alright, alright, I know there's only one real question on your mind, and it's that you want to know if it's entertaining. I'm afraid not. In fact, you'll probably be indulging in one of three different activities rather than watching the movie. You might be snoring (quite a few people in the audience at my showing were doing that), you might me checking your watch (I wish I could have been doing that, but my pocket-watch has no indiglo), or you might be chatting with your neighbor (the rest of the audience was doing that). In case you're wondering, I was busy doodling on my notebook. Why am I sitting here, rambling about everyone's activities during the movie? Because writing a review for a truly dull movie is almost as bad as watching one.
Ah the acting, the acting is certainly one of the more dismal points to "The Art of War". Wesley Snipes has two acting modes: Slyly humorous and friendly (like in "Major League"), and gruffly stoic (like in "Blade"). Snipes is in full stoic mode in "The Art of War", which is a shame because he might have brought some humor to the script otherwise. Instead, the humor all comes from Maury Chaykin ("Cutthroat Island"). However, while Chaykin's brand of humor (which generally involves him quietly making strange comments) is rather amusing, it's completely out of place in this movie. Donald Sutherland does nothing more than chew scenery in a few scenes. Marie Matiko ("Mystery Men"), who is a relative newcomer, plays Snipes's love interest (I think) in one of the most tacked on romances I've ever seen. That's not to say she does a poor job; it's just that her role was so useless she couldn't do much with it. Finally, we have Michael Biehn ("Aliens") and Anne Archer ("Rules of Engagement"). I've always found Biehn to be one of the most underrated actors in Hollywood, turning in stellar performances in "The Abyss", "Terminator", and "Aliens". In "Rules of Engagement", Biehn seems to be going out of his way to prove me wrong.  I could beat this guy up. Anne Archer, who I've never thought of as a particularly talented actress, just gives me more ammunition for my arguments against her.
Perhaps in the hands of a more skilled director, "The Art of War" could have been at least vaguely interesting. Afterall, Duguay's idea of neat directorial tricks are as follows: put little trails behind the bullets (pretty original, huh?); show us everything we've already seen in flashbacks as though we're too stupid to remember (I think the movie was actually an hour long, played twice); blast the soundtrack and sound effects at all times till the audiences' ears start bleeding; and throw in completely gratuitous nude scenes so as to appeal to young males who snuck in (most young males in my audience didn't catch the gratuitous nudity, they were too busy sleeping). Then again, with a script like this, maybe the director didn't make much of a difference. For all those (like me) who thought "The Perfect Storm" had horrendous dialogue, wait till you get to sit through this one. My personal favorite was Anne Archer saying: "My instinct tells me there is something lurking beneath the surface."
So after all this complaining, are there any good points to "The Art of War"? Well, the first fifteen minutes have their moments. Snipes is sneaking into a skyscraper so he can blackmail a general into resuming peace talks (or something like that). The soundtrack during those few scenes is really quite good, and there are one or two decent action scenes (Snipes falling slowly towards earth using a damaged parachute). Also, Snipes may not be the world's best actor, but he does have some impressive moves. The film's ending goes on far past what was necessary, dragging on for about four scenes too many.  In one scene, Maury Chaykin gets shot in the chest by an assassin after already being in a car accident. The assassin shoots him to ensure he's dead, obviously. After the assassin leaves, Chaykin stands up, curses a little, and proceeds to show us how he's miraculously still alive; a bulletproof vest! What wondrous invention is this? Apparently something fairly new since the assassin didn't even think to shoot Chaykin in the head. "The Art of War" runs an ungodly 117 minutes. I'd recommend it to no one and give it two out of five stars.
Comments? Send to<EMAIL_ADDRESS>Past reviews can be found at: http://www.epinions.com/user-elerad?public=yes or http://us.imdb.com/ReviewsBy?John+Beachem
* * * * * - One of the best movies of the year. * * * * - Great flick, try and catch this one. * * * - Okay movie, hits and misses. * * - Pretty bad, see it at your own risk. * - See this one only if you enjoy pain.
Share information about yourself, create your own public profile at http://profiles.msn.com.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Welcome to our club poker!
Would you like to join?
Play
Your turn! what you want to do?
Fold
Call
Raise
You want raise to
?
Wait. Other players make decision.
Next
Player 1
$2000
Player 2
$2000
Player 3
$2000
You
$2000


The president must have the final say
by David Gurfein, Opinion contributorThe U.S. military is the most powerful and effective fighting force the world has ever seen. It is, in part, because of the good order and discipline maintained throughout the ranks.
For nearly 250 years, Americans who serve our country have defended our Constitution and our rights. They have never faltered.
However, recently, a few of our warriors have come under attack. Not from a foreign invader or terrorist, but from people within their own command.
When President Donald Trump pardoned two servicemen and restored the rank of a third — righting the wrongs of unlawful command influence, prosecutorial misconduct and investigator abuse — reports of dissent from a few senior officers and civilians at the Pentagon flooded the airwaves.
As officers in the U.S. military, we are trained that we do not have a responsibility to dissent, we have an obligation to dissent. Acting courageously to challenge senior leadership on their ideas and plans is healthy and helps to ensure the best possible outcome, whether in combat or in garrison. However, that dissent must end once a decision is made.
OUR VIEW: Do Navy leaders have a 'duty to disobey' Trump in Gallagher case?
Continuing to debate, complain or act in defiance undermines good order and discipline far worse than any single decision, especially a decision made by the president to rectify the disgraceful actions demonstrated by the Army and the Navy JAG Corps and their criminal investigators.
America’s Founders structured our military so that it would protect the peoples’ rights by having each member swear to defend our Constitution and answer to a civilian leader who would be elected by the people. As such, when there are disagreements between our military leaders and our civilian leaders, the president, as commander in chief, must have the final say.
Our military leaders may not like the president’s orders. However, they must obey them. Moreover, they must obey them enthusiastically as if they were their own. Anything short of that is considered, at best, insubordination and, at worst, treason.
David Gurfein, a retired lieutenant colonel in the Marine Corps Reserve, is CEO of United American Patriots.
If you can't see the poll below, please refresh your page.
What do you think of this opposing view?
This article originally appeared on USA TODAY: President must have final say: Opposing view


Salmon cookies made with fish, salmon cookies are delish!
HOME
SALES
STYLE GUIDE
Create your own store
Store Name
How much traffic does this store experience
Minimum Customers
Maximum Customers
On average, how many customers purchase something every hour
Average Customers Per Hour
Submit


Create models for a specific mclust model
create_profiles_mplus(df, ..., n_profiles, the_title = "test", data_filename = "d.dat", script_filename = "i.inp", output_filename = "i.out", savedata_filename = "d-mod.dat", model = 1, starts = c(20, 4), m_iterations = 500, st_iterations = 10, convergence_criterion = 1e-06, remove_tmp_files = TRUE, print_input_file = FALSE, return_save_data = TRUE, optseed = NULL, n_processors = 1)
| df | data.frame with two or more columns with continuous variables |
|---|---|
| ... | unquoted variable names separated by commas |
| n_profiles | the number of profiles (or mixture components) to be estimated |
| the_title | title of the model; defaults to test |
| data_filename | name of data file to prepare; defaults to d.dat |
| script_filename | name of script to prepare; defaults to i.inp |
| output_filename | name of the output; defaults to o.out |
| savedata_filename | name of the output for the save data (with the original data conditional probabilities); defaults to o-mod.out |
| model | the mclust model to explore: 1 (varying means, equal variances, and residual covariances fixed to 0); 2 (varying means, equal variances and covariances; 3 (varying means and variances, covariances fixed to 0), 4 (varying means and covariances, equal variances; can only be specified in Mplus); 5 (varying means, equal variances, varying covariances); and 6 (varying means, variances, and covariances), in order least to most freely-estimated; see the introductory vignette for more information |
| starts | number of initial stage starts and number of final stage optimizations; defaults to c(20, 4); can be set to be more conservative to c(500, 50) |
| m_iterations | number of iterations for the EM algorithm; defaults to 500 |
| st_iterations | the number of initial stage iterations; defaults to 10; can be set more to be more conservative to 50 |
| convergence_criterion | convergence criterion for the Quasi-Newton algorithm for continuous outcomes; defaults to 1E-6 (.000001); can be set more conservatively to 1E-7 (.0000001) |
| remove_tmp_files | whether to remove data, script, and output files; defaults to TRUE |
| print_input_file | whether to print the input file to the console |
| return_save_data | whether to return the save data (with the original data and the posterior probabiltiies for the classes and the class assignment) as a data.frame along with the MPlus output; defaults to TRUE |
| optseed | random seed for analysis |
| n_processors | = 1 |
either a tibble or a ggplot2 plot of the BIC values for the explored models
Creates an mplus model (.inp) and associated data file (.dat)
not_run({ m1 <- create_profiles_mplus(iris, Sepal.Length, Sepal.Width, Petal.Length, Petal.Width, n_profiles = 2, model = 1) }) # models described here: # https://jrosen48.github.io/tidyLPA/articles/Introduction_to_tidyLPA.html


Scan contact card
Certified Data Scientist with experience of 3 + years in Data Science.  If there are things out that are not yet tried, I want to be the first to do it. I learn though experience and not through books. Major strengths include strong leadership and capacity to work as a team player, as well as good communication skills. Self-motivated Analyst who has good organisational skills, is highly efficient and has a good eye for detail. A quick learner who can absorb new ideas and can communicate clearly and effectively.
Finance domain
Data Science Delivered
Machine Learning models using Python and R.
Research and Development
GPA: 2.75/4
69% [B.E.]
Apart from being a Data Scientist, I enjoy most of my time being outdoors. I like to explore new places.
When forced indoors, I follow a number of sci-fi and fantasy genre movies, I am an aspiring chef, and I spend a large amount of my free time exploring the latest technolgy advancements in Data Science, AI and Big data world.


Select Yes or No*.
{{#errors}}{{.}}
{{/errors}} {{#> help-reveal title="Help - What if only some Capabilities are available on a mobile device?"}}If any parts of your Solution can be used on a mobile device, you will have to comply with the Mobile Working Standard. During the Standards Compliance stage, you will be asked to provide evidence applicable to the extent your Solution is available for mobile working. See Mobile Working Standard.
{{/help-reveal}}


The Hunger Games
Constant suspense... I couldn't stop reading.
Stephen King
I was so obsessed with this book... The Hunger Games is amazing.
Stephenie Mayer
One of the best written and most thought-provoking books I've read for a long time.
Anthony Horowitz
The Hunger Games
£25.00
| ISBN: |<PHONE_NUMBER>084 |
| Publisher: | Scholastic |
| Pub date: | 05 Jan 2009 |
| Number of pages: | 448 |
Catching Fire
£25.00
| ISBN: |<PHONE_NUMBER>367 |
| Publisher: | Scholastic |
| Pub date: | 07 Sep 2009 |
| Number of pages: | 448 |
Mockingjay
£25.00
| ISBN: |<PHONE_NUMBER>374 |
| Publisher: | Scholastic |
| Pub date: | 25 Aug 2010 |
| Number of pages: | 448 |


Judges 19:4
And his father in law, the damsel's father, retained him; and he abode with him three days: so they did eat and drink, and lodged there.


Travel to Mars: Red Planet 159kk $
Travel to Venus: Solar Sauna 399kk $
Travel to Pluto: Winter is coming! 919kk $
Travel to Saturn: Enjoy stone rings! 669kk $
Travel to Jupiter: Gas giant 429kk $
Travel to Uranus: Ice core 829kk $


Maps are usually associated with geography of course, but we also like them when they have a role in helping us understand how concepts, organisations, places, and people can work together.


Smart quizzes with live results.
Give a feedback to your lecturer
Awesome Lecture
I don't Understand
Sleepy Lecture
Bit Confused


Landing Page
Special Projects
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.
Ashton Nichols
4/17/2019
For some people, family traditions include eating Sunday brunch or going to a state fair. For others, it will include walking through the woods in search for mushrooms.
Mike Hopkins has been hunting morel mushrooms for over 31 years. His father and grandfather hunted and took him along when he was 6 years old. He said he hunts as much as he can outside of work.
“(I carry it on) just because of all the wonderful memories I had as a child,” Hopkins, who lives in Springfield, said. “I enjoyed it myself as I grew older, and I love eating the mushrooms. Never going to quit until I can’t hunt them anymore.”
Allen Roe views mushroom hunting as a spiritual time for him.
“It’s getting in the woods and going off quietly,” Roe said. “Some people go to church to be close with God. I go to the woods. That’s where I feel closer to everything around me. In general, morel hunting is calming. It’s peaceful.”
He lives near Dresden and has been hunting mushrooms for over 35 years, beginning when he was 5 years old.
“They’re very hard to grow; therefore, wild is the main way they are found,” Roe said. “For it’s more about spending time in the woods. It’s about getting away from the crazy, hectic, everyday life. And there’s the benefit that they are delicious.”
For Troy Eden, the smell of spring brings back memories. He spent 27 years in the military and said it was nice to come back to the Athens area in the springtime.
“Wherever I was at, I’d at least try to get back this time of year for mushroom hunting because it reminds me of home,” Eden said.
Today, he lives near Beavercreek. He’s been hunting mushrooms for 42 years after his family got him into it.
“It has to be thousands of hours that I’ve spent in the woods since I was a little boy hunting mushrooms,” Eden said. “It has helped create a passion of wildlife conservation and preservation of our national and state parks. It’s great family time.”
Don King was not born into a family of mushroom hunters. He discovered it 15 years ago when he saw someone on a PBS cooking show go into the woods and gather mushrooms to cook them.
Several years later, King bought an identification book for mushrooms. He found morels that were growing by his house and soon cut them.
 “This was before it was easy to get identifications on Facebook. It was actually before Facebook even existed, and there were few online resources for mushroom identification.”
Once he worked up the courage to eat them, he said they tasted amazing, and it made him feel much more confident to look for more.
King has been able to turn his passion for mushrooms into a business. He is known as The Mushroom Hunter and has a Facebook page with more than 10,000 followers. He also takes people on hunts and does weekend hunting and camping trips.
He said he takes people to hunt for two to three hours and then will take people camping for an entire week, about four to six times per year. When he’s not teaching, he is hunting on his own, which is about five to 10 hours a week.
“There’s such an interest out there, and people are afraid to do it on their own,” King said. “For the first couple of years, it was not very successful. I had maybe half a dozen people interested at the most. And at some point, it just sort of blew up.”
Mushroom hunters often have fierce competition with each other and keep their mushroom locations extremely secret. It’s common that people will pass on the locations from family member to family member, Roe said.
“If you tell one person, they’ll tell 10 people, and then they’ll tell 10 people and before long, you go to your spot and you can’t walk through the woods without running into 10 people,” Roe said.
It often depends on the day for how many mushrooms Roe will find. Sometimes he has found two, other times 200. It is all about where he looks.
The trick to mushroom hunting, Eden said, is that someone must “look up to find them down.”
Eden will search for certain trees.
“The elm trees, old apple trees, orchards, grape vines is where I would always find mushrooms,” Eden said. “But specifically, during the life cycle of the old elm trees, they start to die, and mushrooms would blossom about them. I would always look up to identify the trees before I would start looking for mushrooms.”
Morels grow in two different ways: saprobic and microrisal, King said. Saprobic mushrooms decompose dead matter, which is why morels can be found by dead trees. Microrisal mushrooms grow in a symbiotic relationship with living trees.
Provided by Don King
A morel mushroom grows in the ground. Morel mushrooms grow in two different ways: saprobic and microrisal. Saprobic mushrooms decompose dead matter, while microrisal mushrooms grow in a symbiotic relationship with living trees.
Roe said he looks at elms that are dead but still standing. When searching, he looks for the stem because they are white and will stand out more so than the brain of the morel.
“If you can find a dead elm where the bark is slipping, you have a higher chance of finding them than in just walking through the woods,” Roe said.
Tyson Bolin hunts for morels because he likes the taste. He’s from Meigs County and will hunt about three to four times per week.
He said he once found 87 morels underneath one tree, each the size of a soda can.
“Everyone has their secret spots,” Bolin said, chuckling. “What I’ve found out is that the spots die out, and they’re not consistent. They might be good one year, but then the following year they won’t be as good. You’ll have to find another spot.”
Soil temperatures are also said to be a factor for when mushrooms come out. Hopkins said that ideal temperature is around 55 degrees Fahrenheit. He said he has had his best hunting in central Ohio.
Eden said that morels typically start their season in Georgia and move north. He has a trip scheduled this season to both Tennessee and Illinois to hunt.
“I have tasted variations, and I think Southeastern Ohio mushrooms taste different than western Ohio,” Eden said. “Depending on the soil composition, you get different flavors.”
Many mushroom hunters also hunt other species.
Hopkins said he also hunted oyster mushrooms. They grow on trees from late summer through the fall, and he will fry them. They can be tan to white-colored and have a fishy smell.
Eden said he not only searches for different variations of morels but also for horsetails and chicken of the woods.
“My wife and I have taken several outdoor courses, so when we go through the woods, we’ll pick all different kinds of things,” Eden said. “Nettles, like the stinging kind of nettles, we will boil them and make quesadillas out of them.”
King said he stresses to people who hunt that morels are not the only mushroom that can be found in the woods.
“When I seriously think about morels and their overall flavor and the culinary aspects, they’re not even in my top 10 favorite mushrooms,” King said. “I’ve tried over 80 different species of mushrooms here in Ohio. The more really great mushrooms I try, the lower on the list morels go.”
He said his top three favorite mushrooms are parasol mushrooms, chanterelles and black trumpets.
Once morel season ends in May, King said he looks forward to continue hunting other species.
“I’m not sad when morel mushroom season ends. I’m actually excited because I know that in summer and fall, there will be many, many more species in different varieties,” King said. “I don’t get depressed about mushrooms until the end of November.”
When he’s not hunting mushrooms, he’s involved in a lot of different Facebook pages dedicated to mushroom hunters and will do his best to debunk myths.
He said that it is common for people to believe that the mushroom should be cut from the ground, but really, it is OK to remove it.
“Mushrooms hunting, if done properly, is 100 percent sustainable,” King said. “Plucking mushrooms out of the ground does not harm the actual organism and does not affect future production of those mushrooms.”
The morel has a look-alike, called the verpa bohemica, or false morel. It looks the exact same as a morel, but it is toxic.
Hopkins said the gyromitra mushroom is another type of false morel and looks like a big, red brain.
He recommends that beginners take someone with them who can identify the different kinds.
“The big thing is that if you cut a morel down the middle, good morels will be hollow inside,” Hopkins said. “If there’s anything in the stem or cap, then there’s a false morel, and I wouldn’t eat it because it could be toxic.”
Eden said he and his wife make spore tests by putting the mushroom on a white piece of paper and counting the spores after a few hours. The spore count determines the toxicity of the mushroom.
Once Roe brings the mushrooms home, he cuts them up and soaks them in salt water.
“Anything you bring home from the wild is going to have wild on it: bugs, dirt, etc. I soak them 24 hours in salt water,” Roe said. “The salt water kills bugs.”
Provided by Don King
A box of morel mushrooms sits on the ground. Morel mushrooms typically start their season in Georgia and move north.
During mushroom season, his refrigerator is often filled with bowls of salt water and mushrooms.
“My wife will complain because she will go grocery shopping and not have room for the groceries,” Roe said.
Bolin said morels have an earthy flavor.
“You can cook them about any way you want,” Bolin said. “We like to fry them, put them on pizza, put them in lasagna or spaghetti. It’s like a regular mushroom.”
The different colors do not taste differently, Bolin said, but different sizes have different flavors.
King said that he will eat the vast majority of the mushrooms he finds himself, or he will dehydrate them to use later. He will also take extras to farmers markets and barter with them.
“Since selling wild mushrooms is technically not legal on a commercial scale in Ohio, I basically take small bags of them to my farmers market, and I’ll barter with other vendors there,” King said. “I’ll barter to get meat or veggies or eggs or things like that. But mostly I cook them for myself and friends and family.”
Roe said he absolutely will not sell his mushrooms. If he has surplus of more than he will eat, he will freeze them. He also will take some to his grandmother.
“My favorite thing to do is to wait until there’s three inches, four inches of snow on the ground and send my friends a picture of my fried mushrooms on my plate,” Roe said. “They’re always so jealous when I have mushrooms in the winter.”
Some people also have traditions when looking for morels.
Eden said he has a mushroom hunting stick that is carved like a cane. He always takes it with him into the woods.
“I’ve had this cane with me for 20 years,” Eden said. “I think it’s put as many miles in the woods as I have these last 20-something years. I guess it’s lacing up a comfortable pair of shoes and getting comfortable with it.”
Roe said most people will hunt with a photo of a mushroom.
“Every mushroom hunter has a picture of a mushroom that they have found,” Roe said. “They have it on their phone, and when they’re in the woods, they’ll look at that picture to refresh that image in their mind, and then they’ll go looking for it.”
Bolin said he puts his mushrooms in a mesh bag, or an onion sack. It is to help the spores fall off and replant new mushrooms while he is walking through the woods.
Hopkins said his dad looks at the moon, but he himself doesn’t because he considers himself not superstitious.
“My favorite thing to do in my life is to go mushroom hunting,” Hopkins said. “It’s because I love being out in nature. It’s the time to be with yourself and also you get to enjoy the fruits of your labor with my most favorite delicacy. As far as food goes, it’s the morel mushroom.”
Landing Page
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.


Bookworms at Tidcombe win Summer Reading Challenge for third year in a row
The popular event takes place every year over the six week summer holiday
by Lewis ClarkePupils at Tidcombe Primary have proven to be the best bookworms in Tiverton once again.
The school has won the Summer Reading Challenge for the third consecutive year.
Head of English and assistant headteacher, Jill Mallender said: “Summer may seem like a distant memory, but for children and staff we are still celebrating.
“The popular event takes place every year over the six week summer holiday, and it is organised by Tiverton Library.
“Tidcombe School is one of the smaller Primary schools in Tiverton with just 194 children currently on roll, but, size obviously does not matter for these little bookworms.
“We are all so proud of our children, and as a school, we are very passionate about encouraging our children to read. We have super supportive parents who share our drive to promote reading every evening and would like to say a special thank you to them, for helping the children to achieve this award for the third year running.”


Ontario mother says her son’s light-up shoes may have caused fire
by Pat Foran, Consumer Reporter, CTV NewsTORONTO - A family from Everton, Ont., northeast of Guelph, fears that a popular brand of children’s shoes, that light up as you walk in them, may have caused a fire in their house.
Abby Spielmacher said a fire in her home this past Sunday morning could have been tragic as she was hosting a children’s birthday party for her daughter at the time.
“One of the girls screamed out ‘fire, fire.’ I went to the mudroom where the shoes and backpacks were and saw three-foot flames," Spielmacher said.
She and her husband tried to smother the flames and threw the burning items outside. A pair of battery-powered light up shoes was in a backpack hanging on the wall and the family believes that one of the battery-operated light-up shoes caused the fire.
“It didn't come from the wall or the floor. When we looked through all the burnt items the only thing we could think of was the shoe," Spielmacher said.
Her five-year-old son Bryson said the S-Sport shoes from Skechers were one of his favourite pairs.
“When you step on them, they light up,” he said.
While the family believes the shoes are the likely source of the fire, they said they can't be sure without an investigation.
In May of 2016, a family in Texas said they believed light-up shoes caused a fire in their SUV.
Class action lawsuits have been filed in the U.S. alleging battery-operated shoes are responsible for fires and burns to children's feet. The lawsuits allege when the shoes get wet, the batteries can short circuit and cause a fire.
“We have absolutely no evidence or reason to believe that this style caused a fire, which is pure speculation at this time. Nonetheless, we will contact the owner of the shoes so that they can be returned and examined,” a Skechers spokesperson told CTV News Toronto.
The family wants to have the shoes investigated to make sure this doesn't happen to anyone else.
“Thank goodness it didn't happen during the night. We were fortunate to find the fire within minutes," Spielmacher said.


Upload on form submit
Name:
Email:
Company Perferance 1 :
{{company}}
*required
Photo:
*required
File too large {{errorFile.size / 1000000|number:1}}MB: max 2M
Remove
Submit
Upload Successful
{{errorMsg}}
Name
Eamil
Number
Action
{{contact.name}}
{{contact.email}}
{{contact.number}}
View
Download


Past Salutes
7‐2‐2016 Evelyn Lock‐ She will be 95!
6‐18‐2016 Alma Frost Ethridge Gunn
She’s 99!
6‐11‐2016 Don McDuff
5-28-2016 Joy Ayers— reflecting on Veterans.
ALSO 5-28-2016: Larry Hardin— Larry is a Vietnam Vet!
4-30-2016 Myrna Villers — Happy Birthday, Myrna!
4-16-16 Wilma Snowbarger, Baptist Village
4-2-16 Jean Pereya
93 years young!
Janice Barton - happy birthday!
3-5-16 Glayce Williams —94
Nominated by Baptist Village
2-27-16 Jimmie & Catherine Brownell
1-23-16 Stan & Lisbeth Alexander who are celebrating their 60th Anniversary TODAY! January 21, 2016!
1-13-16 Betty Collier, a lady with a heart for Volunteering!
1-9-16 Thomas Burton
97 years young!
9-18-15 Terry and Eunice Aldrich
12-27-14 This week's Salute is a very special one - watch this video to see how Robin Gunn & Family surprised her mother, Bobbie Diffee Gunn with a gravestone 57 years later for her twins who died after 10 minutes of life.
12-13-2014 Barbie Hall and Joanne Williams
11-8-14 Don Wright
11-2-14 Richard Johnson and wife Ruth Ann
12/05/15 Elmer Norton - Employee of the quarter at NewView Oklahoma
11/28/15 Nancy Tarpley... at 82, she never misses a Senior fitness class!
9-2-15 Shirley Smith nominated by Dennis Helm
8-22-15 Morgan Green nominated by David Orwig
8-8-15 Gracie Donohoe Baptist Village Communities
7-11-15 Bonnie Bley - 91 years old!!
5-30-15 Lawanda Allison 5-23-15 Annie Ezell
3-14-15 Gilbert & Barbara Forest
Bob and Betty Schreimer 7-26-14
8-16-14 Anita Roesler, retiring after 29 Years with the Metro Library
09-20-14: 65th Anniversary sweethearts, Richard & Nancy Parker
10-17-2014 John Sullivan WWII Vet
09-27-14 Daughter Loli, Manola, Amy & Lucy- Manola Hembekides
AC_AX_RunContent('height', '42', 'width', '288 ',' src ',' new_site / WellPreservedSalute ',' autostart ',' False ',' loop ',' False ',' controller ',' true ',' bgcolor ','# FFFFFF ',' autoplay ',' false ' ); //end AC code Martha Verge 5-10-14
|
Share the wealth with the Marjorie Mosel Fund - Make checks payable to the OSU Foundation, Marjorie Mosel Fund, #20-83590. Mail to OSU Foundation, 400 S. Monroe, Stillwater, OK 74076. Read about her endowment scholarship here (pdf).
|
Eugene Brown 4-26-14
04-12-14 Fern Corley
04-05-14 Myrtle Faulkner
03-29-14 Iris Phelps
03-22-14 Betsy Braver
03-15-14 Millie Wright
03-08-14 Ruby Frye
02-22-14 Bobbie Gray Diffee Gunn
03-01-14 John & Norma Dowdy
02-08-14 Peggy Walker
02 15-14 Nina Davis
02-01-14 Sue Longwith
01-25-14 John & Genny Brewer
01-11-14 Juanita Moore


Customer Details
First Name
Last Name
Gender
Male
Female
Email
Phone
Town
Varna
Sofia
Burgas
Plovdiv
Shumen
Ruse
Age
Language
Message
I agree the Terms and Conditions


Coin Type (1: testnet3):
Name:
Working Directory:
Oracle URL:
Underlying:
Settlement Date:
Default Counterparty:


Wikiversity Files for Download
Last Update: 17.07.2023
This file contains all additional files for learning resources in Wikiversity https://de.wikiversity.org.
All wikiversity files can be downloaded from GitHub as ZIP file. Subfolder /de or /en denote the language of the learning resource.
The name of the folder refers to the learning resources in Wikiversity e.g. Diffusion to https://de.wikiversity.org/wiki/Diffusion for a german learning resource in Wikiversity with the name Diffusion.
Click on the folder displays the learning resources in Wikiversity for which the content was created (english/german).
Wikiversity Support Files on GitHub (17.07.2023)


{% load i18n %}
{% blocktrans trimmed %} Administrators are organized in permission groups. There is three types of permission groups: {% endblocktrans %}
{% blocktrans trimmed %} Department administrator permission groups is the highest level of permission except for superusers (which have access to everything). These permission groups is added to multiple courses, typically all courses within a department. {% endblocktrans %}
{% blocktrans trimmed %} Users within a department administrator permission group have access to everything, including some data and operations that is unavailable to course administrators. The extra permissions include access to grades on fully anonymous assignments, and the ability to delete students with deliveries or feedback from an assignment. {% endblocktrans %}
{% blocktrans trimmed %} Course administrator permission groups work just like department permission groups, except that they have a bit fewer permissions (detailed in the "department administrator" section above). Course administrator permission groups are typically only added to one course, or perhaps a couple of courses if the courses share the same course administrators. {% endblocktrans %}
{% blocktrans trimmed %} Each course has exactly one special permission group where department and course administrators can add extra administrators. {% endblocktrans %} {% if in_subject_adminoverview %} {% blocktrans trimmed %} You add admins to this special permission group using the "Add course administrators" button above. {% endblocktrans %} {% endif %}
{% blocktrans trimmed %} Semester administrator permission groups is the lowest level of permission for administrators. Semester administrator permission groups are typically only added to one semester, or perhaps a couple of semesters if the they share the same administrators. {% endblocktrans %}
{% blocktrans trimmed %} Users in a semester administrator permission group do not have access to anonymous assignments. The primary use case for semester administrators is for teaching assistents and other administrators that should only have access to normal non-anonymous assignments. {% endblocktrans %}
{% blocktrans trimmed %} Each semester has exactly one special permission group where department, course and semester administrators can add extra administrators. {% endblocktrans %} {% if in_period_adminoverview %} {% blocktrans trimmed %} You add users to this special permission group using the "Add semester administrators" button above. {% endblocktrans %} {% endif %}
{% blocktrans trimmed %} A user is always given the highest level of permission available. This means that if a user is both in a department administrator permission group and a course administrator permission group for a course, they will have department administrator permissions for that course. {% endblocktrans %}


Playing around with template composition
always
same
data-variable="a"
data-variable="b"
increment global
increment local
display list size of global, with value local
data-list="innerlist-d-inner"


Functions¶
- functions.Lmag_limit(D_o)¶
Calculates the magnitude of the faintest star which can be seen from the telescope
- functions.Max_eyepiece(f_R, D_eye=7, age=None)¶
Calulates the maximum focal length of eyepiece you can use on the telescope :param D_eye: Diameter of Eyepiece (mm); default is 7 mm :type D_eye: float :param f_R: Focal Ratio/f-number of telescope :type f_R: float
- Returns
The maximum focal length of eyepiece (:math: f_{e-max}) you can use with your telescope
- Return type
- functions.Max_magnification(D_o)¶
Calulates the maximum usable magnification of the telescope :param D_o: Diameter of Objective/Aperture (mm) :type D_o: float
- Returns
Maximum Usable Magnification (:math: M_max) of the telescope
- Return type
Note
The maximum usable magnification also depends upon seeing.
- functions.Min_eyepiece(f_o, M_max)¶
Calulates the minimum focal length of eyepiece you can use on the telescope :param f_o: Focal length of Objective/Aperture (mm) :type f_o: float :param M_max: Maximum usable magnification :type M_max: float
- Returns
The minimum focal length of eyepiece (:math: f_{e-min}) you can use with your telescope
- Return type
- functions.Min_magnification(D_o, D_eye=7, age=None)¶
Calulates the minimum usable magnification of the telescope :param D_o: Diameter of Objective/Aperture (mm) :type D_o: float :param D_eye: Diameter of Eyepiece (mm); default is 7 mm :type D_eye: float
- Returns
Minimum Usable Magnification (:math: M_min) of the telescope
- Return type
- functions.dawes_lim(D_o)¶
Calulates the Reosultion of the telescope according to the Dawes Limit
- Parameters
D_o (float) – Diameter of Objective/Aperture (mm)
- Returns
Resolving power of the telescope arroding to Dawes Limit (arc-sec)
- Return type
Note
This function is generally useful when you are doing filter-less observations. For operation with filters, check Resolution Power function.
- functions.exit_pupil(f_e, f_R)¶
Calulates the Exit Pupil of the telescope & eyepiece pair :param f_e: Focal Length of eyepiece (mm) :type f_e: float :param f_R: Focal Ratio of telescope :type f_R: float
- Returns
Diameter of Exit Pupil(:math: D_EP) (mm)
- Return type
Note
For optimal usage, :math: D_EP pprox 2-3 mm is the optimum range for maximizing the resolving power of the eye
- functions.focal_ratio(f_o, D_o)¶
Calculates the Focal Ratio for the telescope :param f_o: Focal Length of Objective/Aperture (mm) :type f_o: float :param D_o: Diameter of Objective/Aperture (mm) :type D_o: float
- Returns
Focal Ratio/f-number (:math: f_R) of the telescope
- Return type
- functions.magnification(f_o, f_e)¶
Calculates the Angular Magnification for the telescope :param f_o: Focal Length of Objective/Aperture (mm) :type f_o: float :param f_e: Focal Length of Eyepiece (mm) :type f_e: float
- Returns
Visual Magnification (M) of the telescope
- Return type
- functions.resolving_power(W, D_o)¶
Calulates the Reosultion of the telescope
- Parameters
- Returns
Resolving power of the telescope (:math: P_R) (arc-sec)
- Return type
Note
This function is generally useful when you are using filters. For filter-less observations, check Dawes Limit function.