Free Sections

Haskell Syntax Extension

by Andrew Seniuk

  f :: Int -> Bool -> Char -> Float -> String
  sect = f 4 True  -- Char -> Float -> String

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 ]_

An more complex example...

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.

  {-# 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] ]

  data D a = D Int [a]

  v = map3  _[ dreadme tableA __ (repeat True,__) (D __ [(+),(*)]) ]_
            [tableA,tableB]
            [0..]
            [-1,1]

  v = map3  (\ fs0 fs1 fs2 -> dreadme tableA fs0 (repeat True,fs1) (D fs2 [(+),(*)]) )
            [tableA,tableB]
            [0..]
            [-1,1]

  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]
  filter' (p:ps) (x:xs) = if p then x:filter' ps xs
                               else   filter' ps xs
  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' (f:fs) xs ys = (map2 f xs ys) : map2' fs xs ys
  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' (p:ps) (x:xs) = if p then x:filter' ps xs
                               else   filter' ps xs
  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' [] _ _ = []
  map2' (f:fs) xs ys = (map2 f xs ys) : map2' fs xs ys
  map3 :: (a->b->c->d) -> [a] -> [b] -> [c] -> [d]
  map3 f _ _ [] = []
  map3 f _ [] _ = []
  map3 f [] _ _ = []
  map3 f (x:xs) (y:ys) (z:zs) = (f x y z) : map3 f xs ys zs
  main = print v

Some virtues of the new syntax

• 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

Implementation

Background

Other details

Temporary names created by FreeSect are guaranteed to be unique among names referenced within a module. 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

How to run it

Feedback