RebindableSyntax implies NoImplicitPrelude.
6.8.1
Implicitly import the Prelude module by default.
The implicit import can be refined in a module by explicitly writing an import of the form:
This will only import foo from Prelude rather than the whole module as the implicit import.
GHC normally imports the Prelude module for you. If youâd rather it didnât, then give it a -XNoImplicitPrelude option. The idea is that you can then import a Prelude of your own.
7.0.1
Enable rebinding of a variety of usually-built-in operations.
Suppose you are importing a Prelude of your own in order to define your own numeric class hierarchy. It completely defeats that purpose if the literal â1â means âPrelude.fromInteger 1â, which is what the Haskell Report specifies. So the RebindableSyntax extension causes the following pieces of built-in syntax to refer to whatever is in scope, not the Prelude versions:
An integer literal 368 means âfromInteger (368::Integer)â, rather than âPrelude.fromInteger (368::Integer)â.
Fractional literals are handled in just the same way, except that the translation is fromRational (3.68::Rational).
String literals are also handled the same way, except that the translation is fromString ("368"::String).
The equality test in an overloaded numeric pattern uses whatever (==) is in scope.
The subtraction operation, and the greater-than-or-equal test, in n+k patterns use whatever (-) and (>=) are in scope.
Negation (e.g. â- (f x)â) means ânegate (f x)â, both in numeric patterns, and expressions.
Conditionals (e.g. âif e1 then e2 else e3â) means âifThenElse e1 e2 e3â. However case expressions are unaffected.
âDoâ notation is translated using whatever functions (>>=), (>>), and fail, are in scope (not the Prelude versions). List comprehensions, mdo (The recursive do-notation), and parallel array comprehensions, are unaffected.
Arrow notation (see Arrow notation) uses whatever arr, (>>>), first, app, (|||) and loop functions are in scope. But unlike the other constructs, the types of these functions must match the Prelude types very closely. Details are in flux; if you want to use this, ask!
List notation, such as [x,y] or [m..n] can also be treated via rebindable syntax if you use -XOverloadedLists; see Overloaded lists.
An overloaded label â#fooâ means âfromLabel @"foo"â, rather than âGHC.OverloadedLabels.fromLabel @"foo"â (see Overloaded labels).
RebindableSyntax implies NoImplicitPrelude.
In all cases (apart from arrow notation), the static semantics should be that of the desugared form, even if that is a little unexpected. For example, the static semantics of the literal 368 is exactly that of fromInteger (368::Integer); itâs fine for fromInteger to have any of the types:
fromInteger :: Integer -> Integer fromInteger :: forall a. Foo a => Integer -> a fromInteger :: Num a => a -> Integer fromInteger :: Integer -> Bool -> Bool
Be warned: this is an experimental facility, with fewer checks than usual. Use -dcore-lint to typecheck the desugared program. If Core Lint is happy you should be all right.
Prelude¶
If you call your custom Prelude module Prelude and place it in a file called Prelude.hs, then your custom Prelude will be implicitly imported instead of the default Prelude.
Here is an example that compiles:
$ cat Prelude.hs module Prelude where a = () $ cat B.hs module B where foo = a $ ghc Prelude.hs B.hs [1 of 2] Compiling Prelude ( Prelude.hs, Prelude.o ) [2 of 2] Compiling B ( B.hs, B.o )
The new Prelude is implicitly imported in B.hs.
Here is an example that does not compile:
$ cat Prelude.hs module Prelude where foo = True $ ghc Prelude.hs [1 of 1] Compiling Prelude ( Prelude.hs, Prelude.o ) Prelude.hs:3:7: error: Data constructor not in scope: True
The original Prelude module is shadowed by the custom Prelude in this case. To include the original Prelude in your custom Prelude, you can explicitly import it with the -XPackageImports option and import "base" Prelude.
Writing an explicit import of Prelude will suppress the implicit import. This allows you to refine the implicit import:
$ cat Prelude.hs
module Prelude where
a = ()
b = ()
$ cat B.hs
module B where
import Prelude (b)
-- a is now not in scope, there is no implicit Prelude import
foo = a
qux = b
$ ghc Prelude.hs B.hs
[1 of 2] Compiling Prelude ( Prelude.hs, Prelude.o )
[2 of 2] Compiling B ( B.hs, B.o )
B.hs:5:7: error: [GHC-88464]
Variable not in scope: a
Suggested fix:
Add 'a' to the import list in the import of 'Prelude'
(at B.hs:3:1-18).
|
5 | foo = a
|
Note
Importing a module named Prelude with the PackageImports extension will not affect the implicit Prelude import:
> cat Prelude.hs
module Prelude where
a = ()
> cat B.hs
{-# LANGUAGE PackageImports #-}
module B where
import "base" Prelude
-- This definition comes from the implicit prelude import
foo = a
-- These definitions come from the package import
baz :: Int -> Int -> Int
baz = (+)
> ghc B.hs
[1 of 2] Compiling Prelude ( Prelude.hs, Prelude.o )
[2 of 2] Compiling B ( B.hs, B.o )
If you want to use package imports then you should explicitly disable the import of the implicit prelude module by enabling NoImplicitPrelude.
RebindableSyntax¶
RebindableSyntax does not apply to any code generated from a deriving clause or declaration. To see why, consider the following code:
{-# LANGUAGE RebindableSyntax, OverloadedStrings #-}
newtype Text = Text String
fromString :: String -> Text
fromString = Text
data Foo = Foo deriving Show
This will generate code to the effect of:
instance Show Foo where showsPrec _ Foo = showString "Foo"
But because RebindableSyntax and OverloadedStrings are enabled, the "Foo" string literal would now be of type Text, not String, which showString doesnât accept! This causes the generated Show instance to fail to typecheck. Itâs hard to imagine any scenario where it would be desirable have RebindableSyntax behavior within derived code, so GHC simply ignores RebindableSyntax entirely when checking derived code.
Allow the use of post-fix operators
The PostfixOperators extension enables a small extension to the syntax of left operator sections, which allows you to define postfix operators. The extension is this: for any expression e and operator (!), the left section
is equivalent (from the point of view of both type checking and execution) to the expression
The strict Haskell 98 interpretation is that the section is equivalent to
That is, the operator must be a function of two arguments. GHC allows it to take only one argument, and that in turn allows you to write the function postfix.
The extension does not extend to the left-hand side of function definitions; you must define such a function in prefix form.
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4