diff --git a/Doc/index.html b/Doc/index.html
--- a/Doc/index.html
+++ b/Doc/index.html
@@ -10,12 +10,22 @@
margin-top: 24px;
margin-bottom: 16px;
}
-pre-inline {
+pre, pre2 {
+ font-weight: bold;
+}
+pre2, pre3 {
font-family: "Courier New";
padding: 0 0 0 0;
margin: 0 0 0 0;
border: 0 0 0 0;
}
+pre4 {
+ font-family: "Courier New";
+ font-size: 12pt;
+ padding: 0 0 0 0;
+ margin: 0 0 0 0;
+ border: 0 0 0 0;
+}
pre.showhide2 {
font-family: "Courier New";
padding: 0 0 0 0;
@@ -28,6 +38,12 @@
margin: 0 0 0 0;
border: 0 0 0 0;
}
+pre.showhide4 {
+ font-family: "Courier New";
+ padding: 0 0 0 0;
+ margin: 0 0 0 0;
+ border: 0 0 0 0;
+}
A:link { font-weight: bold; color: #27e; text-decoration: none; }
A:visited { font-weight: bold; color: #14a; text-decoration: none; }
A:hover { font-weight: bold; color: #795; text-decoration: none; }
@@ -56,35 +72,44 @@
The reader is strongly encouraged to navigate to
fremissant.net/freesect as these documents are currently experiencing rapid growth and refinement. The local files represent the best documentation available at packaging of this v.0.0.5 source distribution (March 11, 2012).
- f :: Int -> Bool -> Char -> Float -> String
- sect = f 4 True -- Char -> Float -> String
+ f :: Int -> Bool -> Char -> Float -> String
+ f 4 True -- Char -> Float -> String
-By using wildcard symbols (__, a double-underscore), any subset of values occurring in a RHS context can be deferred, in the same spirit as partial function application.
-Special brackets (_[…]_) are used to delimit the lexical extent (or context) of the section, although these could sometimes be omitted (details below).
-The free section is then a function with arity at least equal to the number of wildcards, and behaves as if a helper function had been defined which shuffled the argument order of the functional expression, turning it into a normal section.
+By using wildcard symbols (__, a
+double-underscore), any subset of values occurring in a RHS context can
+be deferred, in the same spirit as partial function application.
+Special brackets (_[…]_) are used to delimit
+the lexical extent (or context) of the section, although these can
+sometimes be omitted (details below).
+The free section is then a function with arity at least equal to the
+number of wildcards, and behaves as if a helper function had been
+defined which shuffled the argument order of the functional expression,
+turning it into a normal section.
-Some examples, including illustrations of context inferencing.
-
-- _[ __ ]_ <=> ( __ ) <=> id
-- map _[ (+) __ 2 ]_ [1,2,3] => [3,4,5]
-- map ( (+) __ 2 ) [1,2,3] => [3,4,5]
-- zipWith $ f __ $ g __ z <=> zipWith _[ f __ $ g __ z ]_
-
+Philosophically, use of this sort of syntax promotes "higher-order programming", since any expression can so easily be made into a function, in numerous ways, simply by replacing parts of it with freesect wildcards.
+That this is worthwhile is demonstrated by the frequent usefulness of sections.
-An more complex example...
+Some examples, including illustrations of context inferencing:
+
+- _[ __ ]_ <=> ( __ ) <=> id
+- map _[ (+) __ 2 ]_ [1,2,3] => [3,4,5]
+- map ( (+) __ 2 ) [1,2,3] => [3,4,5]
+- zipWith $ f __ $ g __ z <=> zipWith _[ f __ $ g __ z ]_
+
-Here I depict a situation where some API provides you with the dreaded dreadme function, which you have need of using.
-The example is designed to show that you can really put the __'s anywhere on a RHS that an expression can go.
+For a more complex example, consider a situation where some API provides you with the dreaded dreadme function, which you have need of using.
+The example is designed to show that you can really put the __'s anywhere on a RHS that an expression can go.
-
- {-# LANGUAGE FreeSections #-} -- use "{- #" if compiling with ghc -F
+ {-# LANGUAGE FreeSections #-} -- use "{- #" if compiling with ghc -F
tableA = [ [1,2,3], [4,5], [6,7,8,9] ]
tableB = [ [9,8,7], [6,5], [4,3,2,1] ]
@@ -97,10 +122,9 @@
[-1,1]
-FreeSect rewrites the RHS of rslt (where fs0…fs2 must be fresh identifiers) to:
+FreeSect rewrites the RHS of v (where fs0…fs2 must be fresh identifiers) to:
-
- v = map3 (\ fs0 fs1 fs2 -> dreadme tableA fs0 (repeat True,fs1) (D fs2 [(+),(*)]) )
+ v = map3 (\ fs0 fs1 fs2 -> dreadme tableA fs0 (repeat True,fs1) (D fs2 [(+),(*)]) )
[tableA,tableB]
[0..]
[-1,1]
@@ -108,38 +132,33 @@
(Here is the rest of the code to make a closed module.)
-
- dreadme :: [[Int]] -> [[Int]] -> ([Bool],Int) -> D (Int->Int->Int) -> String
+ dreadme :: [[Int]] -> [[Int]] -> ([Bool],Int) -> D (Int->Int->Int) -> String
dreadme tabA tabB (ps,q) (D wt flst)
- = show $ map (!!q) $ map2 f tabA tabB
- where f :: [Int] -> [Int] -> [Bool]
- f rowA rowB = map2 (==) (repeat rowA)
- $ map2' flst' rowB (map ((q+).(wt*)) rowB)
- flst' = filter' ps flst
-(base cases)
- filter' :: [Bool] -> [a] -> [a]
+ = show $ map (!!q) $ map2 f tabA tabB
+ where f rowA rowB = map2 (<) (repeat rowA)
+ $ map2' (filter' ps flst) rowB (map ((q+).(wt*)) rowB)
+(base cases) filter' :: [Bool] -> [a] -> [a]
filter' (p:ps) (x:xs) = if p then x:filter' ps xs
else filter' ps xs
- map2 :: (a->b->c) -> [a] -> [b] -> [c]
+ map2 :: (a->b->c) -> [a] -> [b] -> [c]
map2 f (x:xs) (y:ys) = (f x y) : map2 f xs ys
- map2' :: [a->a->a] -> [a] -> [a] -> [[a]]
+ map2' :: [a->a->a] -> [a] -> [a] -> [[a]]
map2' (f:fs) xs ys = (map2 f xs ys) : map2' fs xs ys
- map3 :: (a->b->c->d) -> [a] -> [b] -> [c] -> [d]
+ map3 :: (a->b->c->d) -> [a] -> [b] -> [c] -> [d]
map3 f (x:xs) (y:ys) (z:zs) = (f x y z) : map3 f xs ys zs
-
- filter' :: [Bool] -> [a] -> [a]
+
filter' :: [Bool] -> [a] -> [a]
filter' (p:ps) (x:xs) = if p then x:filter' ps xs
else filter' ps xs
- map2 :: (a->b->c) -> [a] -> [b] -> [c]
+ map2 :: (a->b->c) -> [a] -> [b] -> [c]
map2 f _ [] = []
map2 f [] _ = []
map2 f (x:xs) (y:ys) = (f x y) : map2 f xs ys
- map2' :: [a->a->a] -> [a] -> [a] -> [[a]]
- map2' _ _ [] = []
- map2' _ [] _ = []
+ map2' :: [a->a->a] -> [a] -> [a] -> [[a]]
map2' [] _ _ = []
+ map2' _ [] _ = []
+ map2' _ _ [] = []
map2' (f:fs) xs ys = (map2 f xs ys) : map2' fs xs ys
- map3 :: (a->b->c->d) -> [a] -> [b] -> [c] -> [d]
+ map3 :: (a->b->c->d) -> [a] -> [b] -> [c] -> [d]
map3 f _ _ [] = []
map3 f _ [] _ = []
map3 f [] _ _ = []
@@ -149,65 +168,92 @@
Some virtues of the new syntax
-Although the rewrite provided by the extension is simple, there are advantages of free sections relative to explicitly written lambdas:
+Although the rewrite provided by the extension is simple, there are
+advantages of free sections relative to explicitly written lambdas:
- the lambda forces the programmer to invent names for the wildcards
- the lambda forces the programmer to repeat those names, and place them correctly
- freesect wildcards stand out vividly, indicating where the awaited expressions will go
- reading the lambda requires visual pattern-matching between left and right sides of the lambda
-
- the lambda is longer overall, and prefaces the expression of interest with something like micro-boilerplate
+- the lambda is longer overall, and prefaces the expression of interest with something like micro-boilerplate
On the other hand, the lambda is more powerful and can achieve arbitrary permutations without further ado.
Implementation
-The implementation seems to be working.
-The freesect package can also be installed from hackage.haskell.org, for instance using cabal-install.
-I offer fair warning that I'm not a good Haskell coder, but this does demonstrate how a person of modest abilities can use SYB with HSE to create a robust Haskell syntax extension.
+The implementation seems to be working.
+The freesect package can also be installed from Hackage, for instance using cabal-install.
+I offer fair warning that I'm not a good Haskell coder, but this does demonstrate how a person of modest abilities can use SYB with HSE to create a robust Haskell syntax extension.
+Default context inferencing
+
+A default context is automatically applied when the _[…]_ grouping syntax is omitted.
+Defining this default can be tricky, and a bit arbitrary, so for robust code it's best to use explicit bracketing.
+As of v.0.0.5, when the _[…]_ are omitted, the defaulting rules are as follows:
+The semilattice join of all unbacketed wildcards in a RHS are given context of the innermost enclosing parentheses or infix $ operation.
+If no such parentheses or infix $ are present, the whole RHS becomes the default context.
+Some of the examples at the top of the page demonstrate these rules.
+One hopes that the default will result in a type error, should the inferred context differ from the intended.
+I haven't thought of any situation where more than one bracketing of freesect wildcards yield typeable expressions, but neither have I ruled it out.
+A context inference policy based on typeability tests among various possible scopes would also be possible...
+
Background
-There was discussion about this on the #haskell IRC channel.
-Strangely, eyebloom suggested the same thing about an hour after I had started making inquiries about how to go about writing an extension, and this is the one I had in mind.
-It's an extraordinary coincidence, as I first sketched the idea in 2003, and had never seen it mentioned per se, beyond discussions of point-free and the like.
-(Despite eyebloom asking to be contacted if I wanted to work on this, my email was never answered.)
-Some of the examples mentioned in the chat have been presented above, to show how FreeSect deals with them.
+There was discussion
+ about this on the #haskell IRC channel.
+Strangely, <eyebloom> suggested the same thing an hour after I had started making inquiries about how to go about writing an extension -- and this is the one I had in mind.
+It's an extraordinary coincidence, as I first sketched the idea in 2003, and had never seen it mentioned per se, beyond discussions of point-free and the like.
+(Despite <eyebloom> asking to be contacted if I wanted to work on this, my email was never answered; I didn't run off with their idea!)
+The principal example from that chat is described here.
+
+
+ <dolio> map (foo (g _) x) (h _)
+ <dolio> Matter of fact, what does "map (foo (g _) x) (h _)" mean?
+
+Given the present context inferencing policy,
+
+ (map (foo (g _) x) (h _)) => \ y z -> map (foo (g y) x) (h z)
+
+The outer parentheses might be necessary, depending on the larger context of the expression.
+This interpretation might not be what the programmer intended, in which case at least a $ is needed
+
+ (map $ (foo (g __) x) (h __)) => map ( \ y z -> (foo (g y) x) (h z) )
+
+Finally, if two separate free sections were intended, the programmer would need to use _[…]_ bracketing for at least one of them
+
+ map _[foo (g __) x]_ _[h __]_
+ <=> map (foo (g __) x) _[h __]_
+ <=> map _[foo (g __) x]_ (h __)
+ <=> (map _[foo (g __) x]_ $ h __)
+
+all of which are rewritten by FreeSect to
+
+ map (\y->foo (g y) x) (\z->h z)
+
+This interpretation cannot by typed, since the second argument of map must be have kind *, while \z->h z has kind *->*.
Other details
Nested free sections work correctly, thanks to bottom-up traversal.
-Note that, as wildcards are syntactically indistinguishable, it is impossible for an outermore freesect to place a wildcard inside an innermore freesect.
+Note that, as wildcards are syntactically indistinguishable, it is impossible for an enclosing freesect to have a wildcard inside any enclosed freesect.
-Temporary names created by FreeSect are guaranteed to be unique among names referenced within a module.
+Fresh identifiers generated by FreeSect are guaranteed to be unique among names referenced within a module.
+There is no danger of exporting these names inadvertently, as they never have top-level scope.
Imported names which are in scope but never used will not incur conflicts.
-Also, there is no danger of exporting the temporary names inadvertently, as they never have top-level scope.
-A default context is automatically applied when the _[…]_ grouping syntax is omitted.
-Defining this default can be tricky, and a bit arbitrary, so for robust code it's best to use explicit bracketing.
-As of v.0.0.5, when the _[…]_ are omitted, the defaulting rules are as follows:
-The semilattice join of all unbacketed wildcards in a RHS are given context of the innermost enclosing parentheses or infix $ operation.
-If no such parentheses or infix $ are present, the whole RHS becomes the default context.
-Some of the examples at the top of the page demonstrate these rules.
-One hopes that the default will result in a type error, should the inferred context differ from the intended.
-I haven't thought of any situation where more than one bracketing of freesect wildcards yield typeable expressions, but neither have I ruled it out.
-
-Philosophically, use of this sort of syntax promotes "higher-order programming", since any expression can so easily be made into a function, in numerous ways, simply by replacing parts of it with freesect wildcards.
-That this is worthwhile is demonstrated frequently by usefulness of sections.
-
-
Work in progress
A few things don't work quite right yet.
-Free sections in let expressions are one.
-Also, guarded RHS's are not yet handled.
+Guarded RHS's are not yet handled.
+Default free section contexts in let expressions need to be parenthesised.
Work continues...
How to run it
The extension runs as a preprocessor.
This can be done with or without the knowledge of GHC.
-If you use ghc -F (see scripts in the download), then unfortunately GHC checks language pragmas before preprocessing, which means you cannot declare {-# LANGUAGE FreeSections #-} at the top.
+If you use ghc -F (see scripts in the download), then unfortunately GHC checks language pragmas before preprocessing, which means you cannot declare {-# LANGUAGE FreeSections #-} at the top.
Although the patched HSE is capable of rejecting source which uses free sections without the pragma, this feature is disabled for interoperability with GHC.
-All compilers are supported by running freesect as an independent preprocessor, but there are some inconveniences involving temporary files.
+All compilers are supported by running FreeSect as an independent preprocessor, but there are some inconveniences involving temporary files.
Feedback
@@ -215,10 +261,10 @@
Kind Reg'ds,
Andrew Seniuk
-(rasfar on #haskell)
+<rasfar> on #haskell
Feb. 29, 2012
-
-