Functional Programming

Haskell » History » Revision 4

Revision 3 (Grigoriy Volkov, 12/11/2018 03:34 PM) → Revision 4/90 (Grigoriy Volkov, 12/14/2018 04:41 PM)

h1. Haskell 

 "Haskell Cheatsheet":http://bxt.github.io/Ludus/haskell-cheatsheet/ 

 h2. libs 

 * "concat":https://github.com/conal/concat ("z3cat":https://github.com/jwiegley/z3cat/blob/master/test/Main.hs || "smt example":https://github.com/conal/concat/blob/master/examples/src/ConCat/SMT.hs) — *"Compiling to categories":http://conal.net/papers/compiling-to-categories/* — compiler plugin for translating normal Haskell functions (on standard types) to SMT, etc. 
 * "SBV: SMT Based Verification":https://leventerkok.github.io/sbv/ — translates Haskell functions on custom symbolic types 
 * "refined":http://nikita-volkov.github.io/refined/ — refinement types <pre>type ProperFraction = Refined (And (Not (LessThan 0)) (Not (GreaterThan 1))) Double</pre> 
 * "hedgehog":https://github.com/hedgehogqa/haskell-hedgehog — random test gen (QuickCheck) 
 * "GHC.Stack":https://hackage.haskell.org/package/base-4.10.0.0/docs/GHC-Stack.html — can get code position for DSL 
 * "Data.Sequence":http://hackage.haskell.org/package/containers-0.6.0.1/docs/Data-Sequence.html — list with fast append on both sides 

 h2. exts 

 * "RebindableSyntax":https://ocharles.org.uk/guest-posts/2014-12-06-rebindable-syntax.html — overloading built-in operators / do notation 
 * "NullaryTypeClasses":https://ocharles.org.uk/posts/2014-12-10-nullary-type-classes.html — global implementation of one thing 

 h2. snippets 

 h3. Using Maybe Monad for checks 

 <pre> 
 {-# LANGUAGE LambdaCase, RecordWildCards #-} 

 import Data.Maybe (isJust, mapMaybe) 
 import Data.List (nub) 

 data Group = X25519 | Secp384 
            deriving (Eq) 

 data KeyShareData = KeyShareClientHello [Group] 
                   | KeyShareHelloRetryRequest Group 

 data Ext = SupportedGroups [Group] 
          | KeyShares KeyShareData 

 check :: [Ext] -> [Ext] -> Bool 
 check eCH eHRR = isJust $ do 
   sgCH <- exactlyOne $ mapMaybe (\case SupportedGroups gs -> Just gs; _ -> Nothing) eCH 
   continueIf $ nub sgCH == sgCH -- no duplicates allowed 
   ksCH <- (\case KeyShareClientHello gs -> Just gs; _ -> Nothing) =<< 
     exactlyOne (mapMaybe (\case KeyShares ks -> Just ks; _ -> Nothing) eCH) 
   ksHRR <- (\case KeyShareHelloRetryRequest g -> Just g; _ -> Nothing) =<< 
     exactlyOne (mapMaybe (\case KeyShares ks -> Just ks; _ -> Nothing) eHRR) 
   continueIf $ nub ksCH == ksCH -- no duplicates allowed 
   continueIf $ ksHRR `elem` sgCH -- group must be supported 
   continueIf $ ksHRR `notElem` ksCH -- key share must not have been already sent 

 exactlyOne :: [a] -> Maybe a 
 exactlyOne [x] = Just x 
 exactlyOne _ = Nothing 

 continueIf :: Bool -> Maybe () 
 continueIf True = Just () 
 continueIf False = Nothing 
 </pre>