Javier Neira's List: uned_declarative_programming

• • This is like a list comprehension i think
  Add Sticky Note
• Backtracking: The lazy way to code
• type Choice a = [a]  choose :: [a] -> Choice a choose xs = xs
• Because Haskell doesn’t compute answers until we ask for them, we get the actual backtracking for free!
• The missing function is almost too trivial to mention: Given a single value of type a, we need a convenient way to construct a value of type Choice a:
• More math trivia: return is also known as unit and η. That’s a lot of names for a very simple idea.)
• makePairs =   choose [1,2,3] >>= (\x ->  choose [4,5,6] >>= (\y ->  return (x,y)))
• makePairs' = do  x <- choose [1,2,3]  y <- choose [4,5,6]  return (x,y)
• Every monad has three pieces: return, map and join.

7 more annotations...

• 16.2  Incremental Array Updates

   

   The operator (//) takes an array and a list of pairs and returns an array identical to the left argument except that it has been updated by the associations in the right argument. (As with the array function, the indices in the association list must be unique for the updated elements to be defined.) For example, if m is a 1-origin, n by n matrix, then m//[((i,i), 0) | i <- [1..n]] is the same matrix, except with the diagonal zeroed.
• -- A rectangular subarray
   subArray :: (Ix a) => (a,a) -> Array a b -> Array a b
   subArray bnds = ixmap bnds (\i->i)
   
   -- A row of a matrix
   row :: (Ix a, Ix b) => a -> Array (a,b) c -> Array b c
   row i x = ixmap (l',u') (\j->(i,j)) x where ((_,l'),(_,u')) = bounds x
   
   -- Diagonal of a matrix (assumed to be square)
   diag :: (Ix a) => Array (a,a) b -> Array a b
   diag x = ixmap (l,u) (\i->(i,i)) x
          where 
            ((l,_),(u,_)) = bounds x
   
   -- Projection of first components of an array of pairs
   firstArray :: (Ix a) => Array a (b,c) -> Array a b
   firstArray = fmap (\(x,y)->x)

• data NestedList a = Elem a | List [NestedList a]   flatten :: NestedList a -> [a] flatten (Elem x) = [x] flatten (List x) = concatMap flatten x

• compress :: Eq a => [a] -> [a] compress = map head . group

   

  We simply group equal values together (group), then take the head of each.  Note that (with GHC) we must give an explicit type to compress otherwise we get: 

• I will point out that return is, in fact, not a return  statement. It’s a function, and an inappropriately named function, at that.  Writing return () in your do block will  not cause the function to return.
• The curry and uncurry functions stand in for \f  x y -> f (x, y)
• putStrLn (take 12 (map foo (bar ++ "ack")))
  
  -- ...can be rewritten as...
  putStrLn $ take 12 $ map foo $ bar ++ "ack"
  
  (putStrLn . take 12 . map foo) (bar ++ "ack")
  
  putStrLn . take 12 . map foo $ bar ++ "ack"
  
• putStrLn (take 12 (map foo (bar ++ "ack")))
  
  
• anywhere you might write \x -> foo x [1..10], you should instead  write flip foo [1..10], where flip is a standard  Prelude function that flips the first
• The curry and uncurry functions stand in for \f  x y -> f (x, y) and \f (x, y) -> f x y, respectively.
• anywhere you might write \x -> foo x [1..10], you should instead  write flip foo [1..10], where flip is a standard  Prelude function that flips the first two arguments of whatever  function you give it
• -- Actual definitions:
f $ x = f x
(f . g) x = f (g x)

-- Some quick examples of using these. The following line...
putStrLn (take 12 (map foo (bar ++ "ack")))

-- ...can be rewritten as...
putStrLn $ take 12 $ map foo $ bar ++ "ack"

(putStrLn . take 12 . map foo) (bar ++ "ack")

putStrLn . take 12 . map foo $ bar ++ "ack"

• two arguments of whatever

7 more annotations...

• data Suit = Club | Diamond | Heart | Spade  deriving (Read, Show, Enum, Eq, Ord)    data CardValue = Two | Three | Four  | Five | Six | Seven | Eight | Nine | Ten   | Jack | Queen | King | Ace  deriving (Read, Show, Enum, Eq, Ord)
• data Card = Card {value::CardValue,   suit::Suit}  deriving (Read, Show, Eq)
• type Deck = [Card]    deck::Deck  deck = [Card val su | val <- [Two .. Ace], su <- [Club .. Spade]]

1 more annotation...